Continue to work on the MPI Starpu

Src/GroupTree/FGroupOfCells.hpp

@@ -5,6 +5,7 @@
 #define FGROUPOFCELLS_HPP
 
 #include "../Utils/FAssert.hpp"
+#include "../Utils/FAlignedMemory.hpp"
 #include "../Containers/FTreeCoordinate.hpp"
 
 #include <list>
@@ -39,15 +40,34 @@ protected:
     //< This value is for not used cells
     static const MortonIndex CellIsEmptyFlag = -1;
 
+    //< To kown if the object has to delete the memory
+    bool deleteBuffer;
+
 public:
     /**
+     * Init from a given buffer
+     * @param inBuffer
+     * @param inAllocatedMemoryInByte
+     */
+    FGroupOfCells(unsigned char* inBuffer, const size_t inAllocatedMemoryInByte)
+        : allocatedMemoryInByte(inAllocatedMemoryInByte), memoryBuffer(inBuffer),
+          blockHeader(nullptr), blockIndexesTable(nullptr), blockCells(nullptr),
+          deleteBuffer(false){
+        // Move the pointers to the correct position
+        blockHeader         = reinterpret_cast<BlockHeader*>(memoryBuffer);
+        blockIndexesTable   = reinterpret_cast<int*>(memoryBuffer+sizeof(BlockHeader));
+        blockCells          = reinterpret_cast<CellClass*>(memoryBuffer+sizeof(BlockHeader)+(blockHeader->blockIndexesTableSize*sizeof(int)));
+    }
+
+    /**
  * @brief FGroupOfCells
  * @param inStartingIndex first cell morton index
  * @param inEndingIndex last cell morton index + 1
  * @param inNumberOfCells total number of cells in the interval (should be <= inEndingIndex-inEndingIndex)
  */
     FGroupOfCells(const MortonIndex inStartingIndex, const MortonIndex inEndingIndex, const int inNumberOfCells)
