update FlatLutEntry

Author: aalkin

ALICE3/Core/FlatLutEntry.cxx

@@ -12,6 +12,7 @@
 #include "FlatLutEntry.h"
 
 #include <Framework/Logger.h>
+#include <Framework/RuntimeError.h>
 
 #include <cstring>
 
@@ -89,9 +90,9 @@ void FlatLutData::initialize(const lutHeader_t& header)
   size_t totalSize = headerSize + entriesSize;
 
   mData.resize(totalSize);
-
   // Write header at the beginning
   std::memcpy(mData.data(), &header, headerSize);
+  updateRef();
 }
 
 size_t FlatLutData::getEntryOffset(int nch_bin, int rad_bin, int eta_bin, int pt_bin) const
@@ -105,69 +106,95 @@ size_t FlatLutData::getEntryOffset(int nch_bin, int rad_bin, int eta_bin, int pt
   return headerSize + linearIdx * sizeof(lutEntry_t);
 }
 
-lutEntry_t* FlatLutData::getEntry(int nch_bin, int rad_bin, int eta_bin, int pt_bin)
+const lutEntry_t* FlatLutData::getEntryRef(int nch_bin, int rad_bin, int eta_bin, int pt_bin) const
 {
   size_t offset = getEntryOffset(nch_bin, rad_bin, eta_bin, pt_bin);
-  return reinterpret_cast<lutEntry_t*>(mData.data() + offset);
+  return reinterpret_cast<const lutEntry_t*>(mDataRef.data() + offset);
 }
 
-const lutEntry_t* FlatLutData::getEntry(int nch_bin, int rad_bin, int eta_bin, int pt_bin) const
+lutEntry_t* FlatLutData::getEntry(int nch_bin, int rad_bin, int eta_bin, int pt_bin)
 {
   size_t offset = getEntryOffset(nch_bin, rad_bin, eta_bin, pt_bin);
-  return reinterpret_cast<const lutEntry_t*>(mData.data() + offset);
+  return reinterpret_cast<lutEntry_t*>(mData.data() + offset);
 }
 
-FlatLutData FlatLutData::fromBuffer(const uint8_t* buffer, size_t size)
+const lutHeader_t& FlatLutData::getHeaderRef() const
 {
-  FlatLutData data;
-  // Validate buffer
-  if (size < sizeof(lutHeader_t)) {
-    LOG(fatal) << "Buffer too small for LUT header";
-  }
+  return *reinterpret_cast<const lutHeader_t*>(mDataRef.data());
+}
 
-  const auto* header = reinterpret_cast<const lutHeader_t*>(buffer);
-  data.mNchBins = header->nchmap.nbins;
-  data.mRadBins = header->radmap.nbins;
-  data.mEtaBins = header->etamap.nbins;
-  data.mPtBins = header->ptmap.nbins;
+lutHeader_t& FlatLutData::getHeader()
+{
+  return *reinterpret_cast<lutHeader_t*>(mData.data());
+}
 
-  size_t expectedSize = sizeof(lutHeader_t) + static_cast<size_t>(data.mNchBins) * data.mRadBins * data.mEtaBins * data.mPtBins * sizeof(lutEntry_t);
+void FlatLutData::updateRef()
+{
+  mDataRef = std::span{mData.data(), mData.size()};
+}
 
-  if (size < expectedSize) {
-    LOG(fatal) << "Buffer size mismatch: expected " << expectedSize << ", got " << size;
-  }
+void FlatLutData::cacheDimensions()
+{
+  auto const& header = getHeaderRef();
+  mNchBins = header.nchmap.nbins;
+  mRadBins = header.radmap.nbins;
+  mEtaBins = header.etamap.nbins;
+  mPtBins = header.ptmap.nbins;
+}
 
-  // Copy buffer
-  data.mData.resize(size);
-  std::memcpy(data.mData.data(), buffer, size);
+void FlatLutData::adopt(const uint8_t* buffer, size_t size)
+{
+  mData.resize(size);
+  std::memcpy(mData.data(), buffer, size);
+  updateRef();
+  cacheDimensions();
+}
 
-  return data;
+void FlatLutData::view(const uint8_t* buffer, size_t size)
+{
+  mData.clear();
+  mDataRef = std::span{buffer, size};
+  cacheDimensions();
 }
 
-FlatLutData FlatLutData::fromExternalBuffer(uint8_t* buffer, size_t size)
+void FlatLutData::validateBuffer(const uint8_t* buffer, size_t size)
 {
-  FlatLutData data;
   // Validate buffer
   if (size < sizeof(lutHeader_t)) {
-    LOG(fatal) << "Buffer too small for LUT header";
+    throw framework::runtime_error_f("Buffer too small for LUT header: expected at least %zu, got %zu", sizeof(lutHeader_t), size);
   }
 
   const auto* header = reinterpret_cast<const lutHeader_t*>(buffer);
-  data.mNchBins = header->nchmap.nbins;
-  data.mRadBins = header->radmap.nbins;
-  data.mEtaBins = header->etamap.nbins;
-  data.mPtBins = header->ptmap.nbins;
+  auto mNchBins = header->nchmap.nbins;
+  auto mRadBins = header->radmap.nbins;
+  auto mEtaBins = header->etamap.nbins;
+  auto mPtBins = header->ptmap.nbins;
 
-  size_t expectedSize = sizeof(lutHeader_t) + static_cast<size_t>(data.mNchBins) * data.mRadBins * data.mEtaBins * data.mPtBins * sizeof(lutEntry_t);
+  size_t expectedSize = sizeof(lutHeader_t) + static_cast<size_t>(mNchBins) * mRadBins * mEtaBins * mPtBins * sizeof(lutEntry_t);
 
   if (size < expectedSize) {
-    LOG(fatal) << "Buffer size mismatch: expected " << expectedSize << " got " << size;
+    throw framework::runtime_error_f("Buffer size mismatch: expected %zu, got %zu", expectedSize, size);
   }
+}
 
