/************************************************************************
Test for the server

(c) 1996-1997 Innobase Oy

Created 2/16/1996 Heikki Tuuri
*************************************************************************/

#include "os0proc.h"
#include "sync0sync.h"
#include "ut0mem.h"
#include "mem0mem.h"
#include "mem0pool.h"
#include "data0data.h"
#include "data0type.h"
#include "dict0dict.h"
#include "buf0buf.h"
#include "buf0flu.h"
#include "os0file.h"
#include "os0thread.h"
#include "fil0fil.h"
#include "fsp0fsp.h"
#include "rem0rec.h"
#include "rem0cmp.h"
#include "mtr0mtr.h"
#include "log0log.h"
#include "log0recv.h"
#include "page0page.h"
#include "page0cur.h"
#include "trx0trx.h"
#include "dict0boot.h"
#include "trx0sys.h"
#include "dict0crea.h"
#include "btr0btr.h"
#include "btr0pcur.h"
#include "btr0cur.h"
#include "btr0sea.h"
#include "rem0rec.h"
#include "srv0srv.h"
#include "que0que.h"
#include "com0com.h"
#include "usr0sess.h"
#include "lock0lock.h"
#include "trx0roll.h"
#include "trx0purge.h"
#include "row0ins.h"
#include "row0sel.h"
#include "row0upd.h"
#include "row0row.h"
#include "lock0lock.h"
#include "ibuf0ibuf.h"
#include "pars0pars.h"
#include "btr0sea.h"

bool	measure_cont	= FALSE;

os_file_t	files[1000];

mutex_t		ios_mutex;
ulint		ios;
ulint		n[10];

mutex_t		incs_mutex;
ulint		incs;

byte		rnd_buf[67000];

ulint		glob_var1	= 0;
ulint		glob_var2	= 0;

mutex_t		mutex2;

mutex_t		test_mutex1;
mutex_t		test_mutex2;

mutex_t*	volatile mutexes;

bool		always_false	= FALSE;

ulint*		test_array;

/************************************************************************
Io-handler thread function. */

ulint
handler_thread(
/*===========*/
	void*	arg)
{
	ulint	segment;
	ulint	i;
	
	segment = *((ulint*)arg);

	printf("Io handler thread %lu starts\n", segment);

	for (i = 0;; i++) {
		fil_aio_wait(segment);

		mutex_enter(&ios_mutex);
		ios++;
		mutex_exit(&ios_mutex);
	}

	return(0);
}

/*************************************************************************
Creates or opens the log files. */

void
create_log_files(void)
/*==================*/
{
	bool	ret;
	ulint	i, k;
	char	name[20];

	printf("--------------------------------------------------------\n");
	printf("Create or open log files\n");

	strcpy(name, "logfile00");

	for (k = 0; k < srv_n_log_groups; k++) {

	    for (i = 0; i < srv_n_log_files; i++) {

		name[6] = (char)((ulint)'0' + k);
		name[7] = (char)((ulint)'0' + i);
	
		files[i] = os_file_create(name, OS_FILE_CREATE, OS_FILE_AIO,
									&ret);
		if (ret == FALSE) {
			ut_a(os_file_get_last_error() ==
						OS_FILE_ALREADY_EXISTS);
	
			files[i] = os_file_create(
				name, OS_FILE_OPEN, OS_FILE_AIO, &ret);
			ut_a(ret);
		} else {
			ut_a(os_file_set_size(files[i],
						8192 * srv_log_file_size, 0));
		}

		ret = os_file_close(files[i]);
		ut_a(ret);

		if (i == 0) {
			fil_space_create(name, k + 100, FIL_LOG);
		}

		ut_a(fil_validate());

		fil_node_create(name, srv_log_file_size, k + 100);
	    }
	    
	    fil_space_create(name, k + 200, FIL_LOG);
	    	    
	    log_group_init(k, srv_n_log_files,
				srv_log_file_size * UNIV_PAGE_SIZE,
							k + 100, k + 200);
	}
}

/*************************************************************************
Creates the files for the file system test and inserts them to the file
system. */

