diff options
Diffstat (limited to 'src/mem/physical.hh')
-rw-r--r-- | src/mem/physical.hh | 112 |
1 files changed, 105 insertions, 7 deletions
diff --git a/src/mem/physical.hh b/src/mem/physical.hh index fb9969a34..10edeb18f 100644 --- a/src/mem/physical.hh +++ b/src/mem/physical.hh @@ -41,19 +41,37 @@ #define __PHYSICAL_MEMORY_HH__ #include "base/addr_range_map.hh" -#include "mem/abstract_mem.hh" -#include "mem/packet.hh" +#include "mem/port.hh" + +/** + * Forward declaration to avoid header dependencies. + */ +class AbstractMemory; /** * The physical memory encapsulates all memories in the system and * provides basic functionality for accessing those memories without * going through the memory system and interconnect. + * + * The physical memory is also responsible for providing the host + * system backingstore used by the memories in the simulated guest + * system. When the system is created, the physical memory allocates + * the backing store based on the address ranges that are populated in + * the system, and does so indepentent of how those map to actual + * memory controllers. Thus, the physical memory completely abstracts + * the mapping of the backing store of the host system and the address + * mapping in the guest system. This enables us to arbitrarily change + * the number of memory controllers, and their address mapping, as + * long as the ranges stay the same. */ -class PhysicalMemory +class PhysicalMemory : public Serializable { private: + // Name for debugging + std::string _name; + // Global address map AddrRangeMap<AbstractMemory*> addrMap; @@ -66,23 +84,45 @@ class PhysicalMemory // The total memory size uint64_t size; + // The physical memory used to provide the memory in the simulated + // system + std::vector<std::pair<AddrRange, uint8_t*> > backingStore; + // Prevent copying PhysicalMemory(const PhysicalMemory&); // Prevent assignment PhysicalMemory& operator=(const PhysicalMemory&); + /** + * Create the memory region providing the backing store for a + * given address range that corresponds to a set of memories in + * the simulated system. + * + * @param range The address range covered + * @param memories The memories this range maps to + */ + void createBackingStore(AddrRange range, + const std::vector<AbstractMemory*>& _memories); + public: /** * Create a physical memory object, wrapping a number of memories. */ - PhysicalMemory(const std::vector<AbstractMemory*>& _memories); + PhysicalMemory(const std::string& _name, + const std::vector<AbstractMemory*>& _memories); + + /** + * Unmap all the backing store we have used. + */ + ~PhysicalMemory(); /** - * Nothing to destruct. + * Return the name for debugging and for creation of sections for + * checkpointing. */ - ~PhysicalMemory() { } + const std::string name() const { return _name; } /** * Check if a physical address is within a range of a memory that @@ -108,14 +148,72 @@ class PhysicalMemory */ uint64_t totalSize() const { return size; } + /** + * Get the pointers to the backing store for external host + * access. Note that memory in the guest should be accessed using + * access() or functionalAccess(). This interface is primarily + * intended for CPU models using hardware virtualization. Note + * that memories that are null are not present, and that the + * backing store may also contain memories that are not part of + * the OS-visible global address map and thus are allowed to + * overlap. + * + * @return Pointers to the memory backing store + */ + std::vector<std::pair<AddrRange, uint8_t*> > getBackingStore() const + { return backingStore; } + /** + * Perform an untimed memory access and update all the state + * (e.g. locked addresses) and statistics accordingly. The packet + * is turned into a response if required. * + * @param pkt Packet performing the access */ void access(PacketPtr pkt); + + /** + * Perform an untimed memory read or write without changing + * anything but the memory itself. No stats are affected by this + * access. In addition to normal accesses this also facilitates + * print requests. + * + * @param pkt Packet performing the access + */ void functionalAccess(PacketPtr pkt); -}; + /** + * Serialize all the memories in the system. This is independent + * of the logical memory layout, and the serialization only sees + * the contigous backing store, independent of how this maps to + * logical memories in the guest system. + * + * @param os stream to serialize to + */ + void serialize(std::ostream& os); + /** + * Serialize a specific store. + * + * @param store_id Unique identifier of this backing store + * @param range The address range of this backing store + * @param pmem The host pointer to this backing store + */ + void serializeStore(std::ostream& os, unsigned int store_id, + AddrRange range, uint8_t* pmem); + + /** + * Unserialize the memories in the system. As with the + * serialization, this action is independent of how the address + * ranges are mapped to logical memories in the guest system. + */ + void unserialize(Checkpoint* cp, const std::string& section); + /** + * Unserialize a specific backing store, identified by a section. + */ + void unserializeStore(Checkpoint* cp, const std::string& section); + +}; #endif //__PHYSICAL_MEMORY_HH__ |