public static void timer_remove(timer_entry timer)
{
timer_list_remove(timer);
timer.next = timer_free_head;
timer_free_head = timer;
}
/*
* adjust the current CPU's timer so that a new event will fire at the right time
*/
public static void timer_adjust(timer_entry timer, double time, double period)
{
int newicount, diff;
/* compute a new icount for the current CPU */
if (period == TIME_NOW)
newicount = 0;
else
newicount = (int)((timer.expire - time) * cpudata[activecpu].sec_to_cycles) + 1;
/* determine if we're scheduled to run more cycles */
diff = cpudata[activecpu].icount[0] - newicount;
/* if so, set the new icount and compute the amount of "lost" time */
if (diff > 0)
{
cpudata[activecpu].lost += diff;
if (cpudata[activecpu].burn != null)
cpudata[activecpu].burn(diff); /* let the CPU burn the cycles */
else
cpudata[activecpu].icount[0] = newicount; /* CPU doesn't care */
}
}
public static double timer_firetime(timer_entry which)
{
timer_entry timer = (timer_entry)which;
return global_offset + timer.expire;
}
public static bool timer_schedule_cpu(ref int cpu, ref int cycles)
{
double end;
/* then see if there are any CPUs that aren't suspended and haven't yet been updated */
if (pick_cpu(ref cpu, ref cycles, timer_head.expire) )
return true;
/* everyone is up-to-date; expire any timers now */
end = timer_head.expire;
while (timer_head.expire <= end)
{
timer_entry timer = timer_head;
/* the base time is now the time of the timer */
base_time = timer.expire;
/* set the global state of which callback we're in */
callback_timer_modified = 0;
callback_timer = timer;
/* call the callback */
if (timer.callback != null)
{
timer.callback(timer.callback_param);
}
/* clear the callback timer global */
callback_timer = null;
/* reset or remove the timer, but only if it wasn't modified during the callback */
if (callback_timer_modified == 0)
{
if (timer.period != 0)
{
timer.start = timer.expire;
timer.expire += timer.period;
timer_list_remove(timer);
timer_list_insert(timer);
}
else
timer_remove(timer);
}
}
/* reset scheduling so it starts with CPU 0 */
last_activecpu = lastcpu;
/* go back to scheduling */
return pick_cpu(ref cpu, ref cycles, timer_head.expire);
}
public static double timer_timeleft(timer_entry which)
{
double time = getabsolutetime();
timer_entry timer = (timer_entry)which;
return timer.expire - time;
}
public static double timer_starttime(timer_entry which)
{
timer_entry timer = (timer_entry)which;
return global_offset + timer.start;
}
public static int timer_enable(timer_entry which, int enable)
{
timer_entry timer = (timer_entry)which;
int old;
#if VERBOSE
if (enable) verbose_print("T=%.6g: Enabled %08X\n", getabsolutetime() + global_offset, timer);
else verbose_print("T=%.6g: Disabled %08X\n", getabsolutetime() + global_offset, timer);
#endif
/* set the enable flag */
old = timer.enabled;
timer.enabled = enable;
/* remove the timer and insert back into the list */
timer_list_remove(timer);
timer_list_insert(timer);
return old;
}
public static double timer_timeelapsed(timer_entry which)
{
double time = getabsolutetime();
timer_entry timer = (timer_entry)which;
return time - timer.start;
}
public static void timer_remove(object which)
{
timer_entry timer = (timer_entry)which;
/* remove it from the list */
timer_list_remove(timer);
/* free it up by adding it back to the free list */
timer.next = timer_free_head;
timer_free_head = timer;
#if VERBOSE
verbose_print("T=%.6g: Removed %08X\n", getabsolutetime() + global_offset, timer);
#endif
}
public static void timer_init()
{
/* keep a local copy of how many total CPU's */
lastcpu = cpu_gettotalcpu() - 1;
/* we need to wait until the first call to timer_cyclestorun before using real CPU times */
base_time = 0.0;
global_offset = 0.0;
callback_timer = null;
callback_timer_modified = 0;
/* reset the timers */
//memset(timers, 0, sizeof(timers));
for (int i = 0; i < MAX_TIMERS; i++)
timers[i] = new timer_entry();
/* initialize the lists */
timer_head = null;
timer_free_head = timers[0];
for (int i = 0; i < MAX_TIMERS - 1; i++)
timers[i].next = timers[i + 1];
/* reset the CPU timers */
//memset(cpudata, 0, sizeof(cpudata));
for (int i = 0; i < cpudata.Length; i++)
cpudata[i] = new cpu_entry();
activecpu = -1;
last_activecpu = lastcpu;
/* compute the cycle times */
for (int i = 0; i <= lastcpu; i++)
{
/* make a pointer to this CPU's interface functions */
cpudata[i].icount = cpuintf[Machine.drv.cpu[i].cpu_type & ~CPU_FLAGS_MASK].icount;
cpudata[i].burn = cpuintf[Machine.drv.cpu[i].cpu_type & ~CPU_FLAGS_MASK].burn;
/* get the CPU's overclocking factor */
cpudata[i].overclock = cpuintf[Machine.drv.cpu[i].cpu_type & ~CPU_FLAGS_MASK].overclock;
/* everyone is active but suspended by the reset line until further notice */
cpudata[i].suspended = SUSPEND_REASON_RESET;
/* set the CPU index */
cpudata[i].index = i;
/* compute the cycle times */
cpudata[i].sec_to_cycles = sec_to_cycles[i] = cpudata[i].overclock * Machine.drv.cpu[i].cpu_clock;
cpudata[i].cycles_to_sec = cycles_to_sec[i] = 1.0 / sec_to_cycles[i];
}
}
public static void timer_list_remove(timer_entry timer)
{
/* remove it from the list */
if (timer.prev != null)
timer.prev.next = timer.next;
else
timer_head = timer.next;
if (timer.next != null)
timer.next.prev = timer.prev;
}
/*
* insert a new timer into the list at the appropriate location
*/
public static void timer_list_insert(timer_entry timer)
{
double expire = timer.enabled != 0 ? timer.expire : TIME_NEVER;
timer_entry t, lt = null;
/* loop over the timer list */
for (t = timer_head; t != null; lt = t, t = t.next)
{
/* if the current list entry expires after us, we should be inserted before it */
/* note that due to floating point rounding, we need to allow a bit of slop here */
/* because two equal entries -- within rounding precision -- need to sort in */
/* the order they were inserted into the list */
if ((t.expire - expire) > TIME_IN_NSEC(1))
{
/* link the new guy in before the current list entry */
timer.prev = t.prev;
timer.next = t;
if (t.prev != null)
t.prev.next = timer;
else
timer_head = timer;
t.prev = timer;
return;
}
}
/* need to insert after the last one */
if (lt != null)
lt.next = timer;
else
timer_head = timer;
timer.prev = lt;
timer.next = null;
}
/*
* allocate a new timer
*/
public static timer_entry timer_new()
{
timer_entry timer;
/* remove an empty entry */
if (timer_free_head == null)
return null;
timer = timer_free_head;
timer_free_head = timer.next;
return timer;
}