-        : allocatedMemoryInByte(0), memoryBuffer(nullptr), blockHeader(nullptr), blockIndexesTable(nullptr), blockCells(nullptr) {
+        : allocatedMemoryInByte(0), memoryBuffer(nullptr), blockHeader(nullptr), blockIndexesTable(nullptr), blockCells(nullptr),
+          deleteBuffer(true){
         // Find the number of cell to allocate in the blocks
         const int blockIndexesTableSize = int(inEndingIndex-inStartingIndex);
         FAssertLF(inNumberOfCells <= blockIndexesTableSize);
@@ -57,7 +77,7 @@ public:
         // Allocate
         FAssertLF(0 <= int(memoryToAlloc) && int(memoryToAlloc) < std::numeric_limits<int>::max());
         allocatedMemoryInByte = memoryToAlloc;
-        memoryBuffer = new unsigned char[memoryToAlloc];
+        memoryBuffer = (unsigned char*)FAlignedMemory::Allocate32BAligned(memoryToAlloc);
         FAssertLF(memoryBuffer);
         memset(memoryBuffer, 0, memoryToAlloc);
 
@@ -80,12 +100,19 @@ public:
 
     /** Call the destructor of cells and dealloc block memory */
     ~FGroupOfCells(){
-        for(int idxCellPtr = 0 ; idxCellPtr < blockHeader->blockIndexesTableSize ; ++idxCellPtr){
-            if(blockIndexesTable[idxCellPtr] != CellIsEmptyFlag){
-                (&blockCells[blockIndexesTable[idxCellPtr]])->~CellClass();
+        if(deleteBuffer){
+            for(int idxCellPtr = 0 ; idxCellPtr < blockHeader->blockIndexesTableSize ; ++idxCellPtr){
+                if(blockIndexesTable[idxCellPtr] != CellIsEmptyFlag){
+                    (&blockCells[blockIndexesTable[idxCellPtr]])->~CellClass();
+                }
             }
+            FAlignedMemory::Dealloc32BAligned(memoryBuffer);
         }
-        delete[] memoryBuffer;
+    }
+
+    /** Give access to the buffer to send the data */
+    const unsigned char* getRawBuffer() const{
+        return memoryBuffer;
     }
 
     /** The the size of the allocated buffer */
@@ -93,6 +120,11 @@ public:
         return allocatedMemoryInByte;
     }
 
+    /** To know if the object will delete the memory block */
+    bool getDeleteMemory() const{
+        return deleteBuffer;
+    }
+
     /** The index of the fist cell (set from the constructor) */
     MortonIndex getStartingIndex() const {
         return blockHeader->startingIndex;

Src/GroupTree/FGroupOfParticles.hpp

@@ -41,6 +41,7 @@ class FGroupOfParticles {
         size_t offSet;
     };
 
+
 protected:
     static const int MemoryAlignementBytes     = 32;
     static const int MemoryAlignementParticles = MemoryAlignementBytes/sizeof(FReal);
@@ -78,15 +79,49 @@ protected:
     //< Pointers to the particles data inside the block memory
     AttributeClass*      particleAttributes[NbAttributesPerParticle];
 
+    /** To know if we have to delete the buffer */
+    bool deleteBuffer;
+
 public:
     /**
+     * Init from a given buffer
+     * @param inBuffer
+     * @param inAllocatedMemoryInByte
+     */
+    FGroupOfParticles(unsigned char* inBuffer, const size_t inAllocatedMemoryInByte)
+        : allocatedMemoryInByte(inAllocatedMemoryInByte), memoryBuffer(inBuffer),
+          blockHeader(nullptr), blockIndexesTable(nullptr), leafHeader(nullptr), nbParticlesInGroup(0),
+          deleteBuffer(false){
+        // Move the pointers to the correct position
+        blockHeader         = reinterpret_cast<BlockHeader*>(memoryBuffer);
+        blockIndexesTable   = reinterpret_cast<int*>(memoryBuffer+sizeof(BlockHeader));
+        leafHeader          = reinterpret_cast<LeafHeader*>(memoryBuffer+sizeof(BlockHeader)+(blockHeader->blockIndexesTableSize*sizeof(int)));
+
+        // Init particle pointers
+        blockHeader->positionOffset = (sizeof(FReal) * blockHeader->nbParticlesAllocatedInGroup);
+        particlePosition[0] = reinterpret_cast<FReal*>((reinterpret_cast<size_t>(leafHeader + blockHeader->numberOfLeavesInBlock)
+                                                       +MemoryAlignementBytes-1) & ~(MemoryAlignementBytes-1));
+        particlePosition[1] = (particlePosition[0] + blockHeader->nbParticlesAllocatedInGroup);
+        particlePosition[2] = (particlePosition[1] + blockHeader->nbParticlesAllocatedInGroup);
+
+        // Redirect pointer to data
+        blockHeader->attributeOffset = (sizeof(AttributeClass) * blockHeader->nbParticlesAllocatedInGroup);
+        unsigned char* previousPointer = reinterpret_cast<unsigned char*>(particlePosition[2] + blockHeader->nbParticlesAllocatedInGroup);
+        for(unsigned idxAttribute = 0 ; idxAttribute < NbAttributesPerParticle ; ++idxAttribute){
+            particleAttributes[idxAttribute] = reinterpret_cast<AttributeClass*>(previousPointer);
+            previousPointer += sizeof(AttributeClass)*blockHeader->nbParticlesAllocatedInGroup;
+        }
+    }
+
+    /**
  * @brief FGroupOfParticles
  * @param inStartingIndex first leaf morton index
  * @param inEndingIndex last leaf morton index + 1
  * @param inNumberOfLeaves total number of leaves in the interval (should be <= inEndingIndex-inEndingIndex)
  */
     FGroupOfParticles(const MortonIndex inStartingIndex, const MortonIndex inEndingIndex, const int inNumberOfLeaves, const int inNbParticles)
-        : allocatedMemoryInByte(0), memoryBuffer(nullptr), blockHeader(nullptr), blockIndexesTable(nullptr), leafHeader(nullptr), nbParticlesInGroup(inNbParticles) {
+        : allocatedMemoryInByte(0), memoryBuffer(nullptr), blockHeader(nullptr), blockIndexesTable(nullptr), leafHeader(nullptr), nbParticlesInGroup(inNbParticles),
+          deleteBuffer(true){
         memset(particlePosition, 0, sizeof(particlePosition));
         memset(particleAttributes, 0, sizeof(particleAttributes));
 
@@ -144,7 +179,14 @@ public:
 
     /** Call the destructor of leaves and dealloc block memory */
     ~FGroupOfParticles(){
-        FAlignedMemory::Dealloc32BAligned(memoryBuffer);
+        if(deleteBuffer){
+            FAlignedMemory::Dealloc32BAligned(memoryBuffer);
+        }
+    }
+
+    /** Give access to the buffer to send the data */
+    const unsigned char* getRawBuffer() const{
+        return memoryBuffer;
     }
 
     /** The the size of the allocated buffer */
@@ -152,6 +194,11 @@ public:
         return allocatedMemoryInByte;
     }
 
+    /** To know if the object will delete the memory block */
+    bool getDeleteMemory() const{
+        return deleteBuffer;
+    }
+
     /** The index of the fist leaf (set from the constructor) */
     MortonIndex getStartingIndex() const {
         return blockHeader->startingIndex;