GPU Standalone: Add dumping and reading of dynamic structs with larger buffer than sizeof(struct)

Author: davidrohr

GPU/GPUTracking/Base/GPUReconstruction.h

@@ -300,9 +300,13 @@ class GPUReconstruction
   template <class T>
   void DumpStructToFile(const T* obj, const char* file);
   template <class T>
+  void DumpDynamicStructToFile(const T* obj, size_t dynamicSize, const char* file);
+  template <class T>
   std::unique_ptr<T> ReadStructFromFile(const char* file);
   template <class T>
   int32_t ReadStructFromFile(const char* file, T* obj);
+  template <class T, auto F>
+  aligned_unique_buffer_ptr<T> ReadDynamicStructFromFile(const char* file);
 
   // Others
   virtual RecoStepField AvailableGPURecoSteps() { return RecoStep::AllRecoSteps; }

GPU/GPUTracking/Base/GPUReconstructionIO.h

@@ -208,6 +208,57 @@ inline int32_t GPUReconstruction::ReadStructFromFile(const char* file, T* obj)
   return 0;
 }
 
+template <class T>
+inline void GPUReconstruction::DumpDynamicStructToFile(const T* obj, size_t dynamicSize, const char* file)
+{
+  FILE* fp = fopen(file, "w+b");
+  if (fp == nullptr) {
+    return;
+  }
+  size_t size = sizeof(*obj);
+  fwrite(&size, sizeof(size), 1, fp);
+  fwrite(&dynamicSize, sizeof(dynamicSize), 1, fp);
+  fwrite(obj, 1, dynamicSize, fp);
+  fclose(fp);
+}
+
+template <class T, auto F>
+inline aligned_unique_buffer_ptr<T> GPUReconstruction::ReadDynamicStructFromFile(const char* file)
+{
+  FILE* fp = fopen(file, "rb");
+  if (fp == nullptr) {
+    return nullptr;
+  }
+  size_t size, dynsize, r, r2;
+  r = fread(&size, sizeof(size), 1, fp);
+  r2 = fread(&dynsize, sizeof(dynsize), 1, fp);
+  if (r == 0 || r2 == 0 || size != sizeof(T) || dynsize < size) {
+    fclose(fp);
+    GPUError("ERROR reading %s, invalid size: %ld (%ld buffer size, %ld object size expected)", file, (int64_t)size, (int64_t)dynsize, (int64_t)sizeof(T));
+    throw std::runtime_error("invalid size");
+  }
+  std::unique_ptr<T> tmp = std::make_unique<T>();
+  r = fread(tmp.get(), sizeof(T), 1, fp);
+  if (r == 0) {
+    fclose(fp);
+    GPUError("ERROR reading %s", file, (int64_t)size, (int64_t)sizeof(T));
+    throw std::runtime_error("read error");
+  }
+  if ((tmp.get()->*F)() != dynsize) {
+    fclose(fp);
+    GPUError("ERROR: invalid size: %ld (%ld expected)", file, (int64_t)dynsize, (int64_t)(tmp.get()->*F)());
+    throw std::runtime_error("invalid size");
+  }
+  aligned_unique_buffer_ptr<T> newObj(dynsize);
+  memcpy(newObj.get(), tmp.get(), sizeof(T));
+  r = fread(newObj.getraw() + sizeof(T), 1, dynsize - sizeof(T), fp);
+  fclose(fp);
+  if (GetProcessingSettings().debugLevel >= 2) {
+    GPUInfo("Read %ld bytes from %s", (int64_t)r, file);
+  }
+  return newObj;
+}
+
 } // namespace o2::gpu
 
 #endif

GPU/GPUTracking/Global/GPUChain.h

@@ -176,6 +176,16 @@ class GPUChain
   {
     mRec->ReadStructFromFile<T>(file, obj);
   }
+  template <class T>
+  void DumpDynamicStructToFile(const T* obj, size_t dynamicSize, const char* file)
+  {
+    mRec->DumpDynamicStructToFile<T>(obj, dynamicSize, file);
+  }
+  template <class T, auto F>
+  aligned_unique_buffer_ptr<T> ReadDynamicStructFromFile(const char* file)
+  {
+    return mRec->ReadDynamicStructFromFile<T, F>(file);
+  }
 
   template <class S, int32_t I = 0, typename... Args>
     requires(sizeof(S) >= 0) // Yields better incomplete type errors than calling runKernelCallInterface directly

GPU/GPUTracking/Global/GPUChainTrackingIO.cxx

@@ -295,7 +295,7 @@ void GPUChainTracking::DumpSettings(const char* dir)
   if (processors()->calibObjects.fastTransform != nullptr) {
     f = dir;
     f += "tpctransform.dump";
-    DumpStructToFile(processors()->calibObjects.fastTransform, f.c_str());
+    DumpDynamicStructToFile(processors()->calibObjects.fastTransform, processors()->calibObjects.fastTransform->size(), f.c_str());
   }
   if (processors()->calibObjects.tpcPadGain != nullptr) {
     f = dir;
@@ -334,8 +334,8 @@ void GPUChainTracking::ReadSettings(const char* dir)
   std::string f;
   f = dir;
   f += "tpctransform.dump";
-  mTPCFastTransformU = ReadStructFromFile<TPCFastTransformPOD>(f.c_str());
-  processors()->calibObjects.fastTransform = (TPCFastTransformPOD*)mTPCFastTransformU.get();
+  mTPCFastTransformU = ReadDynamicStructFromFile<TPCFastTransformPOD, &TPCFastTransformPOD::size>(f.c_str());
+  processors()->calibObjects.fastTransform = mTPCFastTransformU.get();
   f = dir;
   f += "tpcpadgaincalib.dump";
   mTPCPadGainCalibU = ReadStructFromFile<TPCPadGainCalib>(f.c_str());