void
create_files(void)
/*==============*/
{
	bool		ret;
	ulint		i, k;
	char		name[20];
	os_thread_t	thr[10];
	os_thread_id_t	id[10];

	printf("--------------------------------------------------------\n");
	printf("Create or open database files\n");
	
	strcpy(name, "tsfile00");

	for (k = 0; k < 2 * srv_n_spaces; k += 2) {
	    for (i = 0; i < srv_n_files; i++) {

		name[6] = (char)((ulint)'0' + k);
		name[7] = (char)((ulint)'0' + i);
	
		files[i] = os_file_create(name, OS_FILE_CREATE,
						OS_FILE_NORMAL, &ret);
		if (ret == FALSE) {
			ut_a(os_file_get_last_error() ==
						OS_FILE_ALREADY_EXISTS);
	
			files[i] = os_file_create(
				name, OS_FILE_OPEN, OS_FILE_NORMAL, &ret);
			ut_a(ret);
		} else {
			ut_a(os_file_set_size(files[i],
					UNIV_PAGE_SIZE * srv_file_size, 0));
			/* Initialize the file contents to a random value */
			/*		
			for (j = 0; j < srv_file_size; j++) {

				for (c = 0; c < UNIV_PAGE_SIZE; c++) {

					rnd_buf[c] = 0xFF;
				}

				os_file_write(files[i], rnd_buf,
						UNIV_PAGE_SIZE * j, 0,
						UNIV_PAGE_SIZE);
			}
			*/
		}

		ret = os_file_close(files[i]);
		ut_a(ret);

		if (i == 0) {
			fil_space_create(name, k, FIL_TABLESPACE);
		}

		ut_a(fil_validate());

		fil_node_create(name, srv_file_size, k);
	    }
	}

	ios = 0;

	mutex_create(&ios_mutex);
	mutex_set_level(&ios_mutex, SYNC_NO_ORDER_CHECK);

	/* Create i/o-handler threads: */	

	for (i = 0; i < 9; i++) {
		n[i] = i;

		thr[i] = os_thread_create(handler_thread, n + i, id + i);
	}
}

/************************************************************************
Inits space header of space. */

void
init_spaces(void)
/*=============*/
{
	mtr_t	mtr;

	mtr_start(&mtr);

	fsp_header_init(0, srv_file_size * srv_n_files, &mtr);		

	mtr_commit(&mtr);
}

/*********************************************************************
This thread is used to measure contention of latches. */

ulint
test_measure_cont(
/*==============*/
	void*	arg)
{
	ulint	i, j;
	ulint	pcount, kcount, s_scount, s_xcount, s_mcount, lcount;
	ulint	t1count;
	ulint	t2count;

	UT_NOT_USED(arg);

	printf("Starting contention measurement\n");
	
	for (i = 0; i < 1000; i++) {

		pcount = 0;
		kcount = 0;
		s_scount = 0;
		s_xcount = 0;
		s_mcount = 0;
		lcount = 0;
		t1count	= 0;
		t2count	= 0;

		for (j = 0; j < 100; j++) {

		    if (srv_measure_by_spin) {
		    	ut_delay(ut_rnd_interval(0, 20000));
		    } else {
		    	os_thread_sleep(20000);
		    }

		    if (kernel_mutex.lock_word) {
			kcount++;
		    }

		    if (buf_pool->mutex.lock_word) {
		    	pcount++;
		    }

		    if (log_sys->mutex.lock_word) {
		    	lcount++;
		    }

		    if (btr_search_latch.reader_count) {
		    	s_scount++;
		    }

		    if (btr_search_latch.writer != RW_LOCK_NOT_LOCKED) {
		    	s_xcount++;
		    }

		    if (btr_search_latch.mutex.lock_word) {
		    	s_mcount++;
		    }

		    if (test_mutex1.lock_word) {
		    	t1count++;
		    }
		    
		    if (test_mutex2.lock_word) {
		    	t2count++;
		    }
		}

		printf(
	"Mutex res. l %lu, p %lu, k %lu s x %lu s s %lu s mut %lu of %lu\n",
		lcount, pcount, kcount, s_xcount, s_scount, s_mcount, j);

		sync_print_wait_info();

		printf(
    "log i/o %lu n non sea %lu n succ %lu n h fail %lu\n",
			log_sys->n_log_ios, btr_cur_n_non_sea,
			btr_search_n_succ, btr_search_n_hash_fail);
	}

	return(0);
}

/*********************************************************************
This thread is used to test contention of latches. */

