added alignment + comments

Author: sy-c

src/MemoryBankManager.cxx

@@ -12,76 +12,91 @@ MemoryBankManager::~MemoryBankManager() {
 int MemoryBankManager::addBank(std::shared_ptr<MemoryBank> bankPtr, std::string name) {
 
   // disable concurrent execution of this function
-  bankMutex.lock();
-  
+  std::unique_lock<std::mutex> lock(bankMutex);
+
   try {
     if (name.length()==0) {
       name=bankPtr->getDescription();
     }
     banks.push_back({name,bankPtr,{}});
   }
   catch(...) {
-    bankMutex.unlock();
     return -1;
   }  
 
-  bankMutex.unlock();
   return 0;
 }
 
 
-std::shared_ptr<MemoryPagesPool>  MemoryBankManager::getPagedPool(size_t pageSize, size_t pageNumber, std::string bankName){
+std::shared_ptr<MemoryPagesPool>  MemoryBankManager::getPagedPool(size_t pageSize, size_t pageNumber, std::string bankName, int pageAlign, int blockAlign){
 
-  // disable concurrent execution of this function
-  bankMutex.lock();
-  
-  // look for corresponding named bank
-  // if not specified, used first one...
-  unsigned int ix=0;
-  bool bankFound=false;
-  if (bankName.size()>0) {
-    for (ix=0;ix<banks.size();ix++) {
-      if (banks[ix].name==bankName) {
-        bankFound=true;
-        break;
+   void *baseAddress=nullptr; // base address of bank from which the block is taken
+   size_t offset=0; // offset of new block (relative to baseAddress)
+   size_t blockSize=0; // size of new block (in bytes)
+
+  // disable concurrent execution of this block
+  // automatic release of lock when going out of scope  
+  // beginning of locked block
+  {
+    std::unique_lock<std::mutex> lock(bankMutex);
+
+    // look for corresponding named bank
+    // if not specified, used first one...
+    unsigned int ix=0;
+    bool bankFound=false;
+    if (bankName.size()>0) {
+      for (ix=0;ix<banks.size();ix++) {
+	if (banks[ix].name==bankName) {
+          bankFound=true;
+          break;
+	}
+      }
+    } else {
+      if (banks.size()) {
+	ix=0;
+	bankFound=true;
       }
     }
-  } else {
-    if (banks.size()) {
-      ix=0;
-      bankFound=true;
+    if (!bankFound) {
+      return nullptr;
     }
-  }
-  if (!bankFound) {
-    bankMutex.unlock();
-    return nullptr;
-  }
 
-  // reserve space from big block 
-  size_t offset=0; // offset of new block
-  void *baseAddress=banks[ix].bank->getBaseAddress(); // base address of bank
-  size_t blockSize=pageSize*pageNumber; // size of new block
+    // reserve space from big block 
+    baseAddress=banks[ix].bank->getBaseAddress();
+    offset=0;
+    blockSize=pageSize*pageNumber;  // this is the maximum space to use... may loose some pages for alignment
 
-  // alloc new block after existing ranges already in use
-  for (auto it=banks[ix].rangesInUse.begin();it!=banks[ix].rangesInUse.end();++it) {
-    size_t maxOffset=it->offset+it->size;
-    if (maxOffset>offset) {
-      offset=maxOffset;
+    // alloc new block after existing ranges already in use
+    for (auto it=banks[ix].rangesInUse.begin();it!=banks[ix].rangesInUse.end();++it) {
+      size_t maxOffset=it->offset+it->size;
+      if (maxOffset>offset) {
+	offset=maxOffset;
+      }
     }
-  }
 
-  // check not exceeding bank size
-  if (offset+blockSize>banks[ix].bank->getSize()) {
-    bankMutex.unlock();
-    throw std::bad_alloc();
+    // align beginning of block as specified
+    if (blockAlign>0) {
+      size_t bytesExcess=(((size_t)baseAddress)+offset) % blockAlign;
+      if (bytesExcess) {
+        size_t alignOffset=blockAlign-bytesExcess;
+	offset+=alignOffset; // advance to next aligned address
+	blockSize-=alignOffset; // decrease block size to respect initial limit
+      }
+    }
+    
+    // check not exceeding bank size
+    if (offset+blockSize>banks[ix].bank->getSize()) {
+      throw std::bad_alloc();
+    }
+
+    // keep track of this new block
+    banks[ix].rangesInUse.push_back({offset,blockSize});
   }
-  
-  // keep track of this new block
-  banks[ix].rangesInUse.push_back({offset,blockSize});
-  bankMutex.unlock();
-  
-  // create pool of pages from it
-  return std::make_shared<MemoryPagesPool>(pageSize,pageNumber,&(((char *)baseAddress)[offset]),blockSize);
+  // end of locked block
+    
+  // create pool of pages from new block
+  return std::make_shared<MemoryPagesPool>(pageSize,pageNumber,&(((char *)baseAddress)[offset]),blockSize,nullptr,pageAlign);
 }
 
+// a global MemoryBankManager instance
 MemoryBankManager theMemoryBankManager;

src/MemoryBankManager.h

@@ -21,11 +21,21 @@ class MemoryBankManager {
   ~MemoryBankManager(); // destructor
 
   int addBank(std::shared_ptr<MemoryBank> bankPtr, std::string name=""); // add a named memory bank to the manager. By default, takes name from bank description
-  std::shared_ptr<MemoryPagesPool> getPagedPool(size_t pageSize, size_t pageNumber, std::string bankName=""); // get a pool of pages from the manager
+  
+  // get a pool of pages from the manager, using the banks available
+  // parameters:
+  // - pageSize: size of one page (in bytes)
+  // - pageNumber: number of pages requested
+  // - bankName: name of the bank from which to create the pool. If not specified, using the first bank.
+  // - pageAlign: alignment of first page in pool
+  // - blockAlign: alignment of beginning of big memory block from which pool is created
+  // NB: trivial implementation, once a region from a bank has been used, it can not be reused after the corresponding pool of pages has been release
+  //    ... don't want to deal with fragmentation etc
+  std::shared_ptr<MemoryPagesPool> getPagedPool(size_t pageSize, size_t pageNumber, std::string bankName="", int pageAlign=0, int blockAlign=0);
 
   // a struct to define a memory range
   struct memoryRange {
-    size_t offset; // beginning of memory range (bytes)
+    size_t offset; // beginning of memory range (bytes, counted from beginning of block)
     size_t size; // size of memory range (bytes)
   };
 
@@ -42,6 +52,7 @@ class MemoryBankManager {
   std::mutex bankMutex; // instance mutex to handle concurrent access to public methods
 };
 
+// a global MemoryBankManager instance
 extern MemoryBankManager theMemoryBankManager;
 
 #endif // #ifndef _MEMORYBANKMANAGER_H