- Cleanups or minor changes.

- Now addtick_timer invokes settick_timer, so keep an eye for whatever timer issues it's supposed to have.
- Removed the flush_fifo from clif_parse_TickSend until the socket problems are fixed.

git-svn-id: https://rathena.svn.sourceforge.net/svnroot/rathena/trunk@9521 54d463be-8e91-2dee-dedb-b68131a5f0ec

1 files changed, 139 insertions, 111 deletions

diff --git a/src/common/timer.c b/src/common/timer.c
index 77d88d17d..34c95fcf6 100644
--- a/src/common/timer.c
+++ b/src/common/timer.c
@@ -31,66 +31,76 @@
 
 #define TIMER_MIN_INTERVAL 50
 
+// timers
 static struct TimerData* timer_data	= NULL;
 static int timer_data_max	= 0;
 static int timer_data_num	= 0;
 
+// free timers
 static int* free_timer_list		= NULL;
 static int free_timer_list_max	= 0;
 static int free_timer_list_pos	= 0;
 
+//NOTE: using a binary heap should improve performance [FlavioJS]
+// timer heap (ordered array of tid's)
 static int timer_heap_num = 0;
 static int timer_heap_max = 0;
 static int* timer_heap = NULL;
-
-static int fix_heap_flag =0; //Flag for fixing the stack only once per tick loop. May not be the best way, but it's all I can think of currently :X [Skotlex]
+// searches for the target tick's position and stores it in pos (binary search)
+#define HEAP_SEARCH(target,from,to,pos) \
+	do { \
+		int max,pivot; \
+		pos = from; \
+		max = to; \
+		while (pos < max) { \
+			pivot = (pos + max) / 2; \
+			if (DIFF_TICK(target, timer_data[timer_heap[pivot]].tick) < 0) \
+				pos = pivot + 1; \
+			else \
+				max = pivot; \
+		} \
+	} while(0)
 
 // for debug
 struct timer_func_list {
-	int (*func)(int,unsigned int,int,int);
 	struct timer_func_list* next;
+	TimerFunc func;
 	char* name;
 };
-static struct timer_func_list* tfl_root;
+static struct timer_func_list* tfl_root = NULL;
 
 time_t start_time;
 
-#ifdef __WIN32
-/* Modified struct timezone to void - we pass NULL anyway */
-void gettimeofday (struct timeval *t, void *dummy)
-{
-	DWORD millisec = GetTickCount();
-
-	t->tv_sec = (int) (millisec / 1000);
-	t->tv_usec = (millisec % 1000) * 1000;
-}
-#endif
-
-//
-int add_timer_func_list(int (*func)(int,unsigned int,int,int), char* name)
+/// Sets the name of a timer function.
+int add_timer_func_list(TimerFunc func, char* name)
 {
 	struct timer_func_list* tfl;
 
 	if (name) {
-		tfl = (struct timer_func_list*) aCalloc (sizeof(struct timer_func_list), 1);
-		tfl->name = (char *) aMalloc (strlen(name) + 1);
-
+		for( tfl=tfl_root; tfl != NULL; tfl=tfl->next )
+		{// check suspicious cases
+			if( func == tfl->func )
+				ShowWarning("add_timer_func_list: duplicating function %08x(%s) as %s.\n",(int)tfl->func,tfl->name,name);
+			else if( strcmp(name,tfl->name) == 0 )
+				ShowWarning("add_timer_func_list: function %08X has the same name as %08X(%s)\n",(int)func,(int)tfl->func,tfl->name);
+		}
+		CREATE(tfl,struct timer_func_list,1);
 		tfl->next = tfl_root;
 		tfl->func = func;
-		strcpy(tfl->name, name);
+		tfl->name = aStrdup(name);
 		tfl_root = tfl;
 	}
 	return 0;
 }
 
