define offset of first page instead of alignment

Author: sy-c

src/MemoryBankManager.cxx

@@ -28,7 +28,7 @@ int MemoryBankManager::addBank(std::shared_ptr<MemoryBank> bankPtr, std::string
 }
 
 
-std::shared_ptr<MemoryPagesPool>  MemoryBankManager::getPagedPool(size_t pageSize, size_t pageNumber, std::string bankName, size_t pageAlign, size_t blockAlign){
+std::shared_ptr<MemoryPagesPool>  MemoryBankManager::getPagedPool(size_t pageSize, size_t pageNumber, std::string bankName, size_t firstPageOffset, size_t blockAlign){
 
    void *baseAddress=nullptr; // base address of bank from which the block is taken
    size_t offset=0; // offset of new block (relative to baseAddress)
@@ -95,7 +95,7 @@ std::shared_ptr<MemoryPagesPool>  MemoryBankManager::getPagedPool(size_t pageSiz
   // end of locked block
 
   // create pool of pages from new block
-  return std::make_shared<MemoryPagesPool>(pageSize,pageNumber,&(((char *)baseAddress)[offset]),blockSize,nullptr,pageAlign);
+  return std::make_shared<MemoryPagesPool>(pageSize,pageNumber,&(((char *)baseAddress)[offset]),blockSize,nullptr,firstPageOffset);
 }
 
 // a global MemoryBankManager instance

src/MemoryBankManager.h

@@ -27,11 +27,11 @@ class MemoryBankManager {
   // - 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
+  // - firstPageOffset: to control alignment of first page in pool. With zero, start from beginning of big block.
+  // - blockAlign: alignment of beginning of big memory block from which pool is created. Pool will start at a multiple of this value.
   // 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="", size_t pageAlign=0, size_t blockAlign=0);
+  std::shared_ptr<MemoryPagesPool> getPagedPool(size_t pageSize, size_t pageNumber, std::string bankName="", size_t firstPageOffset=0, size_t blockAlign=0);
 
   // a struct to define a memory range
   struct memoryRange {

src/MemoryPagesPool.cxx

@@ -1,6 +1,6 @@
 #include "MemoryPagesPool.h"
 
-MemoryPagesPool::MemoryPagesPool(size_t vPageSize, size_t vNumberOfPages, void *vBaseAddress, size_t vBaseSize,  ReleaseCallback vCallback, size_t pageAlign) {
+MemoryPagesPool::MemoryPagesPool(size_t vPageSize, size_t vNumberOfPages, void *vBaseAddress, size_t vBaseSize,  ReleaseCallback vCallback, size_t firstPageOffset) {
   // initialize members from parameters
   pageSize=vPageSize;
   numberOfPages=vNumberOfPages;
@@ -13,25 +13,21 @@ MemoryPagesPool::MemoryPagesPool(size_t vPageSize, size_t vNumberOfPages, void *
     baseBlockSize=pageSize * numberOfPages;
   }
 
-  // compute offset of first page to ensure aligned as requested
-  size_t offsetFirstPage=0;
-  if (pageAlign) {
-    size_t bytesExcess=((size_t)vBaseAddress) % pageAlign;
-    if (bytesExcess) {
-      offsetFirstPage=pageAlign-bytesExcess;
-    }
+  // check validity of parameters
+  if ((firstPageOffset>=vBaseSize)||(vBaseSize==0)||(vNumberOfPages==0)||(vPageSize==0)||(baseBlockSize==0)) {
+    throw __LINE__;
   }
-  
+ 
   // if necessary, reduce number of pages to fit in available space
-  size_t sizeNeeded=pageSize * numberOfPages + offsetFirstPage;
-  if (sizeNeeded>baseBlockSize) {
-    numberOfPages=(baseBlockSize-offsetFirstPage)/pageSize;
+  size_t sizeNeeded=pageSize * numberOfPages + firstPageOffset;
+  if (sizeNeeded>baseBlockSize) {    
+    numberOfPages=(baseBlockSize-firstPageOffset)/pageSize;
   }
 
   // create a fifo and store list of pages available
   pagesAvailable=std::make_unique<AliceO2::Common::Fifo<void *>>(numberOfPages);
   for (size_t i=0; i<numberOfPages; i++) {
-    void *ptr=&((char *)baseBlockAddress)[offsetFirstPage+i*pageSize];
+    void *ptr=&((char *)baseBlockAddress)[firstPageOffset+i*pageSize];
     pagesAvailable->push(ptr);
   }
 }

src/MemoryPagesPool.h

@@ -27,10 +27,11 @@ class MemoryPagesPool {
   // - size of each page (in bytes)
   // - number of pages in the pool
   // - base address of memory block where to create the pages
-  // - size of memory block in bytes (if zero, assuming it is big enough for page number * page size)
+  // - size of memory block in bytes (if zero, assuming it is big enough for page number * page size - not taking into account firstPageOffset is set)
   // - a release callback to be called at destruction time
-  // - page align is for alignment of 1st page (all pages are created contiguous)
-  MemoryPagesPool(size_t pageSize, size_t numberOfPages, void *baseAddress, size_t baseSize=0, ReleaseCallback callback=nullptr, size_t pageAlign=0);
+  // - firstPageOffset is the offset of first page from base address. This is to control alignment. All pages are created contiguous from this point.
+  //   If non-zero, this may reduce number of pages created compared to request (as to fit in base size)
+  MemoryPagesPool(size_t pageSize, size_t numberOfPages, void *baseAddress, size_t baseSize=0, ReleaseCallback callback=nullptr, size_t firstPageOffset=0);
 
   // destructor
   ~MemoryPagesPool();