diff -r 1207e705a1b6 -r a8d8937d5e1b src/cpu/inorder/cpu.hh
--- a/src/cpu/inorder/cpu.hh	Tue Jan 04 13:21:36 2011 -0800
+++ b/src/cpu/inorder/cpu.hh	Tue Jan 04 13:21:50 2011 -0800
@@ -156,12 +156,12 @@
     /** Schedule tick event, regardless of its current state. */
     void scheduleTickEvent(int delay)
     {
+        Tick when = nextCycle(curTick + ticks(delay));
+
         if (tickEvent.squashed())
-          mainEventQueue.reschedule(&tickEvent, 
-                                    nextCycle(curTick + ticks(delay)));
+            reschedule(&tickEvent, when);
         else if (!tickEvent.scheduled())
-          mainEventQueue.schedule(&tickEvent, 
-                                  nextCycle(curTick + ticks(delay)));
+            schedule(&tickEvent, when);
     }
 
     /** Unschedule tick event, regardless of its current state. */
diff -r 1207e705a1b6 -r a8d8937d5e1b src/cpu/inorder/cpu.cc
--- a/src/cpu/inorder/cpu.cc	Tue Jan 04 13:21:36 2011 -0800
+++ b/src/cpu/inorder/cpu.cc	Tue Jan 04 13:21:50 2011 -0800
@@ -157,12 +157,12 @@
 void
 InOrderCPU::CPUEvent::scheduleEvent(int delay)
 {
+    Tick when = cpu->nextCycle(curTick + cpu->ticks(delay));
+
     if (squashed())
-        mainEventQueue.reschedule(this, cpu->nextCycle(curTick +
-                                                       cpu->ticks(delay)));
+        cpu->reschedule(this, when);
     else if (!scheduled())
-        mainEventQueue.schedule(this, cpu->nextCycle(curTick +
-                                                     cpu->ticks(delay)));
+        cpu->schedule(this, when);
 }
 
 void
@@ -540,7 +540,7 @@
         } else {
             //Tick next_tick = curTick + cycles(1);
             //tickEvent.schedule(next_tick);
-            mainEventQueue.schedule(&tickEvent, nextCycle(curTick + 1));
+            schedule(&tickEvent, nextCycle(curTick + 1));
             DPRINTF(InOrderCPU, "Scheduled CPU for next tick @ %i.\n", 
                     nextCycle(curTick + 1));
         }
@@ -701,7 +701,7 @@
     if (delay >= 0) {
         DPRINTF(InOrderCPU, "Scheduling CPU Event (%s) for cycle %i, [tid:%i].\n",
                 eventNames[c_event], curTick + delay, tid);
-        mainEventQueue.schedule(cpu_event, sked_tick);
+        schedule(cpu_event, sked_tick);
     } else {
         cpu_event->process();
         cpuEventRemoveList.push(cpu_event);
@@ -1403,7 +1403,7 @@
 
     numCycles += extra_cycles;
 
-    mainEventQueue.schedule(&tickEvent, nextCycle(curTick));
+    schedule(&tickEvent, nextCycle(curTick));
 }
 
 #if FULL_SYSTEM
diff -r 1207e705a1b6 -r a8d8937d5e1b src/cpu/inorder/resource.hh
--- a/src/cpu/inorder/resource.hh	Tue Jan 04 13:21:36 2011 -0800
+++ b/src/cpu/inorder/resource.hh	Tue Jan 04 13:21:50 2011 -0800
@@ -277,13 +277,7 @@
     void setSlot(int slot) { slotIdx = slot; }
 
     /** Schedule resource event, regardless of its current state. */
-    void scheduleEvent(int delay)
-    {
-        if (squashed())
-          mainEventQueue.reschedule(this, curTick + resource->ticks(delay));
-        else if (!scheduled())
-          mainEventQueue.schedule(this, curTick + resource->ticks(delay));
-    }
+    void scheduleEvent(int delay);
 
     /** Unschedule resource event, regardless of its current state. */
     void unscheduleEvent()
diff -r 1207e705a1b6 -r a8d8937d5e1b src/cpu/inorder/resource.cc
--- a/src/cpu/inorder/resource.cc	Tue Jan 04 13:21:36 2011 -0800
+++ b/src/cpu/inorder/resource.cc	Tue Jan 04 13:21:50 2011 -0800
@@ -498,3 +498,15 @@
 
     return desc.c_str();
 }
