void timer_adjust_periodic(emu_timer *which, attotime start_delay, INT32 param, attotime period)
{
attotime time = get_current_time();
/* if this is the callback timer, mark it modified */
if (which == callback_timer)
callback_timer_modified = TRUE;
/* compute the time of the next firing and insert into the list */
which->param = param;
which->enabled = TRUE;
/* clamp negative times to 0 */
if (start_delay.seconds < 0)
start_delay = attotime_zero;
/* set the start and expire times */
which->start = time;
which->expire = attotime_add(time, start_delay);
which->period = period;
/* remove and re-insert the timer in its new order */
timer_list_remove(which);
timer_list_insert(which);
/* if this was inserted as the head, abort the current timeslice and resync */
LOG(("timer_adjust_oneshot %s.%s:%d to expire @ %s\n", which->file, which->func, which->line, attotime_string(which->expire, 9)));
if (which == timer_head && cpu_getexecutingcpu() >= 0)
activecpu_abort_timeslice();
}
void mame_timer_adjust(mame_timer *which, mame_time duration, int param, mame_time period)
{
mame_time time = get_current_time();
/* error if this is an inactive timer */
if (which->tag == -1)
{
printf("mame_timer_adjust: adjusting an inactive timer!\n");
logerror("mame_timer_adjust: adjusting an inactive timer!\n");
return;
}
/* if this is the callback timer, mark it modified */
if (which == callback_timer)
callback_timer_modified = 1;
/* compute the time of the next firing and insert into the list */
which->callback_param = param;
which->enabled = 1;
/* set the start and expire times */
which->start = time;
which->expire = add_mame_times(time, duration);
which->period = period;
/* remove and re-insert the timer in its new order */
timer_list_remove(which);
timer_list_insert(which);
/* if this was inserted as the head, abort the current timeslice and resync */
LOG(("timer_adjust %s:%d to expire @ %.9f\n", which->file, which->line, mame_time_to_double(which->expire)));
if (which == timer_head && cpu_getexecutingcpu() >= 0)
activecpu_abort_timeslice();
}
void timer_adjust(mame_timer *which, double duration, int param, double period)
{
double time = get_relative_time();
/* if this is the callback timer, mark it modified */
if (which == callback_timer)
callback_timer_modified = 1;
/* compute the time of the next firing and insert into the list */
which->callback_param = param;
which->enabled = 1;
/* set the start and expire times */
which->start = time;
which->expire = time + duration;
which->period = period;
/* remove and re-insert the timer in its new order */
timer_list_remove(which);
timer_list_insert(which);
/* if this was inserted as the head, abort the current timeslice and resync */
LOG(("timer_adjust %08X to expire @ %.9f\n", (UINT32)which, which->expire));
if (which == timer_head && cpu_getexecutingcpu() >= 0)
activecpu_abort_timeslice();
}
UINT64 cpu_gettotalcycles64(int cpunum)
{
VERIFY_CPUNUM(0, cpu_gettotalcycles);
if (cpunum == cpu_getexecutingcpu())
return cpu[cpunum].totalcycles + cycles_currently_ran();
else
return cpu[cpunum].totalcycles;
}
void cpunum_resume(int cpunum, int reason)
{
VERIFY_CPUNUM_VOID(cpunum_resume);
LOG(("cpunum_resume (CPU=%d, r=%X)\n", cpunum, reason));
/* clear the pending suspend bits, and force a resync */
cpu[cpunum].nextsuspend &= ~reason;
if (cpu_getexecutingcpu() >= 0)
activecpu_abort_timeslice();
}
void cpunum_suspend(int cpunum, int reason, int eatcycles)
{
VERIFY_CPUNUM_VOID(cpunum_suspend);
LOG(("cpunum_suspend (CPU=%d, r=%X, eat=%d)\n", cpunum, reason, eatcycles));
/* set the pending suspend bits, and force a resync */
cpu[cpunum].nextsuspend |= reason;
cpu[cpunum].nexteatcycles = eatcycles;
if (cpu_getexecutingcpu() >= 0)
activecpu_abort_timeslice();
}
void cpu_yielduntil_trigger(int trigger)
{
int cpunum = cpu_getexecutingcpu();
VERIFY_EXECUTINGCPU_VOID(cpu_yielduntil_trigger);
/* suspend the CPU immediately if it's not already */
cpunum_suspend(cpunum, SUSPEND_REASON_TRIGGER, 0);
/* set the trigger */
cpu[cpunum].trigger = trigger;
}
void activecpu_abort_timeslice(void)
{
int current_icount;
VERIFY_EXECUTINGCPU_VOID(activecpu_abort_timeslice);
LOG(("activecpu_abort_timeslice (CPU=%d, cycles_left=%d)\n", cpu_getexecutingcpu(), activecpu_get_icount() + 1));
/* swallow the remaining cycles */
current_icount = activecpu_get_icount() + 1;
cycles_stolen += current_icount;
cycles_running -= current_icount;
activecpu_adjust_icount(-current_icount);
}
double cpunum_get_localtime(int cpunum)
{
double result;
VERIFY_CPUNUM(0, cpunum_get_localtime);
/* if we're active, add in the time from the current slice */
result = cpu[cpunum].localtime;
if (cpunum == cpu_getexecutingcpu())
{
int cycles = cycles_currently_ran();
result += TIME_IN_CYCLES(cycles, cpunum);
}
return result;
}
void cpu_trigger(int trigger)
{
int cpunum;
/* cause an immediate resynchronization */
if (cpu_getexecutingcpu() >= 0)
activecpu_abort_timeslice();
/* look for suspended CPUs waiting for this trigger and unsuspend them */
for (cpunum = 0; cpunum < MAX_CPU; cpunum++)
{
/* if this is a dummy, stop looking */
if (Machine->drv->cpu[cpunum].cpu_type == CPU_DUMMY)
break;
/* see if this is a matching trigger */
if (cpu[cpunum].suspend && cpu[cpunum].trigger == trigger)
{
cpunum_resume(cpunum, SUSPEND_REASON_TRIGGER);
cpu[cpunum].trigger = 0;
}
}
}
