* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * Authors: Steve Reinhardt
- * Lisa Hsu
- * Nathan Binkert
- * Ali Saidi
- * Rick Strong
*/
#include "sim/system.hh"
#include "arch/remote_gdb.hh"
#include "arch/utility.hh"
+#include "base/compiler.hh"
#include "base/loader/object_file.hh"
#include "base/loader/symtab.hh"
#include "base/str.hh"
#include "base/trace.hh"
+#include "config/the_isa.hh"
#include "config/use_kvm.hh"
#if USE_KVM
#include "cpu/kvm/base.hh"
#include "cpu/kvm/vm.hh"
#endif
+#if THE_ISA != NULL_ISA
#include "cpu/base.hh"
+#endif
#include "cpu/thread_context.hh"
#include "debug/Loader.hh"
+#include "debug/Quiesce.hh"
#include "debug/WorkItems.hh"
#include "mem/abstract_mem.hh"
#include "mem/physical.hh"
#include "sim/full_system.hh"
#include "sim/redirect_path.hh"
-/**
- * To avoid linking errors with LTO, only include the header if we
- * actually have a definition.
- */
-#if THE_ISA != NULL_ISA
-#include "kern/kernel_stats.hh"
+std::vector<System *> System::systemList;
-#endif
+void
+System::Threads::Thread::resume()
+{
+# if THE_ISA != NULL_ISA
+ DPRINTFS(Quiesce, context->getCpuPtr(), "activating\n");
+ context->activate();
+# endif
+}
-using namespace std;
-using namespace TheISA;
+std::string
+System::Threads::Thread::name() const
+{
+ assert(context);
+ return csprintf("%s.threads[%d]", context->getSystemPtr()->name(),
+ context->contextId());
+}
-vector<System *> System::systemList;
+void
+System::Threads::Thread::quiesce() const
+{
+ context->suspend();
+ auto *workload = context->getSystemPtr()->workload;
+ if (workload)
+ workload->recordQuiesce();
+}
+
+ContextID
+System::Threads::insert(ThreadContext *tc, ContextID id)
+{
+ if (id == InvalidContextID) {
+ for (id = 0; id < size(); id++) {
+ if (!threads[id].context)
+ break;
+ }
+ }
+
+ if (id >= size())
+ threads.resize(id + 1);
+
+ fatal_if(threads[id].context,
+ "Cannot have two thread contexts with the same id (%d).", id);
+
+ auto *sys = tc->getSystemPtr();
+
+ auto &t = thread(id);
+ t.context = tc;
+ // Look up this thread again on resume, in case the threads vector has
+ // been reallocated.
+ t.resumeEvent = new EventFunctionWrapper(
+ [this, id](){ thread(id).resume(); }, sys->name());
+# if THE_ISA != NULL_ISA
+ int port = getRemoteGDBPort();
+ if (port) {
+ t.gdb = new TheISA::RemoteGDB(sys, tc, port + id);
+ t.gdb->listen();
+ }
+# endif
+
+ return id;
+}
+
+void
+System::Threads::replace(ThreadContext *tc, ContextID id)
+{
+ auto &t = thread(id);
+ panic_if(!t.context, "Can't replace a context which doesn't exist.");
+ if (t.gdb)
+ t.gdb->replaceThreadContext(tc);
+# if THE_ISA != NULL_ISA
+ if (t.resumeEvent->scheduled()) {
+ Tick when = t.resumeEvent->when();
+ t.context->getCpuPtr()->deschedule(t.resumeEvent);
+ tc->getCpuPtr()->schedule(t.resumeEvent, when);
+ }
+# endif
+ t.context = tc;
+}
+
+ThreadContext *
+System::Threads::findFree()
+{
+ for (auto &thread: threads) {
+ if (thread.context->status() == ThreadContext::Halted)
+ return thread.context;
+ }
+ return nullptr;
+}
+
+int
+System::Threads::numRunning() const
+{
+ int count = 0;
+ for (auto &thread: threads) {
+ auto status = thread.context->status();
+ if (status != ThreadContext::Halted &&
+ status != ThreadContext::Halting) {
+ count++;
+ }
+ }
+ return count;
+}
+
+void
+System::Threads::quiesce(ContextID id)
+{
+ auto &t = thread(id);
+# if THE_ISA != NULL_ISA
+ M5_VAR_USED BaseCPU *cpu = t.context->getCpuPtr();
+ DPRINTFS(Quiesce, cpu, "quiesce()\n");
+# endif
+ t.quiesce();
+}
+
+void
+System::Threads::quiesceTick(ContextID id, Tick when)
+{
+# if THE_ISA != NULL_ISA
+ auto &t = thread(id);
+ BaseCPU *cpu = t.context->getCpuPtr();
+
+ DPRINTFS(Quiesce, cpu, "quiesceTick until %u\n", when);
+ t.quiesce();
+
+ cpu->reschedule(t.resumeEvent, when, true);
+# endif
+}
int System::numSystemsRunning = 0;
-System::System(Params *p)
+System::System(const Params &p)
: SimObject(p), _systemPort("system_port", this),
- multiThread(p->multi_thread),
+ multiThread(p.multi_thread),
pagePtr(0),
- init_param(p->init_param),
- physProxy(_systemPort, p->cache_line_size),
- kernelSymtab(nullptr),
- kernel(nullptr),
- loadAddrMask(p->load_addr_mask),
- loadAddrOffset(p->load_offset),
+ init_param(p.init_param),
+ physProxy(_systemPort, p.cache_line_size),
+ workload(p.workload),
#if USE_KVM
- kvmVM(p->kvm_vm),
+ kvmVM(p.kvm_vm),
#else
kvmVM(nullptr),
#endif
- physmem(name() + ".physmem", p->memories, p->mmap_using_noreserve),
- memoryMode(p->mem_mode),
- _cacheLineSize(p->cache_line_size),
+ physmem(name() + ".physmem", p.memories, p.mmap_using_noreserve,
+ p.shared_backstore),
+ memoryMode(p.mem_mode),
+ _cacheLineSize(p.cache_line_size),
workItemsBegin(0),
workItemsEnd(0),
- numWorkIds(p->num_work_ids),
- thermalModel(p->thermal_model),
+ numWorkIds(p.num_work_ids),
+ thermalModel(p.thermal_model),
_params(p),
- totalNumInsts(0),
- redirectPaths(p->redirect_paths)
+ _m5opRange(p.m5ops_base ?
+ RangeSize(p.m5ops_base, 0x10000) :
+ AddrRange(1, 0)), // Create an empty range if disabled
+ redirectPaths(p.redirect_paths)
{
+ if (workload)
+ workload->system = this;
// add self to global system list
systemList.push_back(this);
}
#endif
- if (FullSystem) {
- kernelSymtab = new SymbolTable;
- if (!debugSymbolTable)
- debugSymbolTable = new SymbolTable;
- }
-
// check if the cache line size is a value known to work
if (!(_cacheLineSize == 16 || _cacheLineSize == 32 ||
_cacheLineSize == 64 || _cacheLineSize == 128))
warn_once("Cache line size is neither 16, 32, 64 nor 128 bytes.\n");
- // Get the generic system master IDs
- MasterID tmp_id M5_VAR_USED;
- tmp_id = getMasterId(this, "writebacks");
- assert(tmp_id == Request::wbMasterId);
- tmp_id = getMasterId(this, "functional");
- assert(tmp_id == Request::funcMasterId);
- tmp_id = getMasterId(this, "interrupt");
- assert(tmp_id == Request::intMasterId);
-
- if (FullSystem) {
- if (params()->kernel == "") {
- inform("No kernel set for full system simulation. "
- "Assuming you know what you're doing\n");
- } else {
- // Get the kernel code
- kernel = createObjectFile(params()->kernel);
- inform("kernel located at: %s", params()->kernel);
-
- if (kernel == NULL)
- fatal("Could not load kernel file %s", params()->kernel);
-
- kernelImage = kernel->buildImage();
-
- // setup entry points
- kernelStart = kernelImage.minAddr();
- kernelEnd = kernelImage.maxAddr();
- kernelEntry = kernel->entryPoint();
-
- // If load_addr_mask is set to 0x0, then auto-calculate
- // the smallest mask to cover all kernel addresses so gem5
- // can relocate the kernel to a new offset.
- if (loadAddrMask == 0) {
- Addr shift_amt = findMsbSet(kernelEnd - kernelStart) + 1;
- loadAddrMask = ((Addr)1 << shift_amt) - 1;
- }
-
- kernelImage.move([this](Addr a) {
- return (a & loadAddrMask) + loadAddrOffset;
- });
-
- // load symbols
- if (!kernel->loadGlobalSymbols(kernelSymtab))
- fatal("could not load kernel symbols\n");
-
- if (!kernel->loadLocalSymbols(kernelSymtab))
- fatal("could not load kernel local symbols\n");
-
- if (!kernel->loadGlobalSymbols(debugSymbolTable))
- fatal("could not load kernel symbols\n");
-
- if (!kernel->loadLocalSymbols(debugSymbolTable))
- fatal("could not load kernel local symbols\n");
-
- // Loading only needs to happen once and after memory system is
- // connected so it will happen in initState()
- }
-
- for (const auto &obj_name : p->kernel_extras) {
- inform("Loading additional kernel object: %s", obj_name);
- ObjectFile *obj = createObjectFile(obj_name);
- fatal_if(!obj, "Failed to additional kernel object '%s'.\n",
- obj_name);
- kernelExtras.push_back(obj);
- }
- }
+ // Get the generic system requestor IDs
+ M5_VAR_USED RequestorID tmp_id;
+ tmp_id = getRequestorId(this, "writebacks");
+ assert(tmp_id == Request::wbRequestorId);
+ tmp_id = getRequestorId(this, "functional");
+ assert(tmp_id == Request::funcRequestorId);
+ tmp_id = getRequestorId(this, "interrupt");
+ assert(tmp_id == Request::intRequestorId);
// increment the number of running systems
numSystemsRunning++;
// Set back pointers to the system in all memories
- for (int x = 0; x < params()->memories.size(); x++)
- params()->memories[x]->system(this);
+ for (int x = 0; x < params().memories.size(); x++)
+ params().memories[x]->system(this);
}
System::~System()
{
- delete kernelSymtab;
- delete kernel;
-
for (uint32_t j = 0; j < numWorkIds; j++)
delete workItemStats[j];
}
void
-System::init()
+System::startup()
{
- // check that the system port is connected
- if (!_systemPort.isConnected())
- panic("System port on %s is not connected.\n", name());
+ SimObject::startup();
+
+ // Now that we're about to start simulation, wait for GDB connections if
+ // requested.
+#if THE_ISA != NULL_ISA
+ for (int i = 0; i < threads.size(); i++) {
+ auto *gdb = threads.thread(i).gdb;
+ auto *cpu = threads[i]->getCpuPtr();
+ if (gdb && cpu->waitForRemoteGDB()) {
+ inform("%s: Waiting for a remote GDB connection on port %d.",
+ cpu->name(), gdb->port());
+ gdb->connect();
+ }
+ }
+#endif
}
Port &
bool System::breakpoint()
{
- if (remoteGDB.size())
- return remoteGDB[0]->breakpoint();
- return false;
+ if (!threads.size())
+ return false;
+ auto *gdb = threads.thread(0).gdb;
+ if (!gdb)
+ return false;
+ return gdb->breakpoint();
}
ContextID
System::registerThreadContext(ThreadContext *tc, ContextID assigned)
{
- int id = assigned;
- if (id == InvalidContextID) {
- // Find an unused context ID for this thread.
- id = 0;
- while (id < threadContexts.size() && threadContexts[id])
- id++;
- }
-
- if (threadContexts.size() <= id)
- threadContexts.resize(id + 1);
+ ContextID id = threads.insert(tc, assigned);
- fatal_if(threadContexts[id],
- "Cannot have two CPUs with the same id (%d)\n", id);
-
- threadContexts[id] = tc;
for (auto *e: liveEvents)
tc->schedule(e);
-#if THE_ISA != NULL_ISA
- int port = getRemoteGDBPort();
- if (port) {
- RemoteGDB *rgdb = new RemoteGDB(this, tc, port + id);
- rgdb->listen();
-
- BaseCPU *cpu = tc->getCpuPtr();
- if (cpu->waitForRemoteGDB()) {
- inform("%s: Waiting for a remote GDB connection on port %d.\n",
- cpu->name(), rgdb->port());
-
- rgdb->connect();
- }
- if (remoteGDB.size() <= id) {
- remoteGDB.resize(id + 1);
- }
-
- remoteGDB[id] = rgdb;
- }
-#endif
-
- activeCpus.push_back(false);
-
return id;
}
{
bool all = true;
liveEvents.push_back(event);
- for (auto *tc: threadContexts)
+ for (auto *tc: threads)
all = tc->schedule(event) && all;
return all;
}
{
bool all = true;
liveEvents.remove(event);
- for (auto *tc: threadContexts)
+ for (auto *tc: threads)
all = tc->remove(event) && all;
return all;
}
-int
-System::numRunningContexts()
-{
- return std::count_if(
- threadContexts.cbegin(),
- threadContexts.cend(),
- [] (ThreadContext* tc) {
- return ((tc->status() != ThreadContext::Halted) &&
- (tc->status() != ThreadContext::Halting));
- }
- );
-}
-
-void
-System::initState()
-{
- if (FullSystem) {
- for (int i = 0; i < threadContexts.size(); i++)
- TheISA::startupCPU(threadContexts[i], i);
- // Moved from the constructor to here since it relies on the
- // address map being resolved in the interconnect
- /**
- * Load the kernel code into memory
- */
- auto mapper = [this](Addr a) {
- return (a & loadAddrMask) + loadAddrOffset;
- };
- if (params()->kernel != "") {
- if (params()->kernel_addr_check) {
- // Validate kernel mapping before loading binary
- if (!isMemAddr(mapper(kernelStart)) ||
- !isMemAddr(mapper(kernelEnd))) {
- fatal("Kernel is mapped to invalid location (not memory). "
- "kernelStart 0x(%x) - kernelEnd 0x(%x) %#x:%#x\n",
- kernelStart, kernelEnd,
- mapper(kernelStart), mapper(kernelEnd));
- }
- }
- // Load program sections into memory
- kernelImage.write(physProxy);
-
- DPRINTF(Loader, "Kernel start = %#x\n", kernelStart);
- DPRINTF(Loader, "Kernel end = %#x\n", kernelEnd);
- DPRINTF(Loader, "Kernel entry = %#x\n", kernelEntry);
- DPRINTF(Loader, "Kernel loaded...\n");
- }
- for (const auto &extra_kernel : kernelExtras)
- extra_kernel->buildImage().move(mapper).write(physProxy);
- }
-}
-
void
System::replaceThreadContext(ThreadContext *tc, ContextID context_id)
{
- if (context_id >= threadContexts.size()) {
- panic("replaceThreadContext: bad id, %d >= %d\n",
- context_id, threadContexts.size());
- }
+ auto *otc = threads[context_id];
+ threads.replace(tc, context_id);
for (auto *e: liveEvents) {
- threadContexts[context_id]->remove(e);
+ otc->remove(e);
tc->schedule(e);
}
- threadContexts[context_id] = tc;
- if (context_id < remoteGDB.size())
- remoteGDB[context_id]->replaceThreadContext(tc);
}
bool
System::validKvmEnvironment() const
{
#if USE_KVM
- if (threadContexts.empty())
+ if (threads.empty())
return false;
- for (auto tc : threadContexts) {
- if (dynamic_cast<BaseKvmCPU*>(tc->getCpuPtr()) == nullptr) {
+ for (auto *tc: threads) {
+ if (!dynamic_cast<BaseKvmCPU *>(tc->getCpuPtr()))
return false;
- }
}
+
return true;
#else
return false;
Addr
System::allocPhysPages(int npages)
{
- Addr return_addr = pagePtr << PageShift;
+ Addr return_addr = pagePtr << TheISA::PageShift;
pagePtr += npages;
- Addr next_return_addr = pagePtr << PageShift;
+ Addr next_return_addr = pagePtr << TheISA::PageShift;
- AddrRange m5opRange(0xffff0000, 0x100000000);
- if (m5opRange.contains(next_return_addr)) {
+ if (_m5opRange.contains(next_return_addr)) {
warn("Reached m5ops MMIO region\n");
return_addr = 0xffffffff;
- pagePtr = 0xffffffff >> PageShift;
+ pagePtr = 0xffffffff >> TheISA::PageShift;
}
- if ((pagePtr << PageShift) > physmem.totalSize())
+ if ((pagePtr << TheISA::PageShift) > physmem.totalSize())
fatal("Out of memory, please increase size of physical memory.");
return return_addr;
}
Addr
System::freeMemSize() const
{
- return physmem.totalSize() - (pagePtr << PageShift);
+ return physmem.totalSize() - (pagePtr << TheISA::PageShift);
}
bool
}
void
-System::drainResume()
+System::addDeviceMemory(RequestorID requestor_id, AbstractMemory *deviceMemory)
+{
+ if (!deviceMemMap.count(requestor_id)) {
+ deviceMemMap.insert(std::make_pair(requestor_id, deviceMemory));
+ }
+}
+
+bool
+System::isDeviceMemAddr(PacketPtr pkt) const
{
- totalNumInsts = 0;
+ const RequestorID& id = pkt->requestorId();
+
+ return (deviceMemMap.count(id) &&
+ deviceMemMap.at(id)->getAddrRange().contains(pkt->getAddr()));
+}
+
+AbstractMemory *
+System::getDeviceMemory(RequestorID id) const
+{
+ panic_if(!deviceMemMap.count(id),
+ "No device memory found for RequestorID %d\n", id);
+ return deviceMemMap.at(id);
}
void
System::serialize(CheckpointOut &cp) const
{
- if (FullSystem)
- kernelSymtab->serialize("kernel_symtab", cp);
SERIALIZE_SCALAR(pagePtr);
- serializeSymtab(cp);
+
+ for (auto &t: threads.threads) {
+ Tick when = 0;
+ if (t.resumeEvent && t.resumeEvent->scheduled())
+ when = t.resumeEvent->when();
+ ContextID id = t.context->contextId();
+ paramOut(cp, csprintf("quiesceEndTick_%d", id), when);
+ }
// also serialize the memories in the system
physmem.serializeSection(cp, "physmem");
void
System::unserialize(CheckpointIn &cp)
{
- if (FullSystem)
- kernelSymtab->unserialize("kernel_symtab", cp);
UNSERIALIZE_SCALAR(pagePtr);
- unserializeSymtab(cp);
+
+ for (auto &t: threads.threads) {
+ Tick when = 0;
+ ContextID id = t.context->contextId();
+ if (!optParamIn(cp, csprintf("quiesceEndTick_%d", id), when) ||
+ !when || !t.resumeEvent) {
+ continue;
+ }
+# if THE_ISA != NULL_ISA
+ t.context->getCpuPtr()->schedule(t.resumeEvent, when);
+# endif
+ }
// also unserialize the memories in the system
physmem.unserializeSection(cp, "physmem");
SimObject::regStats();
for (uint32_t j = 0; j < numWorkIds ; j++) {
- workItemStats[j] = new Stats::Histogram();
- stringstream namestr;
+ workItemStats[j] = new Stats::Histogram(this);
+ std::stringstream namestr;
ccprintf(namestr, "work_item_type%d", j);
workItemStats[j]->init(20)
.name(name() + "." + namestr.str())
void
System::printSystems()
{
- ios::fmtflags flags(cerr.flags());
+ std::ios::fmtflags flags(std::cerr.flags());
- vector<System *>::iterator i = systemList.begin();
- vector<System *>::iterator end = systemList.end();
+ std::vector<System *>::iterator i = systemList.begin();
+ std::vector<System *>::iterator end = systemList.end();
for (; i != end; ++i) {
System *sys = *i;
- cerr << "System " << sys->name() << ": " << hex << sys << endl;
+ std::cerr << "System " << sys->name() << ": " << std::hex << sys
+ << std::endl;
}
- cerr.flags(flags);
+ std::cerr.flags(flags);
}
void
}
std::string
-System::stripSystemName(const std::string& master_name) const
+System::stripSystemName(const std::string& requestor_name) const
{
- if (startswith(master_name, name())) {
- return master_name.substr(name().size());
+ if (startswith(requestor_name, name())) {
+ return requestor_name.substr(name().size());
} else {
- return master_name;
+ return requestor_name;
}
}
-MasterID
-System::lookupMasterId(const SimObject* obj) const
+RequestorID
+System::lookupRequestorId(const SimObject* obj) const
{
- MasterID id = Request::invldMasterId;
+ RequestorID id = Request::invldRequestorId;
// number of occurrences of the SimObject pointer
- // in the master list.
+ // in the requestor list.
auto obj_number = 0;
- for (int i = 0; i < masters.size(); i++) {
- if (masters[i].obj == obj) {
+ for (int i = 0; i < requestors.size(); i++) {
+ if (requestors[i].obj == obj) {
id = i;
obj_number++;
}
}
fatal_if(obj_number > 1,
- "Cannot lookup MasterID by SimObject pointer: "
- "More than one master is sharing the same SimObject\n");
+ "Cannot lookup RequestorID by SimObject pointer: "
+ "More than one requestor is sharing the same SimObject\n");
return id;
}
-MasterID
-System::lookupMasterId(const std::string& master_name) const
+RequestorID
+System::lookupRequestorId(const std::string& requestor_name) const
{
- std::string name = stripSystemName(master_name);
+ std::string name = stripSystemName(requestor_name);
- for (int i = 0; i < masters.size(); i++) {
- if (masters[i].masterName == name) {
+ for (int i = 0; i < requestors.size(); i++) {
+ if (requestors[i].req_name == name) {
return i;
}
}
- return Request::invldMasterId;
+ return Request::invldRequestorId;
}
-MasterID
-System::getGlobalMasterId(const std::string& master_name)
+RequestorID
+System::getGlobalRequestorId(const std::string& requestor_name)
{
- return _getMasterId(nullptr, master_name);
+ return _getRequestorId(nullptr, requestor_name);
}
-MasterID
-System::getMasterId(const SimObject* master, std::string submaster)
+RequestorID
+System::getRequestorId(const SimObject* requestor, std::string subrequestor)
{
- auto master_name = leafMasterName(master, submaster);
- return _getMasterId(master, master_name);
+ auto requestor_name = leafRequestorName(requestor, subrequestor);
+ return _getRequestorId(requestor, requestor_name);
}
-MasterID
-System::_getMasterId(const SimObject* master, const std::string& master_name)
+RequestorID
+System::_getRequestorId(const SimObject* requestor,
+ const std::string& requestor_name)
{
- std::string name = stripSystemName(master_name);
+ std::string name = stripSystemName(requestor_name);
// CPUs in switch_cpus ask for ids again after switching
- for (int i = 0; i < masters.size(); i++) {
- if (masters[i].masterName == name) {
+ for (int i = 0; i < requestors.size(); i++) {
+ if (requestors[i].req_name == name) {
return i;
}
}
// they will be too small
if (Stats::enabled()) {
- fatal("Can't request a masterId after regStats(). "
+ fatal("Can't request a requestorId after regStats(). "
"You must do so in init().\n");
}
- // Generate a new MasterID incrementally
- MasterID master_id = masters.size();
+ // Generate a new RequestorID incrementally
+ RequestorID requestor_id = requestors.size();
- // Append the new Master metadata to the group of system Masters.
- masters.emplace_back(master, name, master_id);
+ // Append the new Requestor metadata to the group of system Requestors.
+ requestors.emplace_back(requestor, name, requestor_id);
- return masters.back().masterId;
+ return requestors.back().id;
}
std::string
-System::leafMasterName(const SimObject* master, const std::string& submaster)
+System::leafRequestorName(const SimObject* requestor,
+ const std::string& subrequestor)
{
- if (submaster.empty()) {
- return master->name();
+ if (subrequestor.empty()) {
+ return requestor->name();
} else {
- // Get the full master name by appending the submaster name to
- // the root SimObject master name
- return master->name() + "." + submaster;
+ // Get the full requestor name by appending the subrequestor name to
+ // the root SimObject requestor name
+ return requestor->name() + "." + subrequestor;
}
}
std::string
-System::getMasterName(MasterID master_id)
+System::getRequestorName(RequestorID requestor_id)
{
- if (master_id >= masters.size())
- fatal("Invalid master_id passed to getMasterName()\n");
+ if (requestor_id >= requestors.size())
+ fatal("Invalid requestor_id passed to getRequestorName()\n");
- const auto& master_info = masters[master_id];
- return master_info.masterName;
-}
-
-System *
-SystemParams::create()
-{
- return new System(this);
+ const auto& requestor_info = requestors[requestor_id];
+ return requestor_info.req_name;
}
projects / gem5.git / blobdiff