diff --git a/src/cpu/base.hh b/src/cpu/base.hh
--- a/src/cpu/base.hh
+++ b/src/cpu/base.hh
@@ -457,6 +457,8 @@
      */
     void scheduleLoadStop(ThreadID tid, Counter loads, const char *cause);
 
+    void doMonitor(PacketPtr pkt);
+
   public:
     /**
      * @{
@@ -555,13 +557,14 @@
     Stats::Scalar numWorkItemsCompleted;
 
   private:
-    AddressMonitor addressMonitor;
+    std::vector<AddressMonitor> addressMonitor;
 
   public:
-    void armMonitor(Addr address);
-    bool mwait(PacketPtr pkt);
-    void mwaitAtomic(ThreadContext *tc, TheISA::TLB *dtb);
-    AddressMonitor *getCpuAddrMonitor() { return &addressMonitor; }
+    void armMonitor(Addr address, ThreadID tid);
+    bool mwait(PacketPtr pkt, ThreadID tid);
+    void mwaitAtomic(ThreadContext *tc, ThreadID tid, TheISA::TLB *dtb);
+    AddressMonitor *getAddrMonitor(ThreadID tid) { return &addressMonitor[tid]; }
+
     void atomicNotify(Addr address);
 };
 
# Node ID 27ededc60d3884fbd87f05011113e78d5dcf8fca
# Parent  c32578991199dcbca0f7a55230e6b396a531941f
diff --git a/src/cpu/base.cc b/src/cpu/base.cc
--- a/src/cpu/base.cc
+++ b/src/cpu/base.cc
@@ -255,6 +255,8 @@
         fatal("Number of ISAs (%i) assigned to the CPU does not equal number "
               "of threads (%i).\n", params()->isa.size(), numThreads);
     }
+
+    addressMonitor.resize(numThreads);
 }
 
 void
@@ -271,39 +273,39 @@
 }
 
 void
-BaseCPU::armMonitor(Addr address)
+BaseCPU::armMonitor(Addr address, ThreadID tid)
 {
-    addressMonitor.armed = true;
-    addressMonitor.vAddr = address;
-    addressMonitor.pAddr = 0x0;
+    addressMonitor[tid].armed = true;
+    addressMonitor[tid].vAddr = address;
+    addressMonitor[tid].pAddr = 0x0;
     DPRINTF(Mwait,"Armed monitor (vAddr=0x%lx)\n", address);
 }
 
 bool
-BaseCPU::mwait(PacketPtr pkt)
+BaseCPU::mwait(PacketPtr pkt, ThreadID tid)
 {
-    if(addressMonitor.gotWakeup == false) {
+    if (!addressMonitor[tid].gotWakeup) {
         int block_size = cacheLineSize();
         uint64_t mask = ~((uint64_t)(block_size - 1));
 
         assert(pkt->req->hasPaddr());
-        addressMonitor.pAddr = pkt->getAddr() & mask;
-        addressMonitor.waiting = true;
+        addressMonitor[tid].pAddr = pkt->getAddr() & mask;
+        addressMonitor[tid].waiting = true;
 
-        DPRINTF(Mwait,"mwait called (vAddr=0x%lx, line's paddr=0x%lx)\n",
-                addressMonitor.vAddr, addressMonitor.pAddr);
+        DPRINTF(Mwait, "mwait called (vAddr=0x%lx, line's paddr=0x%lx)\n",
+                addressMonitor[tid].vAddr, addressMonitor[tid].pAddr);
         return true;
     } else {
-        addressMonitor.gotWakeup = false;
+        addressMonitor[tid].gotWakeup = false;
         return false;
     }
 }
 
 void
-BaseCPU::mwaitAtomic(ThreadContext *tc, TheISA::TLB *dtb)
+BaseCPU::mwaitAtomic(ThreadContext *tc, ThreadID tid, TheISA::TLB *dtb)
 {
     Request req;
-    Addr addr = addressMonitor.vAddr;
+    Addr addr = addressMonitor[tid].vAddr;
     int block_size = cacheLineSize();
     uint64_t mask = ~((uint64_t)(block_size - 1));
     int size = block_size;
@@ -320,11 +322,11 @@
     Fault fault = dtb->translateAtomic(&req, tc, BaseTLB::Read);
     assert(fault == NoFault);
 
-    addressMonitor.pAddr = req.getPaddr() & mask;
-    addressMonitor.waiting = true;
+    addressMonitor[tid].pAddr = req.getPaddr() & mask;
+    addressMonitor[tid].waiting = true;
 
-    DPRINTF(Mwait,"mwait called (vAddr=0x%lx, line's paddr=0x%lx)\n",
-            addressMonitor.vAddr, addressMonitor.pAddr);
+    DPRINTF(Mwait, "mwait called (vAddr=0x%lx, line's paddr=0x%lx)\n",
+            addressMonitor[tid].vAddr, addressMonitor[tid].pAddr);
 }
 
 void
@@ -691,17 +693,20 @@
     gotWakeup = false;
 }
 
-bool AddressMonitor::doMonitor(PacketPtr pkt) {
+void
+BaseCPU::doMonitor(PacketPtr pkt) {
     assert(pkt->req->hasPaddr());
-    if(armed && waiting) {
-        if(pAddr == pkt->getAddr()) {
-            DPRINTF(Mwait,"pAddr=0x%lx invalidated: waking up core\n",
-                    pkt->getAddr());
-            waiting = false;
-            return true;
+    for (ThreadID tid = 0; tid < numThreads; tid++) {
+        if (addressMonitor[tid].armed &&
+            addressMonitor[tid].waiting) {
+            if (addressMonitor[tid].pAddr == pkt->getAddr()) {
+                DPRINTF(Mwait,"pAddr=0x%lx invalidated: waking up core\n",
+                        pkt->getAddr());
+                addressMonitor[tid].waiting = false;
+                activateContext(tid);
+            }
         }
     }
-    return false;
 }
 
 void
diff --git a/src/cpu/base_dyn_inst.hh b/src/cpu/base_dyn_inst.hh
--- a/src/cpu/base_dyn_inst.hh
+++ b/src/cpu/base_dyn_inst.hh
@@ -858,11 +858,11 @@
 
   public:
     // monitor/mwait funtions
-    void armMonitor(Addr address) { cpu->armMonitor(address); }
-    bool mwait(PacketPtr pkt) { return cpu->mwait(pkt); }
+    void armMonitor(Addr address) { cpu->armMonitor(address, threadNumber); }
+    bool mwait(PacketPtr pkt) { return cpu->mwait(pkt, threadNumber); }
     void mwaitAtomic(ThreadContext *tc)
-    { return cpu->mwaitAtomic(tc, cpu->dtb); }
-    AddressMonitor *getAddrMonitor() { return cpu->getCpuAddrMonitor(); }
+    { return cpu->mwaitAtomic(tc, threadNumber, cpu->dtb); }
+    AddressMonitor *getAddrMonitor() { return cpu->getAddrMonitor(threadNumber); }
 };
 
 template<class Impl>
diff --git a/src/cpu/checker/cpu.hh b/src/cpu/checker/cpu.hh
--- a/src/cpu/checker/cpu.hh
+++ b/src/cpu/checker/cpu.hh
@@ -350,11 +350,11 @@
     }
 
     // monitor/mwait funtions
-    virtual void armMonitor(Addr address) { BaseCPU::armMonitor(address); }
-    bool mwait(PacketPtr pkt) { return BaseCPU::mwait(pkt); }
+    virtual void armMonitor(Addr address) { BaseCPU::armMonitor(address, 0); }
+    bool mwait(PacketPtr pkt) { return BaseCPU::mwait(pkt, 0); }
     void mwaitAtomic(ThreadContext *tc)
-    { return BaseCPU::mwaitAtomic(tc, thread->dtb); }
-    AddressMonitor *getAddrMonitor() { return BaseCPU::getCpuAddrMonitor(); }
+    { return BaseCPU::mwaitAtomic(tc, 0, thread->dtb); }
+    AddressMonitor *getAddrMonitor() { return BaseCPU::getAddrMonitor(0); }
 
     void demapInstPage(Addr vaddr, uint64_t asn)
     {
diff --git a/src/cpu/minor/exec_context.hh b/src/cpu/minor/exec_context.hh
--- a/src/cpu/minor/exec_context.hh
+++ b/src/cpu/minor/exec_context.hh
@@ -343,12 +343,12 @@
 
   public:
     // monitor/mwait funtions
-    void armMonitor(Addr address) { getCpuPtr()->armMonitor(address); }
-    bool mwait(PacketPtr pkt) { return getCpuPtr()->mwait(pkt); }
+    void armMonitor(Addr address) { getCpuPtr()->armMonitor(address, 0); }
+    bool mwait(PacketPtr pkt) { return getCpuPtr()->mwait(pkt, 0); }
     void mwaitAtomic(ThreadContext *tc)
-    { return getCpuPtr()->mwaitAtomic(tc, thread.dtb); }
+    { return getCpuPtr()->mwaitAtomic(tc, 0, thread.dtb); }
     AddressMonitor *getAddrMonitor()
-    { return getCpuPtr()->getCpuAddrMonitor(); }
+    { return getCpuPtr()->getAddrMonitor(0); }
 };
 
 }
diff --git a/src/cpu/o3/cpu.cc b/src/cpu/o3/cpu.cc
--- a/src/cpu/o3/cpu.cc
+++ b/src/cpu/o3/cpu.cc
@@ -119,9 +119,7 @@
 FullO3CPU<Impl>::DcachePort::recvTimingSnoopReq(PacketPtr pkt)
 {
     // X86 ISA: Snooping an invalidation for monitor/mwait
-    if(cpu->getCpuAddrMonitor()->doMonitor(pkt)) {
-        cpu->wakeup();
-    }
+    cpu->doMonitor(pkt);
     lsq->recvTimingSnoopReq(pkt);
 }
 
diff --git a/src/cpu/simple/atomic.cc b/src/cpu/simple/atomic.cc
--- a/src/cpu/simple/atomic.cc
+++ b/src/cpu/simple/atomic.cc
@@ -274,9 +274,7 @@
 
     // X86 ISA: Snooping an invalidation for monitor/mwait
     AtomicSimpleCPU *cpu = (AtomicSimpleCPU *)(&owner);
-    if(cpu->getAddrMonitor()->doMonitor(pkt)) {
-        cpu->wakeup();
-    }
+    cpu->doMonitor(pkt);
 
     // if snoop invalidates, release any associated locks
     if (pkt->isInvalidate()) {
@@ -296,9 +294,7 @@
 
     // X86 ISA: Snooping an invalidation for monitor/mwait
     AtomicSimpleCPU *cpu = (AtomicSimpleCPU *)(&owner);
-    if(cpu->getAddrMonitor()->doMonitor(pkt)) {
-        cpu->wakeup();
-    }
+    cpu->doMonitor(pkt);
 
     // if snoop invalidates, release any associated locks
     if (pkt->isInvalidate()) {
diff --git a/src/cpu/simple/base.hh b/src/cpu/simple/base.hh
--- a/src/cpu/simple/base.hh
+++ b/src/cpu/simple/base.hh
@@ -456,11 +456,11 @@
 
   public:
     // monitor/mwait funtions
-    void armMonitor(Addr address) { BaseCPU::armMonitor(address); }
-    bool mwait(PacketPtr pkt) { return BaseCPU::mwait(pkt); }
+    void armMonitor(Addr address) { BaseCPU::armMonitor(address, 0); }
+    bool mwait(PacketPtr pkt) { return BaseCPU::mwait(pkt, 0); }
     void mwaitAtomic(ThreadContext *tc)
-    { return BaseCPU::mwaitAtomic(tc, thread->dtb); }
-    AddressMonitor *getAddrMonitor() { return BaseCPU::getCpuAddrMonitor(); }
+    { return BaseCPU::mwaitAtomic(tc, 0, thread->dtb); }
+    AddressMonitor *getAddrMonitor() { return BaseCPU::getAddrMonitor(0); }
 };
 
 #endif // __CPU_SIMPLE_BASE_HH__
diff --git a/src/cpu/simple/timing.cc b/src/cpu/simple/timing.cc
--- a/src/cpu/simple/timing.cc
+++ b/src/cpu/simple/timing.cc
@@ -814,9 +814,7 @@
 TimingSimpleCPU::DcachePort::recvTimingSnoopReq(PacketPtr pkt)
 {
     // X86 ISA: Snooping an invalidation for monitor/mwait
-    if(cpu->getAddrMonitor()->doMonitor(pkt)) {
-        cpu->wakeup();
-    }
+    cpu->doMonitor(pkt);
     TheISA::handleLockedSnoop(cpu->thread, pkt, cacheBlockMask);
 }
 
@@ -824,9 +822,7 @@
 TimingSimpleCPU::DcachePort::recvFunctionalSnoop(PacketPtr pkt)
 {
     // X86 ISA: Snooping an invalidation for monitor/mwait
-    if(cpu->getAddrMonitor()->doMonitor(pkt)) {
-        cpu->wakeup();
-    }
+    cpu->doMonitor(pkt);
 }
 
 bool