every class is serializable except for RequestGenCPU and GeneratorRequest

Author: plavin

src/sst/elements/miranda/mirandaCPU.h

@@ -151,6 +151,7 @@ class RequestGenCPU : public SST::Component {
         SST_SER(srcReqEvent);
         SST_SER(stdMemHandlers);
 
+        // TODO - fails as there is no serialize_impl for GeneratorRequest
         //SST_SER(pendingRequests);
         SST_SER(memMgr);
 

src/sst/elements/miranda/mirandaGenerator.h

@@ -32,12 +32,12 @@ typedef enum {
 	READ,
 	WRITE,
 	REQ_FENCE,
-        CUSTOM,
-        OPCOUNT
+	CUSTOM,
+	OPCOUNT
 } ReqOperation;
 
 
-class GeneratorRequest {
+class GeneratorRequest : public SST::Core::Serialization::serializable {
 public:
 	GeneratorRequest() {
 		reqID = nextGeneratorRequestID++;
@@ -77,6 +77,16 @@ class GeneratorRequest {
 	void setIssueTime(const uint64_t now) {
 		issueTime = now;
 	}
+
+	virtual void serialize_order(SST::Core::Serialization::serializer& ser) override {
+		SST_SER(reqID);
+		SST_SER(issueTime);
+		SST_SER(dependsOn);
+		SST_SER(nextGeneratorRequestID);
+    }
+
+    ImplementVirtualSerializable(SST::Miranda::GeneratorRequest)
+
 protected:
 	uint64_t reqID;
 	uint64_t issueTime;
@@ -88,33 +98,30 @@ class GeneratorRequest {
 template<typename QueueType>
 class MirandaRequestQueue {
 public:
-       	MirandaRequestQueue() {
-                        theQ = (QueueType*) malloc(sizeof(QueueType) * 16);
-                        maxCapacity = 16;
-                        curSize = 0;
-                }
-        ~MirandaRequestQueue() {
-               	free(theQ);
-        }
-
-        bool empty() const {
-               	return 0 == curSize;
-        }
-
-        void resize(const uint32_t newSize) {
-//		printf("Resizing MirandaQueue from: %" PRIu32 " to %" PRIu32 "\n",
-//			curSize, newSize);
-
-               	QueueType * newQ = (QueueType *) malloc(sizeof(QueueType) * newSize);
-               	for(uint32_t i = 0; i < curSize; ++i) {
-                       	newQ[i] = theQ[i];
-                }
-
-                free(theQ);
-               	theQ = newQ;
-               	maxCapacity = newSize;
-               	curSize = std::min(curSize, newSize);
-        }
+	MirandaRequestQueue() {
+		theQ = (QueueType*) malloc(sizeof(QueueType) * 16);
+		maxCapacity = 16;
+		curSize = 0;
+	}
+	~MirandaRequestQueue() {
+			free(theQ);
+	}
+
+	bool empty() const {
+		return 0 == curSize;
+	}
+
+	void resize(const uint32_t newSize) {
+		QueueType * newQ = (QueueType *) malloc(sizeof(QueueType) * newSize);
+		for(uint32_t i = 0; i < curSize; ++i) {
+			newQ[i] = theQ[i];
+		}
+
+		free(theQ);
+		theQ = newQ;
+		maxCapacity = newSize;
+		curSize = std::min(curSize, newSize);
+	}
 
 	uint32_t size() const {
 		return curSize;
@@ -124,72 +131,91 @@ class MirandaRequestQueue {
 		return maxCapacity;
 	}
 
-       	QueueType at(const uint32_t index) {
-               	return theQ[index];
-       	}
+	QueueType at(const uint32_t index) {
+		return theQ[index];
+	}
 
-       	void erase(const std::vector<uint32_t> eraseList) {
+	void erase(const std::vector<uint32_t> eraseList) {
 		if(0 == eraseList.size()) {
 			return;
 		}
 
-               	QueueType* newQ = (QueueType*) malloc(sizeof(QueueType) * maxCapacity);
+		QueueType* newQ = (QueueType*) malloc(sizeof(QueueType) * maxCapacity);
 
-               	uint32_t nextSkipIndex = 0;
-               	uint32_t nextSkip = eraseList.at(nextSkipIndex);
-                uint32_t nextNewQIndex = 0;
+		uint32_t nextSkipIndex = 0;
+		uint32_t nextSkip = eraseList.at(nextSkipIndex);
+		uint32_t nextNewQIndex = 0;
 
-               	for(uint32_t i = 0; i < curSize; ++i) {
-                       	if(nextSkip == i) {
-                                nextSkipIndex++;
+		for(uint32_t i = 0; i < curSize; ++i) {
+			if(nextSkip == i) {
+				nextSkipIndex++;
 
-                                if(nextSkipIndex >= eraseList.size()) {
-                                       	nextSkip = curSize;
-                               	} else {
-                                       	nextSkip = eraseList.at(nextSkipIndex);
-                                }
-                       	} else {
-                               	newQ[nextNewQIndex] = theQ[i];
-                                nextNewQIndex++;
-                       	}
-               	}
+				if(nextSkipIndex >= eraseList.size()) {
+					nextSkip = curSize;
+				} else {
+					nextSkip = eraseList.at(nextSkipIndex);
+				}
+			} else {
+				newQ[nextNewQIndex] = theQ[i];
+				nextNewQIndex++;
+			}
+		}
 
-                free(theQ);
+		free(theQ);
 
-               	theQ = newQ;
+		theQ = newQ;
 		curSize = nextNewQIndex;
-        }
+	}
 
 	void push_back(QueueType t) {
-                if(curSize == maxCapacity) {
-                        resize(maxCapacity + 16);
-                }
+		if(curSize == maxCapacity) {
+			resize(maxCapacity + 16);
+		}
+
+		theQ[curSize] = t;
+		curSize++;
+	}
+
+    void serialize_order(SST::Core::Serialization::serializer& ser) {
+		SST_SER(theQ);
+		SST_SER(maxCapacity);
+		SST_SER(curSize);
+	}
 
-                theQ[curSize] = t;
-                curSize++;
-        }
 private:
-        QueueType* theQ;
-        uint32_t maxCapacity;
-        uint32_t curSize;
+	QueueType* theQ;
+	uint32_t maxCapacity;
+	uint32_t curSize;
 };
 
 class MemoryOpRequest : public GeneratorRequest {
 public:
-        MemoryOpRequest(const uint64_t cAddr,
+	MemoryOpRequest(const uint64_t cAddr,
 		const uint64_t cLength,
 		const ReqOperation cOpType) :
 		GeneratorRequest(),
 		addr(cAddr), length(cLength), op(cOpType)
-	{ assert (op == READ || op == WRITE); }
-
+	{
+		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; }
 
+	virtual void serialize_order(SST::Core::Serialization::serializer& ser) override {
+        SST::Miranda::GeneratorRequest::serialize_order(ser);
+		SST_SER(addr);
+		SST_SER(length);
+		SST_SER(op);
+    }
+
+    ImplementSerializable(SST::Miranda::MemoryOpRequest)
+
 protected:
 	uint64_t addr;
 	uint64_t length;
@@ -200,11 +226,19 @@ class CustomOpRequest : public GeneratorRequest {
 public:
     CustomOpRequest(Interfaces::StandardMem::CustomData* cData) :
         GeneratorRequest(), data(cData) {}
+	CustomOpRequest() = default;
     ~CustomOpRequest() {}
 
     ReqOperation getOperation() const { return CUSTOM; }
     Interfaces::StandardMem::CustomData* getPayload() { return data; }
 
+	virtual void serialize_order(SST::Core::Serialization::serializer& ser) override {
+        SST::Miranda::GeneratorRequest::serialize_order(ser);
+		SST_SER(data);
+    }
+
+    ImplementSerializable(SST::Miranda::CustomOpRequest)
+
 protected:
     Interfaces::StandardMem::CustomData* data;
 };
@@ -214,6 +248,13 @@ class FenceOpRequest : public GeneratorRequest {
 	FenceOpRequest() : GeneratorRequest() {}
 	~FenceOpRequest() {}
 	ReqOperation getOperation() const { return REQ_FENCE; }
+
+	virtual void serialize_order(SST::Core::Serialization::serializer& ser) override {
+        SST::Miranda::GeneratorRequest::serialize_order(ser);
+    }
+
+    ImplementSerializable(SST::Miranda::FenceOpRequest)
+
 };
 
 class RequestGenerator : public SubComponent {