Optimizing timing functionality?

[superfury]

I've written a timer function in c/c++, but it still has performance problems. Anybody knows how to optimize this further (atm works with delay to perform timing):

#include "headers/types.h" //Basic types!
#include "headers/timers.h" //Timer support function data!
#include "headers/emu/threads.h" //Thread for timer item!

//Timer step in ms! Originally 100ms
#define TIMER_STEP 10000

float timerfreqs[10] = {0,0,0,0,0,0,0,0,0,0};;
Handler timers[10] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
double counters[10] = {0,0,0,0,0,0,0,0,0,0};
char timernames[10][256] = {"","","","","","","","","",""}; //Timer name!
int TIMER_RUNNING = 0; //Whether to run timers or pause!
int action_confirmed = 0; //Action confirmed (after stop)?

//This handles all current used timers!
void timer_thread() //Handler for timer!
{
	int curtimer;
	while (1) //Keep running!
	{

		if (TIMER_RUNNING && !action_confirmed) //Request to run?
		{
			action_confirmed = 1; //Confirmed to run!
		}
		else if (!TIMER_RUNNING && !action_confirmed) //To stop running?
		{
			action_confirmed = 1; //Confirmed!
			return; //Stop timer!
		}


		uint_32 bonus = 0; //Bonus of other running threads!
		bonus = 0; //Init bonus!
		
		for (curtimer=0; curtimer<10; curtimer++) //Process timers!
		{
			if ((timers[curtimer]!=NULL) && (timerfreqs[curtimer]!=0.0)) //Timer set?
			{
				counters[curtimer] += TIMER_STEP+bonus; //Increase counter, including the bonus gotten from the other threads running!
				while ((counters[curtimer]-(1000000/timerfreqs[curtimer]))>=0) //Overflow?
				{
					counters[curtimer] -= (1000000/timerfreqs[curtimer]); //Decrease counter!
					char name[256];
					bzero(name,sizeof(name)); //Init name!
					strcpy(name,"timer_sub_"); //Root!
					strcat(name,timernames[curtimer]); //Set name!
					startThread(timers[curtimer],name); //Fire the timer handler
					delay(10); //Little time for the thread!
					counters[curtimer] += 10; //Add the bonus of the previous thread!
					bonus += 10; //We have a bonus for multiple threads!
				}
				while (counters[curtimer]>10000000) //Way too much (10 seconds)?
				{
					counters[curtimer] -= 10000000; //Remove some (10 seconds)!
				}
			}
		}

		sceKernelDelayThread(TIMER_STEP); //Lousy, take 100ms breaks!
	}
}

void addtimer(float frequency, Handler timer, char *name)
{
	int i;
	for (i=0; i<10; i++) //Check for existing timer!
	{
		if (strcmp(timernames[i],name)==0) //Found?
		{
			timers[i] = timer; //Edit timer if needed!
//Leave counter alone!
			timerfreqs[i] = frequency; //Edit frequency!
//Timer name is already set!
		}
	}

//Now for new timers!

	for (i=0; i<10; i++)
	{
		if (timerfreqs[i]==0.0) //Not set?
		{
			timers[i] = timer; //Set timer!
			counters[i] = 0; //Reset counter!
			timerfreqs[i] = frequency; //Start timer!
			strcpy(timernames[i],name); //Timer name!
			break;
		}
	}
}

void cleartimers() //Clear all running timers!
{
	int i;
	for (i=0; i<10; i++)
	{
		if (timerfreqs[i]!=0.0) //Set?
		{
			if (strcmp(timernames[i],"")!=0) //Set and has a name?
			{
				removetimer(timernames[i]); //Remove!
			}
		}
	}
}

void removetimer(char *name) //Removes a timer!
{
	int i;
	for (i=0; i<10; i++)
	{
		if (timerfreqs[i]!=0.0) //Enabled?
		{
			if (strcmp(timernames[i],name)==0) //Timer enabled and selected?
			{
				timerfreqs[i] = 0.0; //Turn timer off!
				timers[i] = NULL; //Remove timer!
				counters[i] = 0; //Reset counter!
				break;
			}
		}
	}
}

void startTimers()
{
	if (!TIMER_RUNNING) //Not already running?
	{
		TIMER_RUNNING = 1; //Start timers!
		startThread(&timer_thread,"timer_thread"); //Timer thread start!
	}
}

void stopTimers()
{
	if (TIMER_RUNNING) //Running already (we can terminate it)?
	{
		action_confirmed = 0; //Init!
		TIMER_RUNNING = 0; //Stop timers command for the timer thread!
		while (!action_confirmed) //Wait to stop!
		{
			delay(1); //Wait a bit for the thread to stop!
		}
	}
}

void resetTimers() //Reset all timers to off and turn off all handlers!
{
	stopTimers(); //Stop timer thread!
	int i;
	for (i=0; i<10; i++) //Go all!
	{
		timerfreqs[i] = 0.0; //Turn timer off!
		timers[i] = NULL; //Remove timer!
		counters[i] = 0; //Reset counter!
	}
}

[Santosh Reddy]

Can you explain a bit
What is this code is expected to do?
What is startThread?
What is Handler?

If you want some optimization, then better post a compilable code, or at-least tell us the bottle neck, so that productive suggestions can come up

[Fransje]

It might be a better idea to redesign it in an object oriented way.

[superfury]

@Santosh Reddy: startThread starts a new thread (parameters are a pointer to the function (Handler type) and the name of the thread. When the function is done, the thread is destroyed automatically.
Handler is a typedef for functions without parameters:
typedef void (*Handler)(void); /* A pointer to a handler function */

@Fransje: For some reason, OOP doesn't work in the C/C++ version I'm using. The compiler just won't recognise it. (except structs etc.) I'm using the PSPSDK compiler.

Btw. TIMER_STEP is the stepping time for checking (is microseconds). A delay is executed and after the delay the thread handles all functions that must have been done in that time (e.g. if 100 times the interval of the timer has passed (e.g. 2.0Hz becomes 500 000ms intervals) in the passed time (in this case always 10 milliseconds). So at 2.0Hz, after every 500 000microseconds the function is called one time. (Formula for interval: 1000000/Hz (calculated/verified/substracted as a float))).