lib/memory-manager: start implementation using DirectedGraph

fpga/include/villas/memory_manager.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <cstdint>
+#include <string>
 
 #include "log.hpp"
 #include "directed_graph.hpp"
@@ -9,12 +10,25 @@ namespace villas {
 
 
 class Mapping : public graph::Edge {
-public:
-    // create mapping here (if needed)
-    Mapping() {}
+	friend class MemoryManager;
 
-    // destroy mapping here (if needed)
-    ~Mapping() {}
+public:
+	// create mapping here (if needed)
+	Mapping() {}
+
+	// destroy mapping here (if needed)
+	virtual ~Mapping();
+
+	friend std::ostream&
+	operator<< (std::ostream& stream, const Mapping& mapping)
+	{
+		return stream << static_cast<const Edge&>(mapping) << " = "
+		              << std::hex
+		              << "(src=0x"   << mapping.src
+		              << ", dest=0x" << mapping.dest
+		              << ", size=0x" << mapping.size
+		              << ")";
+	}
 
 private:
     uintptr_t src;
@@ -23,25 +37,62 @@ private:
 };
 
 class AddressSpace : public graph::Vertex {
+	friend class MemoryManager;
+
+public:
+	friend std::ostream&
+	operator<< (std::ostream& stream, const AddressSpace& addrSpace)
+	{
+		return stream << static_cast<const Vertex&>(addrSpace) << " = "
+		              << addrSpace.name;
+	}
+
 private:
-    // do we need any metadata? maybe a name?
-    int id;
+	std::string name;
 };
 
 
 // is or has a graph
 class MemoryManager {
-
-// This is a singleton
 private:
-    MemoryManager() = default;
-    static MemoryManager* instance;
+	// This is a singleton, so private constructor
+	MemoryManager() :
+	    memoryGraph("MemoryGraph") {}
+
+	// no copying or assigning
+	MemoryManager(const MemoryManager&) = delete;
+	MemoryManager& operator=(const MemoryManager&) = delete ;
+
+	using MemoryGraph = graph::DirectedGraph<AddressSpace, Mapping>;
+
 public:
-    static MemoryManager& get();
+	using AddressSpaceId = MemoryGraph::VertexIdentifier;
+	using MappingId = MemoryGraph::EdgeIdentifier;
 
+	static MemoryManager& get();
+
+
+	AddressSpaceId createAddressSpace(std::string name);
+
+	/// Create a default mapping
+	MappingId createMapping(uintptr_t src, uintptr_t dest, size_t size,
+	                        AddressSpaceId fromAddrSpace,
+	                        AddressSpaceId toAddrSpace);
+
+	/// Add a mapping
+	///
+	/// Can be used to derive from Mapping in order to implement custom
+	/// constructor/destructor.
+	MappingId addMapping(std::shared_ptr<Mapping> mapping,
+	                     AddressSpaceId fromAddrSpace,
+	                     AddressSpaceId toAddrSpace);
+
+	void dump()
+	{ memoryGraph.dump(); }
 
 private:
-//    std::list<>
+	MemoryGraph memoryGraph;
+	static MemoryManager* instance;
 };
 
 } // namespace villas

fpga/lib/memory_manager.cpp

@@ -1,3 +1,5 @@
+#include <memory>
+
 #include "memory_manager.hpp"
 
 namespace villas {
@@ -15,5 +17,41 @@ MemoryManager::get()
 	return *instance;
 }
 
+MemoryManager::AddressSpaceId
+MemoryManager::createAddressSpace(std::string name)
+{
+	std::shared_ptr<AddressSpace> addrSpace(new AddressSpace);
+	addrSpace->name = name;
+
+	return memoryGraph.addVertex(addrSpace);
+}
+
+MemoryManager::MappingId
+MemoryManager::createMapping(uintptr_t src, uintptr_t dest, size_t size,
+                             MemoryManager::AddressSpaceId fromAddrSpace,
+                             MemoryManager::AddressSpaceId toAddrSpace)
+{
+	std::shared_ptr<Mapping> mapping(new Mapping);
+	mapping->src = src;
+	mapping->dest = dest;
+	mapping->size = size;
+
+	return addMapping(mapping, fromAddrSpace, toAddrSpace);
+}
+
+MemoryManager::MappingId
+MemoryManager::addMapping(std::shared_ptr<Mapping> mapping,
+                          MemoryManager::AddressSpaceId fromAddrSpace,
+                          MemoryManager::AddressSpaceId toAddrSpace)
+{
+	return memoryGraph.addEdge(mapping, fromAddrSpace, toAddrSpace);
+}
+
+
+Mapping::~Mapping()
+{
+
+}
+
 
 } // namespace villas