begin adding checkpointing to Miranda

Author: plavin

src/sst/elements/miranda/mirandaCPU.cc

@@ -544,3 +544,50 @@ bool RequestGenCPU::clockTick(SST::Cycle_t cycle) {
 
     return false;
 }
+
+//void RequestGenCPU::serialize_order(SST::Core::Serialization::serializer& ser) {
+	//SST::Component::serialize_order(ser);
+	//SST_SER(out);
+//}
+	//SST_SER(clockHandler);
+	//SST_SER(reqGen);
+	//SST_SER(requestsInFlight);
+	//SST_SER(cache_link);
+	//SST_SER(srcLink);
+	//SST_SER(srcReqEvent);
+	
+
+/*
+    Output* out;
+
+    TimeConverter timeConverter;
+    Clock::HandlerBase* clockHandler;
+    RequestGenerator* reqGen;
+    std::map<StandardMem::Request::id_t, CPURequest*> requestsInFlight;
+    StandardMem* cache_link;
+    Link* srcLink;
+    MirandaReqEvent* srcReqEvent;
+    StdMemHandler* stdMemHandlers;
+
+    MirandaRequestQueue<GeneratorRequest*> pendingRequests;
+    MirandaMemoryManager* memMgr;
+
+    uint32_t maxRequestsPending[OPCOUNT];
+    uint32_t requestsPending[OPCOUNT];
+    uint32_t reqMaxPerCycle;
+    uint64_t cacheLine;
+    uint32_t maxOpLookup;
+
+    Statistic<uint64_t>* statReqs[OPCOUNT];
+    Statistic<uint64_t>* statSplitReqs[OPCOUNT];
+    Statistic<uint64_t>* statCyclesWithIssue;
+    Statistic<uint64_t>* statMaxIssuePerCycle;
+    Statistic<uint64_t>* statCyclesWithoutIssue;
+    Statistic<uint64_t>* statBytes[OPCOUNT];
+    Statistic<uint64_t>* statReqLatency;
+    Statistic<uint64_t>* statTime;
+    Statistic<uint64_t>* statCyclesHitFence;
+    Statistic<uint64_t>* statCyclesHitReorderLimit;
+    Statistic<uint64_t>* statCycles;
+
+*/

src/sst/elements/miranda/mirandaCPU.h