+
+void
+ResourceEvent::scheduleEvent(int delay)
+{
+    InOrderCPU *cpu = resource->cpu;
+    Tick when = curTick + resource->ticks(delay);
+
+    if (squashed())
+        cpu->reschedule(this, when);
+    else if (!scheduled())
+        cpu->schedule(this, when);
+}
diff -r 1207e705a1b6 -r a8d8937d5e1b src/cpu/inorder/resource_pool.cc
--- a/src/cpu/inorder/resource_pool.cc	Tue Jan 04 13:21:36 2011 -0800
+++ b/src/cpu/inorder/resource_pool.cc	Tue Jan 04 13:21:50 2011 -0800
@@ -244,6 +244,8 @@
 {
     assert(delay >= 0);
 
+    Tick when = cpu->nextCycle(curTick + cpu->ticks(delay));
+
     switch (e_type)
     {
       case InOrderCPU::ActivateThread:
@@ -258,9 +260,7 @@
                                  inst->squashingStage,
                                  inst->bdelaySeqNum,
                                  inst->readTid());
-            mainEventQueue.schedule(res_pool_event, 
-                                    cpu->nextCycle(curTick +
-                                                   cpu->ticks(delay)));
+            cpu->schedule(res_pool_event, when);
         }
         break;
 
@@ -278,19 +278,17 @@
                                  inst->bdelaySeqNum,
                                  tid);
 
-            mainEventQueue.schedule(res_pool_event, 
-                                    cpu->nextCycle(curTick +
-                                                   cpu->ticks(delay)));
-
+            cpu->schedule(res_pool_event, when);
         }
         break;
 
       case InOrderCPU::SuspendThread:
         {
+            // not sure why we add another nextCycle() call here...
+            Tick sked_tick = cpu->nextCycle(when);
 
             DPRINTF(Resource, "Scheduling Suspend Thread Resource Pool "
-                    "Event for tick %i.\n",
-                    cpu->nextCycle(cpu->nextCycle(curTick + cpu->ticks(delay))));
+                    "Event for tick %i.\n", sked_tick);
 
             ResPoolEvent *res_pool_event = new ResPoolEvent(this,
                                                             e_type,
@@ -299,10 +297,7 @@
                                                             inst->bdelaySeqNum,
                                                             tid);
 
-            Tick sked_tick = curTick + cpu->ticks(delay);
-            mainEventQueue.schedule(res_pool_event,
-                                    cpu->nextCycle(cpu->nextCycle(sked_tick)));
-
+            cpu->schedule(res_pool_event, sked_tick);
         }
         break;
 
@@ -316,10 +311,7 @@
                                  inst->squashingStage,
                                  inst->seqNum,
                                  inst->readTid());
-            mainEventQueue.schedule(res_pool_event, 
-                                    cpu->nextCycle(curTick +
-                                                   cpu->ticks(delay)));
-
+            cpu->schedule(res_pool_event, when);
         }
         break;
 
@@ -333,9 +325,7 @@
                                  inst->squashingStage,
                                  inst->bdelaySeqNum,
                                  inst->readTid());
-            mainEventQueue.schedule(res_pool_event, 
-                                    cpu->nextCycle(curTick +
-                                                   cpu->ticks(delay)));
+            cpu->schedule(res_pool_event, when);
         }
         break;
 
@@ -350,23 +340,21 @@
                                  inst->squashingStage,
                                  inst->seqNum - 1,
                                  inst->readTid());
-            mainEventQueue.schedule(res_pool_event, 
-                                    cpu->nextCycle(curTick + cpu->ticks(delay)));
+            cpu->schedule(res_pool_event, when);
         }
         break;
 
       case ResourcePool::UpdateAfterContextSwitch:
         {
-            DPRINTF(Resource, "Scheduling UpdatePC Resource Pool Event for tick %i.\n",
+            DPRINTF(Resource, "Scheduling UpdatePC Resource Pool Event "
+                    "for tick %i.\n",
                     curTick + delay);
             ResPoolEvent *res_pool_event = new ResPoolEvent(this,e_type,
                                                             inst,
                                                             inst->squashingStage,
                                                             inst->seqNum,
                                                             inst->readTid());
-            mainEventQueue.schedule(res_pool_event,
-                                    cpu->nextCycle(curTick + cpu->ticks(delay)));
-
+            cpu->schedule(res_pool_event, when);
         }
         break;
 
@@ -552,16 +540,13 @@
 void
 ResourcePool::ResPoolEvent::scheduleEvent(int delay)
 {
+    InOrderCPU *cpu = resPool->cpu;
+    Tick when = cpu->nextCycle(curTick + cpu->ticks(delay));
+
     if (squashed()) {
-        mainEventQueue.reschedule(this,
-                                  resPool->cpu->nextCycle(curTick +
-                                                          resPool->
-                                                          cpu->ticks(delay)));
+        cpu->reschedule(this, when);
     } else if (!scheduled()) {
-        mainEventQueue.schedule(this,
-                                resPool->cpu->nextCycle(curTick +
-                                                        resPool->
-                                                        cpu->ticks(delay)));
+        cpu->schedule(this, when);
     }
 }