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; } } }