/*
- * Copyright (c) 2012 ARM Limited
+ * Copyright (c) 2012, 2014 ARM Limited
* All rights reserved
*
* The license below extends only to copyright in the software and shall
#define __SYSTEM_HH__
#include <string>
+#include <unordered_map>
#include <utility>
#include <vector>
+#include "arch/isa_traits.hh"
#include "base/loader/symtab.hh"
-#include "base/misc.hh"
#include "base/statistics.hh"
-#include "cpu/pc_event.hh"
+#include "config/the_isa.hh"
#include "enums/MemoryMode.hh"
-#include "kern/system_events.hh"
#include "mem/mem_object.hh"
+#include "mem/physical.hh"
#include "mem/port.hh"
#include "mem/port_proxy.hh"
-#include "mem/physical.hh"
#include "params/System.hh"
+#include "sim/futex_map.hh"
+#include "sim/se_signal.hh"
+
+/**
+ * To avoid linking errors with LTO, only include the header if we
+ * actually have the definition.
+ */
+#if THE_ISA != NULL_ISA
+#include "cpu/pc_event.hh"
+
+#endif
-class BaseCPU;
class BaseRemoteGDB;
class GDBListener;
+class KvmVM;
class ObjectFile;
-class Platform;
class ThreadContext;
class System : public MemObject
SystemPort(const std::string &_name, MemObject *_owner)
: MasterPort(_name, _owner)
{ }
- bool recvTimingResp(PacketPtr pkt)
+ bool recvTimingResp(PacketPtr pkt) override
{ panic("SystemPort does not receive timing!\n"); return false; }
- void recvRetry()
+ void recvReqRetry() override
{ panic("SystemPort does not expect retry!\n"); }
};
* After all objects have been created and all ports are
* connected, check that the system port is connected.
*/
- virtual void init();
+ void init() override;
/**
* Get a reference to the system port that can be used by
* Additional function to return the Port of a memory object.
*/
BaseMasterPort& getMasterPort(const std::string &if_name,
- PortID idx = InvalidPortID);
-
- static const char *MemoryModeStrings[4];
+ PortID idx = InvalidPortID) override;
/** @{ */
/**
std::vector<ThreadContext *> threadContexts;
int _numContexts;
+ const bool multiThread;
- ThreadContext *getThreadContext(ThreadID tid)
+ ThreadContext *getThreadContext(ContextID tid)
{
return threadContexts[tid];
}
/** Object pointer for the kernel code */
ObjectFile *kernel;
- /** Begining of kernel code */
+ /** Additional object files */
+ std::vector<ObjectFile *> kernelExtras;
+
+ /** Beginning of kernel code */
Addr kernelStart;
/** End of kernel code */
*/
Addr loadAddrMask;
- protected:
- uint64_t nextPID;
+ /** Offset that should be used for binary/symbol loading.
+ * This further allows more flexibility than the loadAddrMask allows alone
+ * in loading kernels and similar. The loadAddrOffset is applied after the
+ * loadAddrMask.
+ */
+ Addr loadAddrOffset;
public:
- uint64_t allocatePID()
- {
- return nextPID++;
+ /**
+ * Get a pointer to the Kernel Virtual Machine (KVM) SimObject,
+ * if present.
+ */
+ KvmVM* getKvmVM() {
+ return kvmVM;
}
+ /** Verify gem5 configuration will support KVM emulation */
+ bool validKvmEnvironment() const;
+
/** Get a pointer to access the physical memory of the system */
PhysicalMemory& getPhysMem() { return physmem; }
*/
bool isMemAddr(Addr addr) const;
+ /**
+ * Get the architecture.
+ */
+ Arch getArch() const { return Arch::TheISA; }
+
+ /**
+ * Get the page bytes for the ISA.
+ */
+ Addr getPageBytes() const { return TheISA::PageBytes; }
+
+ /**
+ * Get the number of bits worth of in-page address for the ISA.
+ */
+ Addr getPageShift() const { return TheISA::PageShift; }
+
+ /**
+ * The thermal model used for this system (if any).
+ */
+ ThermalModel * getThermalModel() const { return thermalModel; }
+
protected:
+ KvmVM *const kvmVM;
+
PhysicalMemory physmem;
Enums::MemoryMode memoryMode;
uint32_t numWorkIds;
std::vector<bool> activeCpus;
- /** This array is a per-sytem list of all devices capable of issuing a
+ /** This array is a per-system list of all devices capable of issuing a
* memory system request and an associated string for each master id.
* It's used to uniquely id any master in the system by name for things
* like cache statistics.
*/
std::vector<std::string> masterIds;
+ ThermalModel * thermalModel;
+
public:
/** Request an id used to create a request object in the system. All objects
* that intend to issues requests into the memory system must request an id
* in the init() phase of startup. All master ids must be fixed by the
- * regStats() phase that immediately preceeds it. This allows objects in the
- * memory system to understand how many masters may exist and
+ * regStats() phase that immediately precedes it. This allows objects in
+ * the memory system to understand how many masters may exist and
* appropriately name the bins of their per-master stats before the stats
* are finalized
*/
return masterIds.size();
}
- virtual void regStats();
+ void regStats() override;
/**
* Called by pseudo_inst to track the number of work items started by this
* system.
* Called by pseudo_inst to track the number of work items completed by
* this system.
*/
- uint64_t
+ uint64_t
incWorkItemsEnd()
{
return ++workItemsEnd;
* Returns the total number of cpus that have executed work item begin or
* ends.
*/
- int
+ int
markWorkItem(int index)
{
int count = 0;
assert(index < activeCpus.size());
activeCpus[index] = true;
- for (std::vector<bool>::iterator i = activeCpus.begin();
+ for (std::vector<bool>::iterator i = activeCpus.begin();
i < activeCpus.end(); i++) {
if (*i) count++;
}
System(Params *p);
~System();
- void initState();
+ void initState() override;
const Params *params() const { return (const Params *)_params; }
public:
/**
- * Returns the addess the kernel starts at.
+ * Returns the address the kernel starts at.
* @return address the kernel starts at
*/
Addr getKernelStart() const { return kernelStart; }
/**
- * Returns the addess the kernel ends at.
+ * Returns the address the kernel ends at.
* @return address the kernel ends at
*/
Addr getKernelEnd() const { return kernelEnd; }
/**
- * Returns the addess the entry point to the kernel code.
+ * Returns the address the entry point to the kernel code.
* @return entry point of the kernel code
*/
Addr getKernelEntry() const { return kernelEntry; }
/// @return Starting address of first page
Addr allocPhysPages(int npages);
- int registerThreadContext(ThreadContext *tc, int assigned=-1);
- void replaceThreadContext(ThreadContext *tc, int context_id);
+ ContextID registerThreadContext(ThreadContext *tc,
+ ContextID assigned = InvalidContextID);
+ void replaceThreadContext(ThreadContext *tc, ContextID context_id);
- void serialize(std::ostream &os);
- void unserialize(Checkpoint *cp, const std::string §ion);
+ void serialize(CheckpointOut &cp) const override;
+ void unserialize(CheckpointIn &cp) override;
- unsigned int drain(DrainManager *dm);
- void drainResume();
+ void drainResume() override;
public:
Counter totalNumInsts;
static void printSystems();
- // For futex system call
- std::map<uint64_t, std::list<ThreadContext *> * > futexMap;
+ FutexMap futexMap;
+
+ static const int maxPID = 32768;
+
+ /** Process set to track which PIDs have already been allocated */
+ std::set<int> PIDs;
+
+ // By convention, all signals are owned by the receiving process. The
+ // receiver will delete the signal upon reception.
+ std::list<BasicSignal> signalList;
protected:
/**
* If needed, serialize additional symbol table entries for a
- * specific subclass of this sytem. Currently this is used by
+ * specific subclass of this system. Currently this is used by
* Alpha and MIPS.
*
* @param os stream to serialize to
*/
- virtual void serializeSymtab(std::ostream &os) {}
+ virtual void serializeSymtab(CheckpointOut &os) const {}
/**
* If needed, unserialize additional symbol table entries for a
* @param cp checkpoint to unserialize from
* @param section relevant section in the checkpoint
*/
- virtual void unserializeSymtab(Checkpoint *cp,
- const std::string §ion) {}
+ virtual void unserializeSymtab(CheckpointIn &cp) {}
};
projects / gem5.git / blobdiff