-  // Store reference to external buffer (no copy)
-  // WARNING: Caller must ensure buffer lifetime exceeds FlatLutData usage
-  data.mData.assign(buffer, buffer + size);
+FlatLutData FlatLutData::AdoptFromBuffer(const uint8_t* buffer, size_t size)
+{
+  validateBuffer(buffer, size);
+  FlatLutData data;
+
+  // Copy buffer
+  data.adopt(buffer, size);
+  return data;
+}
 
+FlatLutData FlatLutData::ViewFromBuffer(const uint8_t* buffer, size_t size)
+{
+  validateBuffer(buffer, size);
+  FlatLutData data;
+
+  // Store reference to external buffer
+  // WARNING: Caller must ensure buffer lifetime exceeds FlatLutData usage
+  data.view(buffer, size);
   return data;
 }
 

ALICE3/Core/FlatLutEntry.h

@@ -14,6 +14,7 @@
 
 #include <cmath>
 #include <cstdint>
+#include <span>
 #include <vector>
 
 #define LUTCOVM_VERSION 20260408
@@ -100,51 +101,76 @@ class FlatLutData
   void initialize(const lutHeader_t& header);
 
   /**
-   * @brief Get LUT entry by bin indices
-   * O(1) access via linear index calculation
+   * @brief Get LUT entry by bin indices (view)
+   */
+  const lutEntry_t* getEntryRef(int nch_bin, int rad_bin, int eta_bin, int pt_bin) const;
+
+  /**
+   * @brief Get LUT entry by bin indices (owned)
    */
   lutEntry_t* getEntry(int nch_bin, int rad_bin, int eta_bin, int pt_bin);
-  const lutEntry_t* getEntry(int nch_bin, int rad_bin, int eta_bin, int pt_bin) const;
 
   /**
-   * @brief Get raw data buffer (for serialization/shared memory)
+   * @brief Get LUT header (view)
    */
-  uint8_t* data() { return mData.data(); }
-  const uint8_t* data() const { return mData.data(); }
+  const lutHeader_t& getHeaderRef() const;
 
   /**
-   * @brief Total size in bytes
+   * @brief Get LUT header (owned)
    */
-  size_t bytes() const { return mData.size(); }
+  lutHeader_t& getHeader();
 
   /**
-   * @brief Construct from external buffer (e.g., shared memory or file mapping)
+   * @brief Get raw data buffer
    */
-  static FlatLutData fromBuffer(const uint8_t* buffer, size_t size);
+  uint8_t* data() { return mData.data(); } // owned
+  const uint8_t* data() const { return mDataRef.data(); } //view
 
   /**
-   * @brief Reference-based access without copying
-   * Useful when data is already in shared memory
+   * @brief Total size in bytes
    */
-  static FlatLutData fromExternalBuffer(uint8_t* buffer, size_t size);
+  size_t bytes() const { return mDataRef.size(); }
 
-  const lutHeader_t& header() const
-  {
-    return *reinterpret_cast<const lutHeader_t*>(mData.data());
-  }
+  /**
+   * @brief Construct a new FlatLutData from external buffer as a copy
+   */
+  static FlatLutData AdoptFromBuffer(const uint8_t* buffer, size_t size);
 
-  lutHeader_t& header()
-  {
-    return *reinterpret_cast<lutHeader_t*>(mData.data());
-  }
+  /**
+   * @brief Construct a new FlatLutData from external buffer as a view
+   */
+  static FlatLutData ViewFromBuffer(const uint8_t* buffer, size_t size);
 
  private:
   /**
    * @brief Linear index calculation for entry access
    */
   size_t getEntryOffset(int nch_bin, int rad_bin, int eta_bin, int pt_bin) const;
 
+  /**
+   * @brief Update dimensions from the current header
+   */
+  void cacheDimensions();
+
+  /**
+   * @brief Adopt a buffer by copying
+   */
+  void adopt(const uint8_t* buffer, size_t size);
+  /**
+   * @brief Adopt a buffer as a view
+   */
+  void view(const uint8_t* buffer, size_t size);
+  /**
+   * @brief Update mDataRef from mData
+   */
+  void updateRef();
+  /**
+   * @brief Validate external buffer
+   */
+  static void validateBuffer(const uint8_t* buffer, size_t size);
+
   std::vector<uint8_t> mData;
+  std::span<uint8_t const> mDataRef;
 
   // Cache dimensions for quick access
   int mNchBins = 0;