Return to events_jit.h CVS log

Up to [Previous NeXT emulator] / previous / src / cpu

Annotation of previous/src/cpu/events_jit.h, revision 1.1.1.1

1.1       root        1: /* Let's see whether hiding this away somewhere where the compiler can't
                      2: see it will cure it of its silly urge to mis-optimize the comparison */
                      3: extern long int diff32(frame_time_t x, frame_time_t y);
                      4: extern int pissoff_value;
                      5: 
                      6: STATIC_INLINE void events_schedule (void)
                      7: {
                      8:        int i;
                      9: 
                     10:        unsigned long int mintime = ~0L;
                     11:        for (i = 0; i < ev_max; i++) {
                     12:                if (eventtab[i].active) {
                     13:                        unsigned long int eventtime = eventtab[i].evtime - currcycle;
                     14: #ifdef EVENT_DEBUG
                     15:                        if (eventtime == 0) {
                     16:                                write_log ("event %d bug\n",i);
                     17:                        }
                     18: #endif
                     19:                        if (eventtime < mintime)
                     20:                                mintime = eventtime;
                     21:                }
                     22:        }
                     23:        nextevent = currcycle + mintime;
                     24: }
                     25: 
                     26: extern signed long pissoff;
                     27: 
                     28: STATIC_INLINE void cycles_do_special (void)
                     29: {
                     30: #ifdef JIT
                     31:        if (currprefs.cachesize) {
                     32:                if (pissoff >= 0)
                     33:                        pissoff = -1;
                     34:        } else
                     35: #endif
                     36:        {
                     37:                pissoff = 0;
                     38:        }
                     39: }
                     40: 
                     41: STATIC_INLINE void do_extra_cycles (unsigned long cycles_to_add)
                     42: {
                     43:        pissoff -= cycles_to_add;
                     44: }
                     45: 
                     46: STATIC_INLINE unsigned long int get_cycles (void)
                     47: {
                     48:        return currcycle;
                     49: }
                     50: 
                     51: STATIC_INLINE void set_cycles (unsigned long int x)
                     52: {
                     53:        currcycle = x;
                     54: #ifdef EVT_DEBUG
                     55:        if (currcycle & (CYCLE_UNIT - 1))
                     56:                write_log (L"%x\n", currcycle);
                     57: #endif
                     58: }
                     59: 
                     60: STATIC_INLINE void do_cycles_slow (unsigned long cycles_to_add)
                     61: {
                     62:        if ((pissoff -= cycles_to_add) >= 0)
                     63:                return;
                     64: 
                     65:        cycles_to_add = -pissoff;
                     66:        pissoff = 0;
                     67: 
                     68:        if (is_lastline && eventtab[ev_hsync].evtime - currcycle <= cycles_to_add) {
                     69:                int rpt = read_processor_time ();
                     70:                int v = rpt - vsyncmintime;
                     71:                if (v > (int)syncbase || v < -((int)syncbase))
                     72:                        vsyncmintime = rpt;
                     73:                if (v < 0) {
                     74:                        pissoff = pissoff_value * CYCLE_UNIT;
                     75:                        return;
                     76:                }
                     77:        }
                     78:        while ((nextevent - currcycle) <= cycles_to_add) {
                     79:                int i;
                     80:                cycles_to_add -= (nextevent - currcycle);
                     81:                currcycle = nextevent;
                     82: 
                     83:                for (i = 0; i < ev_max; i++) {
                     84:                        if (eventtab[i].active && eventtab[i].evtime == currcycle) {
                     85:                                (*eventtab[i].handler)();
                     86:                        }
                     87:                }
                     88:                events_schedule ();
                     89:        }
                     90:        currcycle += cycles_to_add;
                     91: #ifdef EVT_DEBUG
                     92:        if (currcycle & (CYCLE_UNIT - 1))
                     93:                write_log (L"%x\n", currcycle);
                     94: #endif
                     95: }
                     96: 
                     97: #define do_cycles do_cycles_slow
                     98: #define countdown pissoff
                     99: 
                    100: /* This is a special-case function.  Normally, all events should lie in the
                    101: future; they should only ever be active at the current cycle during
                    102: do_cycles.  However, a snapshot is saved during do_cycles, and so when
                    103: restoring it, we may have other events pending.  */
                    104: 
                    105: STATIC_INLINE void handle_active_events (void)
                    106: {
                    107:        int i;
                    108:        for (i = 0; i < ev_max; i++) {
                    109:                if (eventtab[i].active && eventtab[i].evtime == currcycle) {
                    110:                        (*eventtab[i].handler)();
                    111:                }
                    112:        }
                    113: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.