Move the port from base memory object into the physical memory object.

The Memory is now a pure virtual base class for all memory type objects (DRAM, physical).
We should consider renaming MemObject to something more meaningful to represent it is for all memory heirarchy objects, perhaps MemHeirObject?

mem/physical.cc:
mem/physical.hh:
    Move the port from the base class into the actual object.

--HG--
extra : convert_revision : b7754ee7b90fd8f816f9876dce374c1d43c7e34b

diff --git a/mem/physical.cc b/mem/physical.cc
index 4c174329324f1fd1cadfec2c1f15f3294e3a5a0e..e6d99358bf816d663d383e936323de47a0d71a07 100644 (file)
--- a/mem/physical.cc
+++ b/mem/physical.cc
@@ -90,7 +90,7 @@ PhysicalMemory::PhysicalMemory(const string &n, Range<Addr> range,
 #endif
 
 PhysicalMemory::PhysicalMemory(const string &n)
-    : Memory(n), base_addr(0), pmem_addr(NULL)
+    : Memory(n), memoryPort(this), base_addr(0), pmem_addr(NULL)
 {
     // Hardcoded to 128 MB for now.
     pmem_size = 1 << 27;
@@ -171,6 +171,86 @@ PhysicalMemory::deviceBlockSize()
     return 0;
 }
 
+bool
+PhysicalMemory::doTimingAccess (Packet &pkt)
+{
+    doFunctionalAccess(pkt);
+    //Schedule a response event at curTick + lat;
+    return true;
+}
+
+Tick
+PhysicalMemory::doAtomicAccess(Packet &pkt)
+{
+    doFunctionalAccess(pkt);
+    return curTick + lat;
+}
+
+void
+PhysicalMemory::doFunctionalAccess(Packet &pkt)
+{
+    switch (pkt.cmd) {
+      case Read:
+        prot_read(pkt.addr, (uint8_t *)pkt.data, pkt.size);
+
+      case Write:
+        prot_write(pkt.addr, (uint8_t *)pkt.data, pkt.size);
+
+      default:
+        panic("unimplemented");
+    }
+}
+
+Port *
+PhysicalMemory::getPort(const char *if_name)
+{
+    return &memoryPort;
+}
+
+void
+PhysicalMemory::recvStatusChange(Port::Status status)
+{
+    panic("??");
+}
+
+PhysicalMemory::MemoryPort::MemoryPort(PhysicalMemory *_memory)
+    : memory(_memory)
+{ }
+
+void
+PhysicalMemory::MemoryPort::recvStatusChange(Port::Status status)
+{
+    memory->recvStatusChange(status);
+}
+
+void
+PhysicalMemory::MemoryPort::getDeviceAddressRanges(AddrRangeList &range_list,
+                                           bool &owner)
+{
+    panic("??");
+}
+
+
+bool
+PhysicalMemory::MemoryPort::recvTiming(Packet &pkt)
+{
+    return memory->doTimingAccess(pkt);
+}
+
+Tick
+PhysicalMemory::MemoryPort::recvAtomic(Packet &pkt)
+{
+    return memory->doAtomicAccess(pkt);
+}
+
+void
+PhysicalMemory::MemoryPort::recvFunctional(Packet &pkt)
+{
+    memory->doFunctionalAccess(pkt);
+}
+
+
+
 void
 PhysicalMemory::serialize(ostream &os)
 {
@@ -278,6 +358,7 @@ PhysicalMemory::unserialize(Checkpoint *cp, const string &section)
 
 }
 
+
 BEGIN_DECLARE_SIM_OBJECT_PARAMS(PhysicalMemory)
 
     Param<string> file;

diff --git a/mem/physical.hh b/mem/physical.hh
index 156a4da1d75527c7354c872b8bf426c76b09fbae..06e6f1f0e7b5e141e407907cfe801b98e19a5156 100644 (file)
--- a/mem/physical.hh
+++ b/mem/physical.hh
@@ -40,6 +40,39 @@
 //
 class PhysicalMemory : public Memory
 {
+    class MemoryPort : public Port
+    {
+        PhysicalMemory *memory;
+
+      public:
+
+        MemoryPort(PhysicalMemory *_memory);
+
+      protected:
+
+        virtual bool recvTiming(Packet &pkt);
+
+        virtual Tick recvAtomic(Packet &pkt);
+
+        virtual void recvFunctional(Packet &pkt);
+
+        virtual void recvStatusChange(Status status);
+
+        virtual void getDeviceAddressRanges(AddrRangeList &range_list,
+                                            bool &owner);
+
+        virtual int deviceBlockSize();
+
+    };
+
+    MemoryPort memoryPort;
+
+    Port * PhysicalMemory::getPort(const char *if_name);
+
+    int lat;
+
+    //event to send response needs to be here
+
   private:
     // prevent copying of a MainMemory object
     PhysicalMemory(const PhysicalMemory &specmem);
@@ -67,12 +100,18 @@ class PhysicalMemory : public Memory
     virtual int deviceBlockSize();
 
     // Read/Write arbitrary amounts of data to simulated memory space
-    virtual void prot_read(Addr addr, uint8_t *p, int size);
-    virtual void prot_write(Addr addr, const uint8_t *p, int size);
-    virtual void prot_memset(Addr addr, uint8_t val, int size);
+    void prot_read(Addr addr, uint8_t *p, int size);
+    void prot_write(Addr addr, const uint8_t *p, int size);
+    void prot_memset(Addr addr, uint8_t val, int size);
 
     // fast back-door memory access for vtophys(), remote gdb, etc.
     uint64_t phys_read_qword(Addr addr) const;
+  private:
+    bool doTimingAccess(Packet &pkt);
+    Tick doAtomicAccess(Packet &pkt);
+    void doFunctionalAccess(Packet &pkt);
+
+    void recvStatusChange(Port::Status status);
 
   public:
     virtual void serialize(std::ostream &os);