ulint
test_sync(
/*======*/
	void*	arg)
{
	ulint	tm, oldtm;
	ulint	i, j;
	ulint	sum;
	ulint	rnd		= ut_rnd_gen_ulint();
	ulint	mut_ind;
	byte*	ptr;
	
	UT_NOT_USED(arg);

	printf("Starting mutex reservation test\n");

	oldtm = ut_clock();			

	sum = 0;
	rnd = 87354941;

	for (i = 0; i < srv_test_n_loops; i++) {
	
		for (j = 0; j < srv_test_n_free_rnds; j++) {
			rnd += 423087123;

			sum += test_array[rnd % (256 * srv_test_array_size)];
		}

		rnd += 43605677;

		mut_ind = rnd % srv_test_n_mutexes;

		mutex_enter(mutexes + mut_ind);
		
		for (j = 0; j < srv_test_n_reserved_rnds; j++) {
			rnd += 423087121;

			sum += test_array[rnd % (256 * srv_test_array_size)];
		}
		
		mutex_exit(mutexes + mut_ind);

		if (srv_test_cache_evict) {
			ptr = (byte*)(mutexes + mut_ind);

			for (j = 0; j < 4; j++) {
				ptr += 256 * 1024;
				sum += *((ulint*)ptr);
			}
		}
	}
	
	if (always_false) {
		printf("%lu", sum);
	}
	
	tm = ut_clock();	

	printf("Wall time for res. test %lu milliseconds\n", tm - oldtm);
	
	return(0);
}

/********************************************************************
Main test function. */

void 
main(void) 
/*======*/
{
	os_thread_id_t	thread_ids[1000];
	ulint		tm, oldtm;
	ulint		rnd;
	ulint		i, sum;
	byte*		ptr;
/*	mutex_t		mutex; */
	
	log_do_write = TRUE;
/*	yydebug = TRUE; */

	srv_boot("srv_init");

	os_aio_init(576, 9, 100);

	fil_init(25);

	buf_pool_init(srv_pool_size, srv_pool_size);

	fsp_init();
	log_init();

	lock_sys_create(srv_lock_table_size);

	create_files();
	create_log_files();
	
	init_spaces();

	sess_sys_init_at_db_start();
	
	trx_sys_create();

	dict_create();

	log_make_checkpoint_at(ut_dulint_max);

	printf("Hotspot semaphore addresses k %lx, p %lx, l %lx, s %lx\n",
		&kernel_mutex, &(buf_pool->mutex),
				&(log_sys->mutex), &btr_search_latch);
	
	if (srv_measure_contention) {
		os_thread_create(&test_measure_cont, NULL, thread_ids + 999);
	}

	if (!srv_log_archive_on) {

		ut_a(DB_SUCCESS == log_archive_noarchivelog());
	}

/*
	mutex_create(&mutex);

	oldtm = ut_clock();

	for (i = 0; i < 2000000; i++) {
	
		mutex_enter(&mutex);

		mutex_exit(&mutex);
	}

	tm = ut_clock();

	printf("Wall clock time for %lu mutex enter %lu milliseconds\n",
							i, tm - oldtm);
*/
	if (srv_test_sync) {
		if (srv_test_nocache) {
        		mutexes = os_mem_alloc_nocache(srv_test_n_mutexes
        						* sizeof(mutex_t));
		} else {
        		mutexes = mem_alloc(srv_test_n_mutexes
        						* sizeof(mutex_t));
        	}

        	sum = 0;

		rnd = 492314896;

		oldtm = ut_clock();

		for (i = 0; i < 4000000; i++) {

			rnd += 85967944;

			ptr = ((byte*)(mutexes)) + (rnd % (srv_test_n_mutexes
        					    	* sizeof(mutex_t)));
			sum += *((ulint*)ptr);
		}

		tm = ut_clock();

		printf(
		"Wall clock time for %lu random access %lu milliseconds\n",
							i, tm - oldtm);
		if (always_false) {
			printf("%lu", sum);
		}
	
		test_array = mem_alloc(4 * 256 * srv_test_array_size);

		for (i = 0; i < srv_test_n_mutexes; i++) {

			mutex_create(mutexes + i);
		}
	
		for (i = 0; i < srv_test_n_threads; i++) {
			os_thread_create(&test_sync, NULL, thread_ids + i);
		}
	}

	srv_master_thread(NULL);

	printf("TESTS COMPLETED SUCCESSFULLY!\n");

	os_process_exit(0);
}