TPCFastTransform: remove unnecessary memory alignment in the spline data

Author: cbmsw

GPU/TPCFastTransformation/TPCFastSpaceChargeCorrection.cxx

@@ -147,9 +147,8 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
     }
     size_t bufferSize = scBufferOffset + scBufferSize;
     for (int32_t is = 0; is < 3; is++) {
-      size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
-      mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
-      bufferSize = correctionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
+      mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + bufferSize);
+      bufferSize += mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
     }
     return;
   }
@@ -256,7 +255,7 @@ void TPCFastSpaceChargeCorrection::setActualBufferAddress(char* actualFlatBuffer
 
   for (int32_t is = 0; is < 3; is++) {
     size_t oldCorrectionDataOffset = alignSize(oldBufferSize, SplineType::getParameterAlignmentBytes());
-    size_t correctionDataOffset = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    size_t correctionDataOffset = bufferSize;
     mCorrectionData[is] = reinterpret_cast<char*>(mFlatBufferPtr + correctionDataOffset);
     memmove(mCorrectionData[is], mFlatBufferPtr + oldCorrectionDataOffset, mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors());
     oldBufferSize = oldCorrectionDataOffset + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
@@ -509,16 +508,24 @@ void TPCFastSpaceChargeCorrection::finishConstruction()
   size_t bufferSize = scBufferOffsets[0] + scBufferSize;
   size_t correctionDataOffset[3];
   for (int32_t is = 0; is < 3; is++) {
-    correctionDataOffset[is] = alignSize(bufferSize, SplineType::getParameterAlignmentBytes());
+    correctionDataOffset[is] = bufferSize;
     mSectorDataSizeBytes[is] = 0;
     for (int32_t j = 0; j < mGeo.getNumberOfRows(); j++) {
       RowInfo& row = getRowInfo(j);
-      SplineType& spline = mConstructionScenarios[row.splineScenarioID];
-      row.dataOffsetBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-      mSectorDataSizeBytes[is] = row.dataOffsetBytes[is] + spline.getSizeOfParameters();
+      row.dataOffsetBytes[is] = mSectorDataSizeBytes[is];
+      const SplineType& spline = mConstructionScenarios[row.splineScenarioID];
+      if (is == 0) {
+        const SplineTypeXYZ& splineXYZ = reinterpret_cast<const SplineTypeXYZ&>(spline);
+        mSectorDataSizeBytes[is] += splineXYZ.getSizeOfParameters();
+      } else if (is == 1) {
+        const SplineTypeInvX& splineInvX = reinterpret_cast<const SplineTypeInvX&>(spline);
+        mSectorDataSizeBytes[is] += splineInvX.getSizeOfParameters();
+      } else if (is == 2) {
+        const SplineTypeInvYZ& splineInvYZ = reinterpret_cast<const SplineTypeInvYZ&>(spline);
+        mSectorDataSizeBytes[is] += splineInvYZ.getSizeOfParameters();
+      }
     }
-    mSectorDataSizeBytes[is] = alignSize(mSectorDataSizeBytes[is], SplineType::getParameterAlignmentBytes());
-    bufferSize = correctionDataOffset[is] + mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
+    bufferSize += mSectorDataSizeBytes[is] * mGeo.getNumberOfSectors();
   }
 
   FlatObject::finishConstruction(bufferSize);

GPU/TPCFastTransformation/TPCFastTransformPOD.cxx

@@ -157,40 +157,27 @@ TPCFastTransformPOD* TPCFastTransformPOD::create(char* buff, size_t buffSize, co
     nextDynOffs = alignOffset(nextDynOffs + spline.getFlatBufferSize());
   }
 
-  // copy spline data w/o memory alignment gaps between the sectors
+  // copy spline data
   for (int is = 0; is < 3; is++) {
     float* data = reinterpret_cast<float*>(buff + nextDynOffs);
     LOGP(debug, "splinID={} start offset {} -> {}", is, nextDynOffs, (void*)data);
 
     // metadata
-    size_t sectorDataSizeFloats = 0;
-    size_t sectorDataSizeBytes = 0;
-    for (int row = 0; row < NROWS; row++) {
-      podMap.getRowInfo(row).dataOffsetBytes[is] = sectorDataSizeBytes;
-      const auto& spline = origCorr.getSplineForRow(row);
-      int nPar = spline.getNumberOfParameters();
-      if (is == 1) {
-        nPar = nPar / 3;
-      }
-      if (is == 2) {
-        nPar = nPar * 2 / 3;
-      }
-      sectorDataSizeFloats += nPar;
-      sectorDataSizeBytes += nPar * sizeof(float);
-    }
+    size_t sectorDataSizeBytes = origCorr.mSectorDataSizeBytes[is];
 
-    for (int sector = 0; sector < origCorr.mGeo.getNumberOfSectors(); sector++) {
-      podMap.mSplineDataOffsets[sector][is] = nextDynOffs;
-      if (buffSize < nextDynOffs + sectorDataSizeBytes) {
-        throw std::runtime_error(fmt::format("attempt to copy {} bytes of data for spline{} of sector{} to {}, overflowing the buffer of size {}", sectorDataSizeBytes, is, sector, nextDynOffs, buffSize));
-      }
-      const float* dataOr = origCorr.getCorrectionData(sector, 0, is);
-      std::memcpy(data, dataOr, sectorDataSizeBytes);
-      data += sectorDataSizeFloats;
-      nextDynOffs += sectorDataSizeBytes;
+    for (int sector = 0; sector < TPCFastTransformGeo::getNumberOfSectors(); sector++) {
+      podMap.mSplineDataOffsets[sector][is] = nextDynOffs + sectorDataSizeBytes * sector;
+    }
+    size_t dataSize = TPCFastTransformGeo::getNumberOfSectors() * sectorDataSizeBytes;
+    if (buffSize < nextDynOffs + dataSize) {
+      throw std::runtime_error(fmt::format("attempt to copy {} bytes of data for spline{} to {}, overflowing the buffer of size {}", sectorDataSizeBytes, is, nextDynOffs, buffSize));
     }
+    const char* dataOr = origCorr.mCorrectionData[is];
+    std::memcpy(data, dataOr, dataSize);
+    nextDynOffs += dataSize;
   }
-  podMap.mTotalSize = alignOffset(nextDynOffs);
+  nextDynOffs = alignOffset(nextDynOffs);
+  podMap.mTotalSize = nextDynOffs;
   if (buffSize != podMap.mTotalSize) {
     throw std::runtime_error(fmt::format("Estimated buffer size {} differs from filled one {}", buffSize, podMap.mTotalSize));
   }