-char* search_timer_func_list(int (*func)(int,unsigned int,int,int))
+/// Returns the name of the timer function.
+char* search_timer_func_list(TimerFunc func)
 {
-	struct timer_func_list* tfl = tfl_root;
-	while (tfl) {
+	struct timer_func_list* tfl;
+
+	for( tfl=tfl_root; tfl != NULL; tfl=tfl->next )
 		if (func == tfl->func)
 			return tfl->name;
-		tfl = tfl->next;
-	}
 
 	return "unknown timer function";
 }
@@ -103,18 +113,22 @@ static int gettick_count;
 
 unsigned int gettick_nocache(void)
 {
+#ifdef _WIN32
+	gettick_count = 256;
+	return gettick_cache = GetTickCount();
+#else
 	struct timeval tval;
 
 	gettimeofday(&tval, NULL);
 	gettick_count = 256;
 
 	return gettick_cache = tval.tv_sec * 1000 + tval.tv_usec / 1000;
+#endif
 }
 
 unsigned int gettick(void)
 {
-	gettick_count--;
-	if (gettick_count < 0)
+	if (--gettick_count < 0)
 		return gettick_nocache();
 
 	return gettick_cache;
@@ -124,61 +138,56 @@ unsigned int gettick(void)
  * 	CORE : Timer Heap
  *--------------------------------------
  */
-static void push_timer_heap(int index)
+/// Adds a timer to the timer_heap
+static void push_timer_heap(int tid)
 {
-	int i, j;
-	int min, max, pivot; // for sorting
+	unsigned int tick;
+	int pos;
+	int i;
 
 	// check number of element
 	if (timer_heap_num >= timer_heap_max) {
 		if (timer_heap_max == 0) {
 			timer_heap_max = 256;
-			timer_heap = (int *) aCalloc( sizeof(int) , 256);
+			CREATE(timer_heap, int, 256);
 		} else {
 			timer_heap_max += 256;
-			timer_heap = (int *) aRealloc( timer_heap, sizeof(int) * timer_heap_max);
+			RECREATE(timer_heap, int, timer_heap_max);
 			malloc_tsetdword(timer_heap + (timer_heap_max - 256), 0, sizeof(int) * 256);
 		}
 	}
 
 	// do a sorting from higher to lower
-	j = timer_data[index].tick; // speed up
+	tick = timer_data[tid].tick; // speed up
 	// with less than 4 values, it's speeder to use simple loop
 	if (timer_heap_num < 4) {
 		for(i = timer_heap_num; i > 0; i--)
+		{
 //			if (j < timer_data[timer_heap[i - 1]].tick) //Plain comparisons break on bound looping timers. [Skotlex]
-			if (DIFF_TICK(j, timer_data[timer_heap[i - 1]].tick) < 0)
+			if (DIFF_TICK(tick, timer_data[timer_heap[i - 1]].tick) < 0)
 				break;
 			else
 				timer_heap[i] = timer_heap[i - 1];
-		timer_heap[i] = index;
-	// searching by dichotomie
+		}
+		timer_heap[i] = tid;
+	// searching by dichotomy (binary search)
 	} else {
 		// if lower actual item is higher than new
 //		if (j < timer_data[timer_heap[timer_heap_num - 1]].tick) //Plain comparisons break on bound looping timers. [Skotlex]
-		if (DIFF_TICK(j, timer_data[timer_heap[timer_heap_num - 1]].tick) < 0)
-			timer_heap[timer_heap_num] = index;
+		if (DIFF_TICK(tick, timer_data[timer_heap[timer_heap_num - 1]].tick) < 0)
+			timer_heap[timer_heap_num] = tid;
 		else {
 			// searching position
-			min = 0;
-			max = timer_heap_num - 1;
-			while (min < max) {
-				pivot = (min + max) / 2;
-//				if (j < timer_data[timer_heap[pivot]].tick) //Plain comparisons break on bound looping timers. [Skotlex]
-				if (DIFF_TICK(j, timer_data[timer_heap[pivot]].tick) < 0)
-					min = pivot + 1;
-				else
-					max = pivot;
-			}
+			HEAP_SEARCH(tick,0,timer_heap_num-1,pos);
 			// move elements - do loop if there are a little number of elements to move
-			if (timer_heap_num - min < 5) {
-				for(i = timer_heap_num; i > min; i--)
+			if (timer_heap_num - pos < 5) {
+				for(i = timer_heap_num; i > pos; i--)
 					timer_heap[i] = timer_heap[i - 1];
 			// move elements - else use memmove (speeder for a lot of elements)
 			} else
-				memmove(&timer_heap[min + 1], &timer_heap[min], sizeof(int) * (timer_heap_num - min));
+				memmove(&timer_heap[pos + 1], &timer_heap[pos], sizeof(int) * (timer_heap_num - pos));
 			// save new element
-			timer_heap[min] = index;
+			timer_heap[pos] = tid;
 		}
 	}
 
@@ -190,34 +199,41 @@ static void push_timer_heap(int index)
  *--------------------------
  */
 
-int acquire_timer (void)
+/// Returns a free timer id.
+static int acquire_timer(void)
 {
-	int i;
+	int tid;
 
 	if (free_timer_list_pos) {
 		do {
-			i = free_timer_list[--free_timer_list_pos];
-		} while(i >= timer_data_num && free_timer_list_pos > 0);
+			tid = free_timer_list[--free_timer_list_pos];
+		} while(tid >= timer_data_num && free_timer_list_pos > 0);
 	} else
-		i = timer_data_num;
+		tid = timer_data_num;
 
-	if (i >= timer_data_num)
-		for (i = timer_data_num; i < timer_data_max && timer_data[i].type; i++);
-	if (i >= timer_data_num && i >= timer_data_max) {
-		if (timer_data_max == 0) {
+	if (tid >= timer_data_num)
+		for (tid = timer_data_num; tid < timer_data_max && timer_data[tid].type; tid++);
+	if (tid >= timer_data_num && tid >= timer_data_max)
+	{// expand timer array
+		if (timer_data_max == 0)
+		{// create timer data (1st time)
 			timer_data_max = 256;
-			timer_data = (struct TimerData*) aCalloc( sizeof(struct TimerData) , timer_data_max);
-		} else {
+			CREATE(timer_data, struct TimerData, timer_data_max);
+		} else
+		{// add more timers
 			timer_data_max += 256;
-			timer_data = (struct TimerData *) aRealloc( timer_data, sizeof(struct TimerData) * timer_data_max);
+			RECREATE(timer_data, struct TimerData, timer_data_max);
 			malloc_tsetdword(timer_data + (timer_data_max - 256), 0, sizeof(struct TimerData) * 256);
 		}
 	}
 
-	return i;
+	if (tid >= timer_data_num)
+		timer_data_num = tid + 1;
+
+	return tid;
 }
 
-int add_timer(unsigned int tick,int (*func)(int,unsigned int,int,int), int id, int data)
+int add_timer(unsigned int tick,TimerFunc func, int id, int data)
 {
 	int tid = acquire_timer();
 
@@ -229,13 +245,10 @@ int add_timer(unsigned int tick,int (*func)(int,unsigned int,int,int), int id, i
 	timer_data[tid].interval = 1000;
 	push_timer_heap(tid);
 
-	if (tid >= timer_data_num)
-		timer_data_num = tid + 1;
-
 	return tid;
 }
 
-int add_timer_interval(unsigned int tick, int (*func)(int,unsigned int,int,int), int id, int data, int interval)
+int add_timer_interval(unsigned int tick, TimerFunc func, int id, int data, int interval)
 {
 	int tid;
 
@@ -254,13 +267,10 @@ int add_timer_interval(unsigned int tick, int (*func)(int,unsigned int,int,int),
 	timer_data[tid].interval = interval;
 	push_timer_heap(tid);
 
-	if (tid >= timer_data_num)
-		timer_data_num = tid + 1;
-
 	return tid;
 }
 
-int delete_timer(int id, int (*func)(int,unsigned int,int,int))
+int delete_timer(int id, TimerFunc func)
 {
 	if (id <= 0 || id >= timer_data_num) {
 		ShowError("delete_timer error : no such timer %d (%08x(%s))\n", id, (int)func, search_timer_func_list(func));
@@ -281,41 +291,59 @@ int delete_timer(int id, int (*func)(int,unsigned int,int,int))
 
 int addtick_timer(int tid, unsigned int tick)
 {
-	return timer_data[tid].tick += tick;
+	// Doesn't adjust the timer position. Might be the root of the FIXME in settick_timer. [FlavioJS]
+	//return timer_data[tid].tick += tick;
+	return settick_timer(tid, timer_data[tid].tick+tick);
 }
 
 //Sets the tick at which the timer triggers directly (meant as a replacement of delete_timer + add_timer) [Skotlex]
 //FIXME: DON'T use this function yet, it is not correctly reorganizing the timer stack causing unexpected problems later on!
 int settick_timer(int tid, unsigned int tick)
 {
-	int i,j;
-	if (timer_data[tid].tick == tick)
+	int old_pos,pos;
+	unsigned int old_tick;
+	
+	old_tick = timer_data[tid].tick;
+	if( old_tick == tick )
 		return tick;
 
 	//FIXME: This search is not all that effective... there doesn't seems to be a better way to locate an element in the heap.
-	for(i = timer_heap_num-1; i >= 0 && timer_heap[i] != tid; i--);
-
-	if (i < 0)
-		return -1; //Sort of impossible, isn't it?
-	if (DIFF_TICK(timer_data[tid].tick, tick) > 0)
-	{	//Timer is accelerated, shift timer near the end of the heap.
-		if (i == timer_heap_num-1) //Nothing to shift.
-			j = timer_heap_num-1;
+	//for(i = timer_heap_num-1; i >= 0 && timer_heap[i] != tid; i--);
+
+	// search old_tick position
+	HEAP_SEARCH(old_tick,0,timer_heap_num-1,old_pos);
+	while( timer_heap[old_pos] != tid )
+	{// skip timers with the same tick
+		if( DIFF_TICK(old_tick,timer_data[timer_heap[old_pos]].tick) != 0 )
+		{
+			ShowError("settick_timer: no such timer %d (%08x(%s))\n", tid, (int)timer_data[tid].func, search_timer_func_list(timer_data[tid].func));
+			return -1;
+		}
+		++old_pos;
+	}
+
+	if( DIFF_TICK(tick,timer_data[tid].tick) < 0 )
+	{// Timer is accelerated, shift timer near the end of the heap.
+		if (old_pos == timer_heap_num-1) //Nothing to shift.
+			pos = old_pos;
 		else {
-			for (j = i+1; j < timer_heap_num && DIFF_TICK(timer_data[j].tick, tick) > 0; j++);
-			j--;
-			memmove(&timer_heap[i], &timer_heap[i+1], (j-i)*sizeof(int));
+			HEAP_SEARCH(tick,old_pos+1,timer_heap_num-1,pos);
+			--pos;
+			if (pos != old_pos)
+				memmove(&timer_heap[old_pos], &timer_heap[old_pos+1], (pos-old_pos)*sizeof(int));
 		}
-	} else {	//Timer is delayed, shift timer near the beginning of the heap.
-		if (i == 0) //Nothing to shift.
-			j = 0;
+	} else
+	{// Timer is delayed, shift timer near the beginning of the heap.
+		if (old_pos == 0) //Nothing to shift.
+			pos = old_pos;
 		else {
-			for (j = i-1; j >= 0 && DIFF_TICK(timer_data[j].tick, tick) < 0; j--);
-			j++;
-			memmove(&timer_heap[j+1], &timer_heap[j], (i-j)*sizeof(int));
+			HEAP_SEARCH(tick,0,old_pos-1,pos);
+			++pos;
+			if (pos != old_pos)
+				memmove(&timer_heap[pos+1], &timer_heap[pos], (old_pos-pos)*sizeof(int));
 		}
 	}
-	timer_heap[j] = tid;
+	timer_heap[pos] = tid;
 	timer_data[tid].tick = tick;
 	return tick;
 }
@@ -341,15 +369,16 @@ static void fix_timer_heap(unsigned int tick)
 		}
 		//Move elements to readjust the heap.
 		tmp_heap = aCalloc(sizeof(int), i);
-		memmove(&tmp_heap[0], &timer_heap[0], i*sizeof(int));
-		memmove(&timer_heap[0], &timer_heap[i], (timer_heap_num-i)*sizeof(int));
-		memmove(&timer_heap[timer_heap_num-i], &tmp_heap[0], i*sizeof(int));
+		memcpy(tmp_heap, timer_heap, i*sizeof(int));
+		memmove(timer_heap, &timer_heap[i], (timer_heap_num-i)*sizeof(int));
+		memmove(&timer_heap[timer_heap_num-i], tmp_heap, i*sizeof(int));
 		aFree(tmp_heap);
 	}
 }
 
 int do_timer(unsigned int tick)
 {
+	static int fix_heap_flag = 0; //Flag for fixing the stack only once per tick loop. May not be the best way, but it's all I can think of currently :X [Skotlex]
 	int i, nextmin = 1000;
 
 	if (tick < 0x010000 && fix_heap_flag)
@@ -362,8 +391,8 @@ int do_timer(unsigned int tick)
 		i = timer_heap[timer_heap_num - 1]; // next shorter element
 		if ((nextmin = DIFF_TICK(timer_data[i].tick, tick)) > 0)
 			break;
-		if (timer_heap_num > 0) // suppress the actual element from the table
-			timer_heap_num--;
+
+		--timer_heap_num; // suppress the actual element from the table
 		timer_data[i].type |= TIMER_REMOVE_HEAP;
 		if (timer_data[i].func) {
 			if (nextmin < -1000) {
@@ -382,7 +411,7 @@ int do_timer(unsigned int tick)
 				timer_data[i].type = 0;
 				if (free_timer_list_pos >= free_timer_list_max) {
 					free_timer_list_max += 256;
-					free_timer_list = (int *) aRealloc(free_timer_list, sizeof(int) * free_timer_list_max);
+					RECREATE(free_timer_list,int,free_timer_list_max);
 					malloc_tsetdword(free_timer_list + (free_timer_list_max - 256), 0, 256 * sizeof(int));
 				}
 				free_timer_list[free_timer_list_pos++] = i;
@@ -403,14 +432,14 @@ int do_timer(unsigned int tick)
 	if (nextmin < TIMER_MIN_INTERVAL)
 		nextmin = TIMER_MIN_INTERVAL;
 
-	if ((unsigned int)(tick + nextmin) < tick) //Tick will loop, rearrange the heap on the next iteration.
+	if (UINT_MAX - nextmin < tick) //Tick will loop, rearrange the heap on the next iteration.
 		fix_heap_flag = 1;
 	return nextmin;
 }
 
-unsigned long get_uptime (void)
+unsigned long get_uptime(void)
 {
-	return (unsigned long) difftime (time(NULL), start_time);
+	return (unsigned long)difftime(time(NULL), start_time);
 }
 
 void timer_init(void)
@@ -420,17 +449,16 @@ void timer_init(void)
 
 void timer_final(void)
 {
-	struct timer_func_list* tfl = tfl_root, *tfl2;
+	struct timer_func_list *tfl;
+	struct timer_func_list *next;
 
-	while (tfl) {
-		tfl2 = tfl->next;	// copy next pointer
+	for( tfl=tfl_root; tfl != NULL; tfl = next )
+		next = tfl->next;	// copy next pointer
 		aFree(tfl->name);	// free structures
 		aFree(tfl);
-		tfl = tfl2;			// use copied pointer for next cycle
 	}
-	
+
 	if (timer_data) aFree(timer_data);
 	if (timer_heap) aFree(timer_heap);
 	if (free_timer_list) aFree(free_timer_list);
 }
-