@@ -42,6 +42,11 @@ class CPURequest {
     uint64_t getIssueTime() const { return issueTime; }
     uint64_t getOriginalReqID() const { return originalID; }
     uint32_t countParts() const { return outstandingParts; }
+    void serialize_order(SST::Core::Serialization::serializer& ser) {
+        SST_SER(originalID);
+        SST_SER(issueTime);
+        SST_SER(outstandingParts);
+    }
 protected:
     uint64_t originalID;
     uint64_t issueTime;
@@ -65,9 +70,14 @@ class RequestGenCPU : public SST::Component {
         virtual void handle(SST::Interfaces::StandardMem::WriteResp* rsp) override;
         virtual void handle(SST::Interfaces::StandardMem::CustomResp* rsp) override;
 
+        void serialize_order(SST::Core::Serialization::serializer& ser) override;
+
         RequestGenCPU* cpu;
     };
 
+    //void serialize_order(SST::Core::Serialization::serializer& ser) override;
+    //ImplementSerializable(SST::Miranda::RequestGenCPU);
+
 	SST_ELI_REGISTER_COMPONENT(
         RequestGenCPU,
         "miranda",

src/sst/elements/miranda/mirandaGenerator.h

@@ -28,12 +28,16 @@
 namespace SST {
 namespace Miranda {
 
+// OPCOUNT is used to by stats to know how many distinct types
+// of operations to track. INVALID is placed after OPCOUNT
+// as these operations should never be tracked.
 typedef enum {
 	READ,
 	WRITE,
 	REQ_FENCE,
-        CUSTOM,
-        OPCOUNT
+	CUSTOM,
+	OPCOUNT,
+	INVALID
 } ReqOperation;
 
 
@@ -43,8 +47,8 @@ class GeneratorRequest {
 		reqID = nextGeneratorRequestID++;
 	}
 
-	virtual ~GeneratorRequest() {}
-	virtual ReqOperation getOperation() const = 0;
+	~GeneratorRequest() {}
+	ReqOperation getOperation() const { return op; };
 	uint64_t getRequestID() const { return reqID; }
 
 	void addDependency(uint64_t depReq) {
@@ -77,10 +81,22 @@ class GeneratorRequest {
 	void setIssueTime(const uint64_t now) {
 		issueTime = now;
 	}
+
+	void serialize_order(SST::Core::Serialization::serializer& ser) {
+		SST_SER(reqID);
+		SST_SER(issueTime);
+		SST_SER(dependsOn);
+		SST_SER(nextGeneratorRequestID);
+		SST_SER(op);
+	}
+	//ImplementSerializable(SST::Miranda::GeneratorRequest);
+
 protected:
 	uint64_t reqID;
 	uint64_t issueTime;
 	std::vector<uint64_t> dependsOn;
+	ReqOperation op = INVALID;
+
 private:
 	static std::atomic<uint64_t> nextGeneratorRequestID;
 };
@@ -168,6 +184,13 @@ class MirandaRequestQueue {
                 theQ[curSize] = t;
                 curSize++;
         }
+
+	void serialize_order(SST::Core::Serialization::serializer& ser) {
+		SST_SER(theQ);
+		SST_SER(maxCapacity);
+		SST_SER(curSize);
+	}
+
 private:
         QueueType* theQ;
         uint32_t maxCapacity;
@@ -180,20 +203,28 @@ class MemoryOpRequest : public GeneratorRequest {
 		const uint64_t cLength,
 		const ReqOperation cOpType) :
 		GeneratorRequest(),
-		addr(cAddr), length(cLength), op(cOpType)
-	{ assert (op == READ || op == WRITE); }
+		addr(cAddr), length(cLength)
+	{
+		op = cOpType;
+		assert (op == READ || op == WRITE);
+	}
 
+	MemoryOpRequest() = default;
 	~MemoryOpRequest() {}
-	ReqOperation getOperation() const { return op; }
 	bool isRead() const { return op == READ; }
 	bool isWrite() const { return op == WRITE; }
 	uint64_t getAddress() const { return addr; }
 	uint64_t getLength() const { return length; }
 
+	void serialize_order(SST::Core::Serialization::serializer& ser) {
+		SST::Miranda::GeneratorRequest::serialize_order(ser);
+		SST_SER(addr);
+		SST_SER(length);
+	}
+
 protected:
 	uint64_t addr;
 	uint64_t length;
-	ReqOperation op;
 };
 
 class CustomOpRequest : public GeneratorRequest {
@@ -202,7 +233,6 @@ class CustomOpRequest : public GeneratorRequest {
         GeneratorRequest(), data(cData) {}
     ~CustomOpRequest() {}
 
-    ReqOperation getOperation() const { return CUSTOM; }
     Interfaces::StandardMem::CustomData* getPayload() { return data; }
 
 protected:
@@ -213,7 +243,6 @@ class FenceOpRequest : public GeneratorRequest {
 public:
 	FenceOpRequest() : GeneratorRequest() {}
 	~FenceOpRequest() {}
-	ReqOperation getOperation() const { return REQ_FENCE; }
 };
 
 class RequestGenerator : public SubComponent {
@@ -222,14 +251,21 @@ class RequestGenerator : public SubComponent {
     SST_ELI_REGISTER_SUBCOMPONENT_API(SST::Miranda::RequestGenerator)
 
 	RequestGenerator( ComponentId_t id, Params& params) : SubComponent(id) {}
+	RequestGenerator() = default;
 	~RequestGenerator() {}
 	virtual void generate(MirandaRequestQueue<GeneratorRequest*>* q) { }
 	virtual bool isFinished() { return true; }
 	virtual void completed() { }
 
+	void serialize_order(SST::Core::Serialization::serializer& ser) override {
+		SST::SubComponent::serialize_order(ser);
+	}
+	ImplementSerializable(SST::Miranda::RequestGenerator);
+
 };
 
 }
 }
 
+
 #endif

src/sst/elements/miranda/mirandaMemMgr.h

@@ -127,6 +127,14 @@ class MirandaMemoryManager {
 
 		return physAddress;
 	}
+    void serialize_order(SST::Core::Serialization::serializer& ser) {
+        SST_SER(pageSize);
+        SST_SER(pageCount);
+        SST_SER(maxMemoryAddress);
+        SST_SER(output);
+        SST_SER(pageMap);
+    }
+
 
 private:
 	uint64_t pageSize;
@@ -135,8 +143,6 @@ class MirandaMemoryManager {
 	SST::Output* output;
 
     Shared::SharedArray<uint64_t> pageMap;
-	// const uint64_t * pageMap;
-
 };
 
 }