sim: Decouple draining from the SimObject hierarchy
Draining is currently done by traversing the SimObject graph and calling drain()/drainResume() on the SimObjects. This is not ideal when non-SimObjects (e.g., ports) need draining since this means that SimObjects owning those objects need to be aware of this. This changeset moves the responsibility for finding objects that need draining from SimObjects and the Python-side of the simulator to the DrainManager. The DrainManager now maintains a set of all objects that need draining. To reduce the overhead in classes owning non-SimObjects that need draining, objects inheriting from Drainable now automatically register with the DrainManager. If such an object is destroyed, it is automatically unregistered. This means that drain() and drainResume() should never be called directly on a Drainable object. While implementing the new functionality, the DrainManager has now been made thread safe. In practice, this means that it takes a lock whenever it manipulates the set of Drainable objects since SimObjects in different threads may create Drainable objects dynamically. Similarly, the drain counter is now an atomic_uint, which ensures that it is manipulated correctly when objects signal that they are done draining. A nice side effect of these changes is that it makes the drain state changes stricter, which the simulation scripts can exploit to avoid redundant drains.
This commit is contained in:
parent
d5f5fbb855
commit
f16c0a4a90
31 changed files with 243 additions and 332 deletions
|
@ -141,12 +141,6 @@ Stage2MMU::Stage2Translation::finish(const Fault &_fault, RequestPtr req,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
Stage2MMU::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
return port.drain(dm);
|
|
||||||
}
|
|
||||||
|
|
||||||
ArmISA::Stage2MMU *
|
ArmISA::Stage2MMU *
|
||||||
ArmStage2MMUParams::create()
|
ArmStage2MMUParams::create()
|
||||||
{
|
{
|
||||||
|
|
|
@ -112,8 +112,6 @@ class Stage2MMU : public SimObject
|
||||||
*/
|
*/
|
||||||
DmaPort& getPort() { return port; }
|
DmaPort& getPort() { return port; }
|
||||||
|
|
||||||
unsigned int drain(DrainManager *dm);
|
|
||||||
|
|
||||||
Fault readDataUntimed(ThreadContext *tc, Addr oVAddr, Addr descAddr,
|
Fault readDataUntimed(ThreadContext *tc, Addr oVAddr, Addr descAddr,
|
||||||
uint8_t *data, int numBytes, Request::Flags flags, bool isFunctional);
|
uint8_t *data, int numBytes, Request::Flags flags, bool isFunctional);
|
||||||
Fault readDataTimed(ThreadContext *tc, Addr descAddr,
|
Fault readDataTimed(ThreadContext *tc, Addr descAddr,
|
||||||
|
|
|
@ -2319,26 +2319,16 @@ UFSHostDevice::unserialize(CheckpointIn &cp)
|
||||||
unsigned int
|
unsigned int
|
||||||
UFSHostDevice::drain(DrainManager *dm)
|
UFSHostDevice::drain(DrainManager *dm)
|
||||||
{
|
{
|
||||||
unsigned int count = 0;
|
|
||||||
|
|
||||||
// check pio, dma port, and doorbells
|
|
||||||
count = pioPort.drain(dm) + dmaPort.drain(dm);
|
|
||||||
|
|
||||||
if (UFSHCIMem.TRUTRLDBR) {
|
if (UFSHCIMem.TRUTRLDBR) {
|
||||||
count += 1;
|
|
||||||
drainManager = dm;
|
drainManager = dm;
|
||||||
} else {
|
|
||||||
DPRINTF(UFSHostDevice, "UFSHostDevice in drained state\n");
|
|
||||||
}
|
|
||||||
|
|
||||||
if (count) {
|
|
||||||
DPRINTF(UFSHostDevice, "UFSDevice is draining...\n");
|
DPRINTF(UFSHostDevice, "UFSDevice is draining...\n");
|
||||||
setDrainState(DrainState::Draining);
|
setDrainState(DrainState::Draining);
|
||||||
|
return 1;
|
||||||
} else {
|
} else {
|
||||||
DPRINTF(UFSHostDevice, "UFSDevice drained\n");
|
DPRINTF(UFSHostDevice, "UFSDevice drained\n");
|
||||||
setDrainState(DrainState::Drained);
|
setDrainState(DrainState::Drained);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
return count;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
|
|
@ -650,29 +650,10 @@ CopyEngine::CopyEngineChannel::drain(DrainManager *dm)
|
||||||
{
|
{
|
||||||
if (nextState == Idle || ce->getDrainState() != DrainState::Running)
|
if (nextState == Idle || ce->getDrainState() != DrainState::Running)
|
||||||
return 0;
|
return 0;
|
||||||
unsigned int count = 1;
|
|
||||||
count += cePort.drain(dm);
|
|
||||||
|
|
||||||
DPRINTF(Drain, "CopyEngineChannel not drained\n");
|
DPRINTF(Drain, "CopyEngineChannel not drained\n");
|
||||||
this->drainManager = dm;
|
this->drainManager = dm;
|
||||||
return count;
|
return 1;
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int
|
|
||||||
CopyEngine::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
unsigned int count;
|
|
||||||
count = pioPort.drain(dm) + dmaPort.drain(dm) + configPort.drain(dm);
|
|
||||||
for (int x = 0;x < chan.size(); x++)
|
|
||||||
count += chan[x]->drain(dm);
|
|
||||||
|
|
||||||
if (count)
|
|
||||||
setDrainState(DrainState::Draining);
|
|
||||||
else
|
|
||||||
setDrainState(DrainState::Drained);
|
|
||||||
|
|
||||||
DPRINTF(Drain, "CopyEngine not drained\n");
|
|
||||||
return count;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
@ -755,15 +736,6 @@ CopyEngine::CopyEngineChannel::restartStateMachine()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
|
||||||
CopyEngine::drainResume()
|
|
||||||
{
|
|
||||||
Drainable::drainResume();
|
|
||||||
for (int x = 0;x < chan.size(); x++)
|
|
||||||
chan[x]->drainResume();
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void
|
void
|
||||||
CopyEngine::CopyEngineChannel::drainResume()
|
CopyEngine::CopyEngineChannel::drainResume()
|
||||||
{
|
{
|
||||||
|
|
|
@ -207,9 +207,6 @@ class CopyEngine : public PciDevice
|
||||||
|
|
||||||
void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
|
void serialize(CheckpointOut &cp) const M5_ATTR_OVERRIDE;
|
||||||
void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
|
void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
|
||||||
|
|
||||||
unsigned int drain(DrainManager *drainManger);
|
|
||||||
void drainResume();
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif //__DEV_COPY_ENGINE_HH__
|
#endif //__DEV_COPY_ENGINE_HH__
|
||||||
|
|
|
@ -125,17 +125,6 @@ DmaDevice::init()
|
||||||
PioDevice::init();
|
PioDevice::init();
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
DmaDevice::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
unsigned int count = pioPort.drain(dm) + dmaPort.drain(dm);
|
|
||||||
if (count)
|
|
||||||
setDrainState(DrainState::Draining);
|
|
||||||
else
|
|
||||||
setDrainState(DrainState::Drained);
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int
|
unsigned int
|
||||||
DmaPort::drain(DrainManager *dm)
|
DmaPort::drain(DrainManager *dm)
|
||||||
{
|
{
|
||||||
|
|
|
@ -51,7 +51,7 @@
|
||||||
#include "sim/drain.hh"
|
#include "sim/drain.hh"
|
||||||
#include "sim/system.hh"
|
#include "sim/system.hh"
|
||||||
|
|
||||||
class DmaPort : public MasterPort
|
class DmaPort : public MasterPort, public Drainable
|
||||||
{
|
{
|
||||||
private:
|
private:
|
||||||
|
|
||||||
|
@ -176,8 +176,6 @@ class DmaDevice : public PioDevice
|
||||||
|
|
||||||
virtual void init();
|
virtual void init();
|
||||||
|
|
||||||
unsigned int drain(DrainManager *drainManger);
|
|
||||||
|
|
||||||
unsigned int cacheBlockSize() const { return sys->cacheLineSize(); }
|
unsigned int cacheBlockSize() const { return sys->cacheLineSize(); }
|
||||||
|
|
||||||
virtual BaseMasterPort &getMasterPort(const std::string &if_name,
|
virtual BaseMasterPort &getMasterPort(const std::string &if_name,
|
||||||
|
|
|
@ -2058,8 +2058,7 @@ IGbE::restartClock()
|
||||||
unsigned int
|
unsigned int
|
||||||
IGbE::drain(DrainManager *dm)
|
IGbE::drain(DrainManager *dm)
|
||||||
{
|
{
|
||||||
unsigned int count;
|
unsigned int count(0);
|
||||||
count = pioPort.drain(dm) + dmaPort.drain(dm);
|
|
||||||
if (rxDescCache.hasOutstandingEvents() ||
|
if (rxDescCache.hasOutstandingEvents() ||
|
||||||
txDescCache.hasOutstandingEvents()) {
|
txDescCache.hasOutstandingEvents()) {
|
||||||
count++;
|
count++;
|
||||||
|
|
|
@ -93,18 +93,6 @@ PioDevice::getSlavePort(const std::string &if_name, PortID idx)
|
||||||
return MemObject::getSlavePort(if_name, idx);
|
return MemObject::getSlavePort(if_name, idx);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
PioDevice::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
unsigned int count;
|
|
||||||
count = pioPort.drain(dm);
|
|
||||||
if (count)
|
|
||||||
setDrainState(DrainState::Draining);
|
|
||||||
else
|
|
||||||
setDrainState(DrainState::Drained);
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
BasicPioDevice::BasicPioDevice(const Params *p, Addr size)
|
BasicPioDevice::BasicPioDevice(const Params *p, Addr size)
|
||||||
: PioDevice(p), pioAddr(p->pio_addr), pioSize(size),
|
: PioDevice(p), pioAddr(p->pio_addr), pioSize(size),
|
||||||
pioDelay(p->pio_latency)
|
pioDelay(p->pio_latency)
|
||||||
|
|
|
@ -125,8 +125,6 @@ class PioDevice : public MemObject
|
||||||
|
|
||||||
virtual void init();
|
virtual void init();
|
||||||
|
|
||||||
unsigned int drain(DrainManager *drainManger);
|
|
||||||
|
|
||||||
virtual BaseSlavePort &getSlavePort(const std::string &if_name,
|
virtual BaseSlavePort &getSlavePort(const std::string &if_name,
|
||||||
PortID idx = InvalidPortID);
|
PortID idx = InvalidPortID);
|
||||||
|
|
||||||
|
|
|
@ -255,18 +255,6 @@ PciDevice::init()
|
||||||
DmaDevice::init();
|
DmaDevice::init();
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
PciDevice::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
unsigned int count;
|
|
||||||
count = pioPort.drain(dm) + dmaPort.drain(dm) + configPort.drain(dm);
|
|
||||||
if (count)
|
|
||||||
setDrainState(DrainState::Draining);
|
|
||||||
else
|
|
||||||
setDrainState(DrainState::Drained);
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
Tick
|
Tick
|
||||||
PciDevice::readConfig(PacketPtr pkt)
|
PciDevice::readConfig(PacketPtr pkt)
|
||||||
{
|
{
|
||||||
|
|
|
@ -259,8 +259,6 @@ class PciDevice : public DmaDevice
|
||||||
void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
|
void unserialize(CheckpointIn &cp) M5_ATTR_OVERRIDE;
|
||||||
|
|
||||||
|
|
||||||
virtual unsigned int drain(DrainManager *dm);
|
|
||||||
|
|
||||||
virtual BaseSlavePort &getSlavePort(const std::string &if_name,
|
virtual BaseSlavePort &getSlavePort(const std::string &if_name,
|
||||||
PortID idx = InvalidPortID)
|
PortID idx = InvalidPortID)
|
||||||
{
|
{
|
||||||
|
|
17
src/mem/cache/base.cc
vendored
17
src/mem/cache/base.cc
vendored
|
@ -775,23 +775,6 @@ BaseCache::regStats()
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
BaseCache::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
int count = memSidePort->drain(dm) + cpuSidePort->drain(dm) +
|
|
||||||
mshrQueue.drain(dm) + writeBuffer.drain(dm);
|
|
||||||
|
|
||||||
// Set status
|
|
||||||
if (count != 0) {
|
|
||||||
setDrainState(DrainState::Draining);
|
|
||||||
DPRINTF(Drain, "Cache not drained\n");
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
setDrainState(DrainState::Drained);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
BaseCache *
|
BaseCache *
|
||||||
BaseCacheParams::create()
|
BaseCacheParams::create()
|
||||||
{
|
{
|
||||||
|
|
2
src/mem/cache/base.hh
vendored
2
src/mem/cache/base.hh
vendored
|
@ -593,8 +593,6 @@ class BaseCache : public MemObject
|
||||||
// interesting again.
|
// interesting again.
|
||||||
}
|
}
|
||||||
|
|
||||||
virtual unsigned int drain(DrainManager *dm);
|
|
||||||
|
|
||||||
virtual bool inCache(Addr addr, bool is_secure) const = 0;
|
virtual bool inCache(Addr addr, bool is_secure) const = 0;
|
||||||
|
|
||||||
virtual bool inMissQueue(Addr addr, bool is_secure) const = 0;
|
virtual bool inMissQueue(Addr addr, bool is_secure) const = 0;
|
||||||
|
|
|
@ -834,20 +834,6 @@ CoherentXBar::forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
CoherentXBar::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
// sum up the individual layers
|
|
||||||
unsigned int total = 0;
|
|
||||||
for (auto l: reqLayers)
|
|
||||||
total += l->drain(dm);
|
|
||||||
for (auto l: respLayers)
|
|
||||||
total += l->drain(dm);
|
|
||||||
for (auto l: snoopLayers)
|
|
||||||
total += l->drain(dm);
|
|
||||||
return total;
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
void
|
||||||
CoherentXBar::regStats()
|
CoherentXBar::regStats()
|
||||||
{
|
{
|
||||||
|
|
|
@ -396,8 +396,6 @@ class CoherentXBar : public BaseXBar
|
||||||
|
|
||||||
virtual ~CoherentXBar();
|
virtual ~CoherentXBar();
|
||||||
|
|
||||||
unsigned int drain(DrainManager *dm);
|
|
||||||
|
|
||||||
virtual void regStats();
|
virtual void regStats();
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
|
@ -2169,8 +2169,6 @@ DRAMCtrl::getSlavePort(const string &if_name, PortID idx)
|
||||||
unsigned int
|
unsigned int
|
||||||
DRAMCtrl::drain(DrainManager *dm)
|
DRAMCtrl::drain(DrainManager *dm)
|
||||||
{
|
{
|
||||||
unsigned int count = port.drain(dm);
|
|
||||||
|
|
||||||
// if there is anything in any of our internal queues, keep track
|
// if there is anything in any of our internal queues, keep track
|
||||||
// of that as well
|
// of that as well
|
||||||
if (!(writeQueue.empty() && readQueue.empty() &&
|
if (!(writeQueue.empty() && readQueue.empty() &&
|
||||||
|
@ -2178,7 +2176,6 @@ DRAMCtrl::drain(DrainManager *dm)
|
||||||
DPRINTF(Drain, "DRAM controller not drained, write: %d, read: %d,"
|
DPRINTF(Drain, "DRAM controller not drained, write: %d, read: %d,"
|
||||||
" resp: %d\n", writeQueue.size(), readQueue.size(),
|
" resp: %d\n", writeQueue.size(), readQueue.size(),
|
||||||
respQueue.size());
|
respQueue.size());
|
||||||
++count;
|
|
||||||
drainManager = dm;
|
drainManager = dm;
|
||||||
|
|
||||||
// the only part that is not drained automatically over time
|
// the only part that is not drained automatically over time
|
||||||
|
@ -2186,13 +2183,12 @@ DRAMCtrl::drain(DrainManager *dm)
|
||||||
if (!writeQueue.empty() && !nextReqEvent.scheduled()) {
|
if (!writeQueue.empty() && !nextReqEvent.scheduled()) {
|
||||||
schedule(nextReqEvent, curTick());
|
schedule(nextReqEvent, curTick());
|
||||||
}
|
}
|
||||||
}
|
|
||||||
|
|
||||||
if (count)
|
|
||||||
setDrainState(DrainState::Draining);
|
setDrainState(DrainState::Draining);
|
||||||
else
|
return 1;
|
||||||
|
} else {
|
||||||
setDrainState(DrainState::Drained);
|
setDrainState(DrainState::Drained);
|
||||||
return count;
|
return 0;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
|
@ -313,18 +313,6 @@ NoncoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id)
|
||||||
masterPorts[dest_id]->sendFunctional(pkt);
|
masterPorts[dest_id]->sendFunctional(pkt);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
NoncoherentXBar::drain(DrainManager *dm)
|
|
||||||
{
|
|
||||||
// sum up the individual layers
|
|
||||||
unsigned int total = 0;
|
|
||||||
for (auto l: reqLayers)
|
|
||||||
total += l->drain(dm);
|
|
||||||
for (auto l: respLayers)
|
|
||||||
total += l->drain(dm);
|
|
||||||
return total;
|
|
||||||
}
|
|
||||||
|
|
||||||
NoncoherentXBar*
|
NoncoherentXBar*
|
||||||
NoncoherentXBarParams::create()
|
NoncoherentXBarParams::create()
|
||||||
{
|
{
|
||||||
|
|
|
@ -195,8 +195,6 @@ class NoncoherentXBar : public BaseXBar
|
||||||
|
|
||||||
virtual ~NoncoherentXBar();
|
virtual ~NoncoherentXBar();
|
||||||
|
|
||||||
unsigned int drain(DrainManager *dm);
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* stats
|
* stats
|
||||||
*/
|
*/
|
||||||
|
|
|
@ -95,8 +95,6 @@ class QueuedSlavePort : public SlavePort
|
||||||
* functional request. */
|
* functional request. */
|
||||||
bool checkFunctional(PacketPtr pkt)
|
bool checkFunctional(PacketPtr pkt)
|
||||||
{ return respQueue.checkFunctional(pkt); }
|
{ return respQueue.checkFunctional(pkt); }
|
||||||
|
|
||||||
unsigned int drain(DrainManager *dm) { return respQueue.drain(dm); }
|
|
||||||
};
|
};
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -166,9 +164,6 @@ class QueuedMasterPort : public MasterPort
|
||||||
return reqQueue.checkFunctional(pkt) ||
|
return reqQueue.checkFunctional(pkt) ||
|
||||||
snoopRespQueue.checkFunctional(pkt);
|
snoopRespQueue.checkFunctional(pkt);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int drain(DrainManager *dm)
|
|
||||||
{ return reqQueue.drain(dm) + snoopRespQueue.drain(dm); }
|
|
||||||
};
|
};
|
||||||
|
|
||||||
#endif // __MEM_QPORT_HH__
|
#endif // __MEM_QPORT_HH__
|
||||||
|
|
|
@ -160,15 +160,6 @@ DMASequencer::testDrainComplete()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
DMASequencer::getChildDrainCount(DrainManager *dm)
|
|
||||||
{
|
|
||||||
int count = 0;
|
|
||||||
count += slave_port.drain(dm);
|
|
||||||
DPRINTF(Config, "count after slave port check %d\n", count);
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int
|
unsigned int
|
||||||
DMASequencer::drain(DrainManager *dm)
|
DMASequencer::drain(DrainManager *dm)
|
||||||
{
|
{
|
||||||
|
@ -181,11 +172,6 @@ DMASequencer::drain(DrainManager *dm)
|
||||||
DPRINTF(Config, "outstanding count %d\n", outstandingCount());
|
DPRINTF(Config, "outstanding count %d\n", outstandingCount());
|
||||||
bool need_drain = outstandingCount() > 0;
|
bool need_drain = outstandingCount() > 0;
|
||||||
|
|
||||||
//
|
|
||||||
// Also, get the number of child ports that will also need to clear
|
|
||||||
// their buffered requests before they call drainManager->signalDrainDone()
|
|
||||||
//
|
|
||||||
unsigned int child_drain_count = getChildDrainCount(dm);
|
|
||||||
|
|
||||||
// Set status
|
// Set status
|
||||||
if (need_drain) {
|
if (need_drain) {
|
||||||
|
@ -193,12 +179,12 @@ DMASequencer::drain(DrainManager *dm)
|
||||||
|
|
||||||
DPRINTF(Drain, "DMASequencer not drained\n");
|
DPRINTF(Drain, "DMASequencer not drained\n");
|
||||||
setDrainState(DrainState::Draining);
|
setDrainState(DrainState::Draining);
|
||||||
return child_drain_count + 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
drainManager = NULL;
|
drainManager = NULL;
|
||||||
setDrainState(DrainState::Drained);
|
setDrainState(DrainState::Drained);
|
||||||
return child_drain_count;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
|
@ -399,31 +399,6 @@ RubyPort::testDrainComplete()
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
|
||||||
RubyPort::getChildDrainCount(DrainManager *dm)
|
|
||||||
{
|
|
||||||
int count = 0;
|
|
||||||
|
|
||||||
if (memMasterPort.isConnected()) {
|
|
||||||
count += memMasterPort.drain(dm);
|
|
||||||
DPRINTF(Config, "count after pio check %d\n", count);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (CpuPortIter p = slave_ports.begin(); p != slave_ports.end(); ++p) {
|
|
||||||
count += (*p)->drain(dm);
|
|
||||||
DPRINTF(Config, "count after slave port check %d\n", count);
|
|
||||||
}
|
|
||||||
|
|
||||||
for (std::vector<PioMasterPort *>::iterator p = master_ports.begin();
|
|
||||||
p != master_ports.end(); ++p) {
|
|
||||||
count += (*p)->drain(dm);
|
|
||||||
DPRINTF(Config, "count after master port check %d\n", count);
|
|
||||||
}
|
|
||||||
|
|
||||||
DPRINTF(Config, "final count %d\n", count);
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
unsigned int
|
unsigned int
|
||||||
RubyPort::drain(DrainManager *dm)
|
RubyPort::drain(DrainManager *dm)
|
||||||
{
|
{
|
||||||
|
@ -438,24 +413,18 @@ RubyPort::drain(DrainManager *dm)
|
||||||
DPRINTF(Config, "outstanding count %d\n", outstandingCount());
|
DPRINTF(Config, "outstanding count %d\n", outstandingCount());
|
||||||
bool need_drain = outstandingCount() > 0;
|
bool need_drain = outstandingCount() > 0;
|
||||||
|
|
||||||
//
|
|
||||||
// Also, get the number of child ports that will also need to clear
|
|
||||||
// their buffered requests before they call drainManager->signalDrainDone()
|
|
||||||
//
|
|
||||||
unsigned int child_drain_count = getChildDrainCount(dm);
|
|
||||||
|
|
||||||
// Set status
|
// Set status
|
||||||
if (need_drain) {
|
if (need_drain) {
|
||||||
drainManager = dm;
|
drainManager = dm;
|
||||||
|
|
||||||
DPRINTF(Drain, "RubyPort not drained\n");
|
DPRINTF(Drain, "RubyPort not drained\n");
|
||||||
setDrainState(DrainState::Draining);
|
setDrainState(DrainState::Draining);
|
||||||
return child_drain_count + 1;
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
drainManager = NULL;
|
drainManager = NULL;
|
||||||
setDrainState(DrainState::Drained);
|
setDrainState(DrainState::Drained);
|
||||||
return child_drain_count;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
|
@ -193,8 +193,6 @@ class RubyPort : public MemObject
|
||||||
retryList.push_back(port);
|
retryList.push_back(port);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int getChildDrainCount(DrainManager *dm);
|
|
||||||
|
|
||||||
PioMasterPort pioMasterPort;
|
PioMasterPort pioMasterPort;
|
||||||
PioSlavePort pioSlavePort;
|
PioSlavePort pioSlavePort;
|
||||||
MemMasterPort memMasterPort;
|
MemMasterPort memMasterPort;
|
||||||
|
|
|
@ -467,8 +467,6 @@ class BaseXBar : public MemObject
|
||||||
BaseSlavePort& getSlavePort(const std::string& if_name,
|
BaseSlavePort& getSlavePort(const std::string& if_name,
|
||||||
PortID idx = InvalidPortID);
|
PortID idx = InvalidPortID);
|
||||||
|
|
||||||
virtual unsigned int drain(DrainManager *dm) = 0;
|
|
||||||
|
|
||||||
virtual void regStats();
|
virtual void regStats();
|
||||||
|
|
||||||
};
|
};
|
||||||
|
|
|
@ -66,6 +66,8 @@ _memory_modes = {
|
||||||
"atomic_noncaching" : objects.params.atomic_noncaching,
|
"atomic_noncaching" : objects.params.atomic_noncaching,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
_drain_manager = internal.drain.DrainManager.instance()
|
||||||
|
|
||||||
# The final hook to generate .ini files. Called from the user script
|
# The final hook to generate .ini files. Called from the user script
|
||||||
# once the config is built.
|
# once the config is built.
|
||||||
def instantiate(ckpt_dir=None):
|
def instantiate(ckpt_dir=None):
|
||||||
|
@ -129,10 +131,10 @@ def instantiate(ckpt_dir=None):
|
||||||
|
|
||||||
# Restore checkpoint (if any)
|
# Restore checkpoint (if any)
|
||||||
if ckpt_dir:
|
if ckpt_dir:
|
||||||
|
_drain_manager.preCheckpointRestore()
|
||||||
ckpt = internal.core.getCheckpoint(ckpt_dir)
|
ckpt = internal.core.getCheckpoint(ckpt_dir)
|
||||||
internal.core.unserializeGlobals(ckpt);
|
internal.core.unserializeGlobals(ckpt);
|
||||||
for obj in root.descendants(): obj.loadState(ckpt)
|
for obj in root.descendants(): obj.loadState(ckpt)
|
||||||
need_resume.append(root)
|
|
||||||
else:
|
else:
|
||||||
for obj in root.descendants(): obj.initState()
|
for obj in root.descendants(): obj.initState()
|
||||||
|
|
||||||
|
@ -140,10 +142,9 @@ def instantiate(ckpt_dir=None):
|
||||||
# a checkpoint, If so, this call will shift them to be at a valid time.
|
# a checkpoint, If so, this call will shift them to be at a valid time.
|
||||||
updateStatEvents()
|
updateStatEvents()
|
||||||
|
|
||||||
need_resume = []
|
|
||||||
need_startup = True
|
need_startup = True
|
||||||
def simulate(*args, **kwargs):
|
def simulate(*args, **kwargs):
|
||||||
global need_resume, need_startup
|
global need_startup
|
||||||
|
|
||||||
if need_startup:
|
if need_startup:
|
||||||
root = objects.Root.getInstance()
|
root = objects.Root.getInstance()
|
||||||
|
@ -160,9 +161,8 @@ def simulate(*args, **kwargs):
|
||||||
# Reset to put the stats in a consistent state.
|
# Reset to put the stats in a consistent state.
|
||||||
stats.reset()
|
stats.reset()
|
||||||
|
|
||||||
for root in need_resume:
|
if _drain_manager.isDrained():
|
||||||
resume(root)
|
_drain_manager.resume()
|
||||||
need_resume = []
|
|
||||||
|
|
||||||
return internal.event.simulate(*args, **kwargs)
|
return internal.event.simulate(*args, **kwargs)
|
||||||
|
|
||||||
|
@ -170,33 +170,40 @@ def simulate(*args, **kwargs):
|
||||||
def curTick():
|
def curTick():
|
||||||
return internal.core.curTick()
|
return internal.core.curTick()
|
||||||
|
|
||||||
# Drain the system in preparation of a checkpoint or memory mode
|
def drain():
|
||||||
# switch.
|
"""Drain the simulator in preparation of a checkpoint or memory mode
|
||||||
def drain(root):
|
switch.
|
||||||
|
|
||||||
|
This operation is a no-op if the simulator is already in the
|
||||||
|
Drained state.
|
||||||
|
|
||||||
|
"""
|
||||||
|
|
||||||
# Try to drain all objects. Draining might not be completed unless
|
# Try to drain all objects. Draining might not be completed unless
|
||||||
# all objects return that they are drained on the first call. This
|
# all objects return that they are drained on the first call. This
|
||||||
# is because as objects drain they may cause other objects to no
|
# is because as objects drain they may cause other objects to no
|
||||||
# longer be drained.
|
# longer be drained.
|
||||||
def _drain():
|
def _drain():
|
||||||
all_drained = False
|
# Try to drain the system. The drain is successful if all
|
||||||
dm = internal.drain.createDrainManager()
|
# objects are done without simulation. We need to simulate
|
||||||
unready_objs = sum(obj.drain(dm) for obj in root.descendants())
|
# more if not.
|
||||||
# If we've got some objects that can't drain immediately, then simulate
|
if _drain_manager.tryDrain():
|
||||||
if unready_objs > 0:
|
return True
|
||||||
dm.setCount(unready_objs)
|
|
||||||
#WARNING: if a valid exit event occurs while draining, it will not
|
# WARNING: if a valid exit event occurs while draining, it
|
||||||
# get returned to the user script
|
# will not get returned to the user script
|
||||||
exit_event = simulate()
|
exit_event = internal.event.simulate()
|
||||||
while exit_event.getCause() != 'Finished drain':
|
while exit_event.getCause() != 'Finished drain':
|
||||||
exit_event = simulate()
|
exit_event = simulate()
|
||||||
else:
|
|
||||||
all_drained = True
|
|
||||||
internal.drain.cleanupDrainManager(dm)
|
|
||||||
return all_drained
|
|
||||||
|
|
||||||
all_drained = _drain()
|
return False
|
||||||
while (not all_drained):
|
|
||||||
all_drained = _drain()
|
# Don't try to drain a system that is already drained
|
||||||
|
is_drained = _drain_manager.isDrained()
|
||||||
|
while not is_drained:
|
||||||
|
is_drained = _drain()
|
||||||
|
|
||||||
|
assert _drain_manager.isDrained(), "Drain state inconsistent"
|
||||||
|
|
||||||
def memWriteback(root):
|
def memWriteback(root):
|
||||||
for obj in root.descendants():
|
for obj in root.descendants():
|
||||||
|
@ -206,18 +213,15 @@ def memInvalidate(root):
|
||||||
for obj in root.descendants():
|
for obj in root.descendants():
|
||||||
obj.memInvalidate()
|
obj.memInvalidate()
|
||||||
|
|
||||||
def resume(root):
|
|
||||||
for obj in root.descendants(): obj.drainResume()
|
|
||||||
|
|
||||||
def checkpoint(dir):
|
def checkpoint(dir):
|
||||||
root = objects.Root.getInstance()
|
root = objects.Root.getInstance()
|
||||||
if not isinstance(root, objects.Root):
|
if not isinstance(root, objects.Root):
|
||||||
raise TypeError, "Checkpoint must be called on a root object."
|
raise TypeError, "Checkpoint must be called on a root object."
|
||||||
drain(root)
|
|
||||||
|
drain()
|
||||||
memWriteback(root)
|
memWriteback(root)
|
||||||
print "Writing checkpoint"
|
print "Writing checkpoint"
|
||||||
internal.core.serializeAll(dir)
|
internal.core.serializeAll(dir)
|
||||||
resume(root)
|
|
||||||
|
|
||||||
def _changeMemoryMode(system, mode):
|
def _changeMemoryMode(system, mode):
|
||||||
if not isinstance(system, (objects.Root, objects.System)):
|
if not isinstance(system, (objects.Root, objects.System)):
|
||||||
|
@ -228,15 +232,9 @@ def _changeMemoryMode(system, mode):
|
||||||
else:
|
else:
|
||||||
print "System already in target mode. Memory mode unchanged."
|
print "System already in target mode. Memory mode unchanged."
|
||||||
|
|
||||||
def switchCpus(system, cpuList, do_drain=True, verbose=True):
|
def switchCpus(system, cpuList, verbose=True):
|
||||||
"""Switch CPUs in a system.
|
"""Switch CPUs in a system.
|
||||||
|
|
||||||
By default, this method drains and resumes the system. This
|
|
||||||
behavior can be disabled by setting the keyword argument
|
|
||||||
'do_drain' to false, which might be desirable if multiple
|
|
||||||
operations requiring a drained system are going to be performed in
|
|
||||||
sequence.
|
|
||||||
|
|
||||||
Note: This method may switch the memory mode of the system if that
|
Note: This method may switch the memory mode of the system if that
|
||||||
is required by the CPUs. It may also flush all caches in the
|
is required by the CPUs. It may also flush all caches in the
|
||||||
system.
|
system.
|
||||||
|
@ -244,9 +242,6 @@ def switchCpus(system, cpuList, do_drain=True, verbose=True):
|
||||||
Arguments:
|
Arguments:
|
||||||
system -- Simulated system.
|
system -- Simulated system.
|
||||||
cpuList -- (old_cpu, new_cpu) tuples
|
cpuList -- (old_cpu, new_cpu) tuples
|
||||||
|
|
||||||
Keyword Arguments:
|
|
||||||
do_drain -- Perform a drain/resume of the system when switching.
|
|
||||||
"""
|
"""
|
||||||
|
|
||||||
if verbose:
|
if verbose:
|
||||||
|
@ -292,8 +287,7 @@ def switchCpus(system, cpuList, do_drain=True, verbose=True):
|
||||||
except KeyError:
|
except KeyError:
|
||||||
raise RuntimeError, "Invalid memory mode (%s)" % memory_mode_name
|
raise RuntimeError, "Invalid memory mode (%s)" % memory_mode_name
|
||||||
|
|
||||||
if do_drain:
|
drain()
|
||||||
drain(system)
|
|
||||||
|
|
||||||
# Now all of the CPUs are ready to be switched out
|
# Now all of the CPUs are ready to be switched out
|
||||||
for old_cpu, new_cpu in cpuList:
|
for old_cpu, new_cpu in cpuList:
|
||||||
|
@ -314,7 +308,4 @@ def switchCpus(system, cpuList, do_drain=True, verbose=True):
|
||||||
for old_cpu, new_cpu in cpuList:
|
for old_cpu, new_cpu in cpuList:
|
||||||
new_cpu.takeOverFrom(old_cpu)
|
new_cpu.takeOverFrom(old_cpu)
|
||||||
|
|
||||||
if do_drain:
|
|
||||||
resume(system)
|
|
||||||
|
|
||||||
from internal.core import disableAllListeners
|
from internal.core import disableAllListeners
|
||||||
|
|
|
@ -46,21 +46,3 @@
|
||||||
%nodefaultctor Drainable;
|
%nodefaultctor Drainable;
|
||||||
|
|
||||||
%include "sim/drain.hh"
|
%include "sim/drain.hh"
|
||||||
|
|
||||||
%inline %{
|
|
||||||
|
|
||||||
DrainManager *
|
|
||||||
createDrainManager()
|
|
||||||
{
|
|
||||||
return new DrainManager();
|
|
||||||
}
|
|
||||||
|
|
||||||
void
|
|
||||||
cleanupDrainManager(DrainManager *drain_manager)
|
|
||||||
{
|
|
||||||
assert(drain_manager);
|
|
||||||
assert(drain_manager->getCount() == 0);
|
|
||||||
delete drain_manager;
|
|
||||||
}
|
|
||||||
|
|
||||||
%}
|
|
||||||
|
|
|
@ -644,20 +644,15 @@ CxxConfigManager::startup()
|
||||||
}
|
}
|
||||||
|
|
||||||
unsigned int
|
unsigned int
|
||||||
CxxConfigManager::drain(DrainManager *drain_manager)
|
CxxConfigManager::drain()
|
||||||
{
|
{
|
||||||
unsigned int ret = 0;
|
return DrainManager::instance().tryDrain() ? 0 : 1;
|
||||||
|
|
||||||
for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++ i)
|
|
||||||
ret += (*i)->drain(drain_manager);
|
|
||||||
|
|
||||||
return ret;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
CxxConfigManager::drainResume()
|
CxxConfigManager::drainResume()
|
||||||
{
|
{
|
||||||
forEachObject(&SimObject::drainResume);
|
DrainManager::instance().resume();
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
|
@ -283,7 +283,7 @@ class CxxConfigManager
|
||||||
void startup();
|
void startup();
|
||||||
|
|
||||||
/** Drain all objects */
|
/** Drain all objects */
|
||||||
unsigned int drain(DrainManager *drain_manager);
|
unsigned int drain();
|
||||||
|
|
||||||
/** Resume from drain */
|
/** Resume from drain */
|
||||||
void drainResume();
|
void drainResume();
|
||||||
|
|
102
src/sim/drain.cc
102
src/sim/drain.cc
|
@ -38,10 +38,17 @@
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#include "sim/drain.hh"
|
#include "sim/drain.hh"
|
||||||
|
|
||||||
|
#include "base/misc.hh"
|
||||||
|
#include "base/trace.hh"
|
||||||
|
#include "debug/Drain.hh"
|
||||||
#include "sim/sim_exit.hh"
|
#include "sim/sim_exit.hh"
|
||||||
|
|
||||||
|
DrainManager DrainManager::_instance;
|
||||||
|
|
||||||
DrainManager::DrainManager()
|
DrainManager::DrainManager()
|
||||||
: _count(0)
|
: _count(0),
|
||||||
|
_state(DrainState::Running)
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -49,21 +56,108 @@ DrainManager::~DrainManager()
|
||||||
{
|
{
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
bool
|
||||||
DrainManager::drainCycleDone()
|
DrainManager::tryDrain()
|
||||||
{
|
{
|
||||||
|
panic_if(_state == DrainState::Drained,
|
||||||
|
"Trying to drain a drained system\n");
|
||||||
|
|
||||||
|
panic_if(_count != 0,
|
||||||
|
"Drain counter must be zero at the start of a drain cycle\n");
|
||||||
|
|
||||||
|
DPRINTF(Drain, "Trying to drain %u objects.\n", drainableCount());
|
||||||
|
_state = DrainState::Draining;
|
||||||
|
for (auto *obj : _allDrainable)
|
||||||
|
_count += obj->drain(&_instance);
|
||||||
|
|
||||||
|
if (_count == 0) {
|
||||||
|
DPRINTF(Drain, "Drain done.\n");
|
||||||
|
_state = DrainState::Drained;
|
||||||
|
return true;
|
||||||
|
} else {
|
||||||
|
DPRINTF(Drain, "Need another drain cycle. %u/%u objects not ready.\n",
|
||||||
|
_count, drainableCount());
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
DrainManager::resume()
|
||||||
|
{
|
||||||
|
panic_if(_state == DrainState::Running,
|
||||||
|
"Trying to resume a system that is already running\n");
|
||||||
|
|
||||||
|
warn_if(_state == DrainState::Draining,
|
||||||
|
"Resuming a system that isn't fully drained, this is untested and "
|
||||||
|
"likely to break\n");
|
||||||
|
|
||||||
|
panic_if(_count != 0,
|
||||||
|
"Resume called in the middle of a drain cycle. %u objects "
|
||||||
|
"left to drain.\n", _count);
|
||||||
|
|
||||||
|
DPRINTF(Drain, "Resuming %u objects.\n", drainableCount());
|
||||||
|
_state = DrainState::Running;
|
||||||
|
for (auto *obj : _allDrainable)
|
||||||
|
obj->drainResume();
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
DrainManager::preCheckpointRestore()
|
||||||
|
{
|
||||||
|
panic_if(_state != DrainState::Running,
|
||||||
|
"preCheckpointRestore() called on a system that isn't in the "
|
||||||
|
"Running state.\n");
|
||||||
|
|
||||||
|
DPRINTF(Drain, "Applying pre-restore fixes to %u objects.\n",
|
||||||
|
drainableCount());
|
||||||
|
_state = DrainState::Drained;
|
||||||
|
for (auto *obj : _allDrainable)
|
||||||
|
obj->_drainState = DrainState::Drained;
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
DrainManager::signalDrainDone()
|
||||||
|
{
|
||||||
|
if (--_count == 0) {
|
||||||
|
DPRINTF(Drain, "All %u objects drained..\n", drainableCount());
|
||||||
exitSimLoop("Finished drain", 0);
|
exitSimLoop("Finished drain", 0);
|
||||||
}
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
void
|
||||||
|
DrainManager::registerDrainable(Drainable *obj)
|
||||||
|
{
|
||||||
|
std::lock_guard<std::mutex> lock(globalLock);
|
||||||
|
_allDrainable.insert(obj);
|
||||||
|
}
|
||||||
|
|
||||||
|
void
|
||||||
|
DrainManager::unregisterDrainable(Drainable *obj)
|
||||||
|
{
|
||||||
|
std::lock_guard<std::mutex> lock(globalLock);
|
||||||
|
_allDrainable.erase(obj);
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t
|
||||||
|
DrainManager::drainableCount() const
|
||||||
|
{
|
||||||
|
std::lock_guard<std::mutex> lock(globalLock);
|
||||||
|
return _allDrainable.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
Drainable::Drainable()
|
Drainable::Drainable()
|
||||||
: _drainState(DrainState::Running)
|
: _drainManager(DrainManager::instance()),
|
||||||
|
_drainState(DrainState::Running)
|
||||||
{
|
{
|
||||||
|
_drainManager.registerDrainable(this);
|
||||||
}
|
}
|
||||||
|
|
||||||
Drainable::~Drainable()
|
Drainable::~Drainable()
|
||||||
{
|
{
|
||||||
|
_drainManager.unregisterDrainable(this);
|
||||||
}
|
}
|
||||||
|
|
||||||
void
|
void
|
||||||
|
|
126
src/sim/drain.hh
126
src/sim/drain.hh
|
@ -40,8 +40,9 @@
|
||||||
#ifndef __SIM_DRAIN_HH__
|
#ifndef __SIM_DRAIN_HH__
|
||||||
#define __SIM_DRAIN_HH__
|
#define __SIM_DRAIN_HH__
|
||||||
|
|
||||||
#include <cassert>
|
#include <atomic>
|
||||||
#include <vector>
|
#include <mutex>
|
||||||
|
#include <unordered_set>
|
||||||
|
|
||||||
#include "base/flags.hh"
|
#include "base/flags.hh"
|
||||||
|
|
||||||
|
@ -76,12 +77,12 @@ enum class DrainState {
|
||||||
/**
|
/**
|
||||||
* This class coordinates draining of a System.
|
* This class coordinates draining of a System.
|
||||||
*
|
*
|
||||||
* When draining a System, we need to make sure that all SimObjects in
|
* When draining the simulator, we need to make sure that all
|
||||||
* that system have drained their state before declaring the operation
|
* Drainable objects within the system have ended up in the drained
|
||||||
* to be successful. This class keeps track of how many objects are
|
* state before declaring the operation to be successful. This class
|
||||||
* still in the process of draining their state. Once it determines
|
* keeps track of how many objects are still in the process of
|
||||||
* that all objects have drained their state, it exits the simulation
|
* draining. Once it determines that all objects have drained their
|
||||||
* loop.
|
* state, it exits the simulation loop.
|
||||||
*
|
*
|
||||||
* @note A System might not be completely drained even though the
|
* @note A System might not be completely drained even though the
|
||||||
* DrainManager has caused the simulation loop to exit. Draining needs
|
* DrainManager has caused the simulation loop to exit. Draining needs
|
||||||
|
@ -91,39 +92,92 @@ enum class DrainState {
|
||||||
*/
|
*/
|
||||||
class DrainManager
|
class DrainManager
|
||||||
{
|
{
|
||||||
public:
|
private:
|
||||||
DrainManager();
|
DrainManager();
|
||||||
virtual ~DrainManager();
|
#ifndef SWIG
|
||||||
|
DrainManager(DrainManager &) = delete;
|
||||||
|
#endif
|
||||||
|
~DrainManager();
|
||||||
|
|
||||||
|
public:
|
||||||
|
/** Get the singleton DrainManager instance */
|
||||||
|
static DrainManager &instance() { return _instance; }
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Get the number of objects registered with this DrainManager
|
* Try to drain the system.
|
||||||
* that are currently draining their state.
|
|
||||||
*
|
*
|
||||||
* @return Number of objects currently draining.
|
* Try to drain the system and return true if all objects are in a
|
||||||
|
* the Drained state at which point the whole simulator is in a
|
||||||
|
* consistent state and ready for checkpointing or CPU
|
||||||
|
* handover. The simulation script must continue simulating until
|
||||||
|
* the simulation loop returns "Finished drain", at which point
|
||||||
|
* this method should be called again. This cycle should continue
|
||||||
|
* until this method returns true.
|
||||||
|
*
|
||||||
|
* @return true if all objects were drained successfully, false if
|
||||||
|
* more simulation is needed.
|
||||||
*/
|
*/
|
||||||
unsigned int getCount() const { return _count; }
|
bool tryDrain();
|
||||||
|
|
||||||
void setCount(int count) { _count = count; }
|
/**
|
||||||
|
* Resume normal simulation in a Drained system.
|
||||||
|
*/
|
||||||
|
void resume();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Run state fixups before a checkpoint restore operation
|
||||||
|
*
|
||||||
|
* The drain state of an object isn't stored in a checkpoint since
|
||||||
|
* the whole system is always going to be in the Drained state
|
||||||
|
* when the checkpoint is created. When the checkpoint is restored
|
||||||
|
* at a later stage, recreated objects will be in the Running
|
||||||
|
* state since the state isn't stored in checkpoints. This method
|
||||||
|
* performs state fixups on all Drainable objects and the
|
||||||
|
* DrainManager itself.
|
||||||
|
*/
|
||||||
|
void preCheckpointRestore();
|
||||||
|
|
||||||
|
/** Check if the system is drained */
|
||||||
|
bool isDrained() { return _state == DrainState::Drained; }
|
||||||
|
|
||||||
|
/** Get the simulators global drain state */
|
||||||
|
DrainState state() { return _state; }
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Notify the DrainManager that a Drainable object has finished
|
* Notify the DrainManager that a Drainable object has finished
|
||||||
* draining.
|
* draining.
|
||||||
*/
|
*/
|
||||||
void signalDrainDone() {
|
void signalDrainDone();
|
||||||
assert(_count > 0);
|
|
||||||
if (--_count == 0)
|
|
||||||
drainCycleDone();
|
|
||||||
}
|
|
||||||
|
|
||||||
protected:
|
public:
|
||||||
|
void registerDrainable(Drainable *obj);
|
||||||
|
void unregisterDrainable(Drainable *obj);
|
||||||
|
|
||||||
|
private:
|
||||||
/**
|
/**
|
||||||
* Callback when all registered Drainable objects have completed a
|
* Thread-safe helper function to get the number of Drainable
|
||||||
* drain cycle.
|
* objects in a system.
|
||||||
*/
|
*/
|
||||||
virtual void drainCycleDone();
|
size_t drainableCount() const;
|
||||||
|
|
||||||
/** Number of objects still draining. */
|
/** Lock protecting the set of drainable objects */
|
||||||
unsigned int _count;
|
mutable std::mutex globalLock;
|
||||||
|
|
||||||
|
/** Set of all drainable objects */
|
||||||
|
std::unordered_set<Drainable *> _allDrainable;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Number of objects still draining. This is flagged atomic since
|
||||||
|
* it can be manipulated by SimObjects living in different
|
||||||
|
* threads.
|
||||||
|
*/
|
||||||
|
std::atomic_uint _count;
|
||||||
|
|
||||||
|
/** Global simulator drain state */
|
||||||
|
DrainState _state;
|
||||||
|
|
||||||
|
/** Singleton instance of the drain manager */
|
||||||
|
static DrainManager _instance;
|
||||||
};
|
};
|
||||||
|
|
||||||
/**
|
/**
|
||||||
|
@ -133,17 +187,11 @@ class DrainManager
|
||||||
* An object's internal state needs to be drained when creating a
|
* An object's internal state needs to be drained when creating a
|
||||||
* checkpoint, switching between CPU models, or switching between
|
* checkpoint, switching between CPU models, or switching between
|
||||||
* timing models. Once the internal state has been drained from
|
* timing models. Once the internal state has been drained from
|
||||||
* <i>all</i> objects in the system, the objects are serialized to
|
* <i>all</i> objects in the simulator, the objects are serialized to
|
||||||
* disc or the configuration change takes place. The process works as
|
* disc or the configuration change takes place. The process works as
|
||||||
* follows (see simulate.py for details):
|
* follows (see simulate.py for details):
|
||||||
*
|
*
|
||||||
* <ol>
|
* <ol>
|
||||||
* <li>An instance of a DrainManager is created to keep track of how
|
|
||||||
* many objects need to be drained. The object maintains an
|
|
||||||
* internal counter that is decreased every time its
|
|
||||||
* CountedDrainEvent::signalDrainDone() method is called. When the
|
|
||||||
* counter reaches zero, the simulation is stopped.
|
|
||||||
*
|
|
||||||
* <li>Call Drainable::drain() for every object in the
|
* <li>Call Drainable::drain() for every object in the
|
||||||
* system. Draining has completed if all of them return
|
* system. Draining has completed if all of them return
|
||||||
* zero. Otherwise, the sum of the return values is loaded into
|
* zero. Otherwise, the sum of the return values is loaded into
|
||||||
|
@ -151,9 +199,9 @@ class DrainManager
|
||||||
* manager is passed as an argument to the drain() method.
|
* manager is passed as an argument to the drain() method.
|
||||||
*
|
*
|
||||||
* <li>Continue simulation. When an object has finished draining its
|
* <li>Continue simulation. When an object has finished draining its
|
||||||
* internal state, it calls CountedDrainEvent::signalDrainDone()
|
* internal state, it calls DrainManager::signalDrainDone() on the
|
||||||
* on the manager. When the counter in the manager reaches zero,
|
* manager. When the counter in the manager reaches zero, the
|
||||||
* the simulation stops.
|
* simulation stops.
|
||||||
*
|
*
|
||||||
* <li>Check if any object still needs draining, if so repeat the
|
* <li>Check if any object still needs draining, if so repeat the
|
||||||
* process above.
|
* process above.
|
||||||
|
@ -166,6 +214,8 @@ class DrainManager
|
||||||
*/
|
*/
|
||||||
class Drainable
|
class Drainable
|
||||||
{
|
{
|
||||||
|
friend class DrainManager;
|
||||||
|
|
||||||
public:
|
public:
|
||||||
Drainable();
|
Drainable();
|
||||||
virtual ~Drainable();
|
virtual ~Drainable();
|
||||||
|
@ -210,10 +260,8 @@ class Drainable
|
||||||
void setDrainState(DrainState new_state) { _drainState = new_state; }
|
void setDrainState(DrainState new_state) { _drainState = new_state; }
|
||||||
|
|
||||||
private:
|
private:
|
||||||
|
DrainManager &_drainManager;
|
||||||
DrainState _drainState;
|
DrainState _drainState;
|
||||||
};
|
};
|
||||||
|
|
||||||
DrainManager *createDrainManager();
|
|
||||||
void cleanupDrainManager(DrainManager *drain_manager);
|
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
|
|
@ -122,13 +122,12 @@ def run_test(root, switcher=None, freq=1000, verbose=False):
|
||||||
if verbose:
|
if verbose:
|
||||||
print "Switching CPUs..."
|
print "Switching CPUs..."
|
||||||
print "Next CPU: %s" % type(next_cpu)
|
print "Next CPU: %s" % type(next_cpu)
|
||||||
m5.drain(system)
|
m5.drain()
|
||||||
if current_cpu != next_cpu:
|
if current_cpu != next_cpu:
|
||||||
m5.switchCpus(system, [ (current_cpu, next_cpu) ],
|
m5.switchCpus(system, [ (current_cpu, next_cpu) ],
|
||||||
do_drain=False, verbose=verbose)
|
verbose=verbose)
|
||||||
else:
|
else:
|
||||||
print "Source CPU and destination CPU are the same, skipping..."
|
print "Source CPU and destination CPU are the same, skipping..."
|
||||||
m5.resume(system)
|
|
||||||
current_cpu = next_cpu
|
current_cpu = next_cpu
|
||||||
elif exit_cause == "target called exit()" or \
|
elif exit_cause == "target called exit()" or \
|
||||||
exit_cause == "m5_exit instruction encountered":
|
exit_cause == "m5_exit instruction encountered":
|
||||||
|
|
Loading…
Reference in a new issue