WIP

main/include/BankTypes.h

@@ -64,7 +64,12 @@ constexpr auto to_integral(ENUM e) -> typename std::underlying_type<ENUM>::type
   return static_cast<typename std::underlying_type<ENUM>::type>(e);
 }
 
-using BanksAndOffsets = std::tuple<std::vector<gsl::span<const char>>, size_t, gsl::span<const unsigned int>, int>;
+using BanksAndOffsets = std::tuple<
+  std::vector<gsl::span<const char>>, // Fragment data
+  std::vector<gsl::span<const uint16_t>>, // Fragment sizes
+  size_t, // Total data size
+  gsl::span<const unsigned int>, // Fragment offsets
+  int>; // Bank version
 
 template<BankTypes... BANKS>
 std::unordered_set<BankTypes> banks_set()

main/include/TransposeTypes.h

@@ -30,16 +30,16 @@ namespace Allen {
   using ReadBuffer = std::tuple<size_t, std::vector<unsigned int>, std::vector<char>, size_t>;
   using ReadBuffers = std::vector<ReadBuffer>;
 
-  // A slice contains transposed bank data, offsets to the start of each
-  // set of banks and the number of sets of banks
-  using Slice = std::tuple<std::vector<gsl::span<char>>, size_t, gsl::span<unsigned int>, size_t>;
+  using Slice = std::tuple<
+    std::vector<gsl::span<char>>, // bank data
+    std::vector<gsl::span<uint16_t>>, // the sizes of the fragments
+    size_t, // size of the bank data
+    gsl::span<unsigned int>, // offsets to address the fragments
+    size_t>; // number of offsets
   using BankSlices = std::vector<Slice>;
   using Slices = std::array<BankSlices, NBankTypes>;
 
   std::array<int, LHCb::NBankTypes> bank_ids();
-  int subdetector_id(const std::string subdetector);
-  int subdetector_index(const std::string subdetector);
-  int subdetector_index_from_bank_type(BankTypes bt);
 
   using sd_from_raw_bank = std::function<BankTypes(LHCb::RawBank const* raw_bank)>;
   using bank_sorter = std::function<bool(LHCb::RawBank const* a, LHCb::RawBank const* b)>;

main/src/SliceUtils.cpp

@@ -29,13 +29,16 @@ void reset_slice(
   // "Reset" the slice
   for (auto bank_type : bank_types) {
     auto ib = to_integral(bank_type);
-    auto& [banks, data_size, offsets, offsets_size] = slices[ib][slice_index];
+    auto& [banks, sizes, data_size, offsets, offsets_size] = slices[ib][slice_index];
     std::fill(offsets.begin(), offsets.end(), 0);
     offsets_size = 1;
     if (mep) {
       banks.clear();
       data_size = 0;
     }
+    else {
+      std::fill(sizes[0].begin(), sizes[0].end(), 0);
+    }
   }
   event_ids.clear();
 }
@@ -43,31 +46,39 @@ void reset_slice(
 Allen::Slices allocate_slices(
   size_t n_slices,
   std::unordered_set<BankTypes> const& bank_types,
-  std::function<std::tuple<size_t, size_t>(BankTypes)> size_fun)
+  std::function<std::tuple<size_t, size_t, size_t>(BankTypes)> size_fun)
 {
   Allen::Slices slices;
   for (auto bank_type : bank_types) {
-    auto [n_bytes, n_offsets] = size_fun(bank_type);
+    auto [n_bytes, n_sizes, n_offsets] = size_fun(bank_type);
 
     auto ib = to_integral(bank_type);
     auto& bank_slices = slices[ib];
     bank_slices.reserve(n_slices);
     for (size_t i = 0; i < n_slices; ++i) {
       char* events_mem = nullptr;
+      uint16_t* sizes_mem = nullptr;
       unsigned* offsets_mem = nullptr;
 
       if (n_bytes) Allen::malloc_host((void**) &events_mem, n_bytes);
+      if (n_sizes) Allen::malloc_host((void**) &sizes_mem, n_sizes * sizeof(uint16_t));
       if (n_offsets) Allen::malloc_host((void**) &offsets_mem, (n_offsets + 1) * sizeof(unsigned));
 
       for (size_t i = 0; i < n_offsets + 1; ++i) {
         offsets_mem[i] = 0;
       }
-      std::vector<gsl::span<char>> spans {};
+      std::vector<gsl::span<char const>> bank_spans {};
       if (n_bytes) {
-        spans.emplace_back(events_mem, n_bytes);
+        bank_spans.emplace_back(events_mem, n_bytes);
+      }
+
+      std::vector<gsl::span<uint16_t const>> size_spans {};
+      if (n_sizes) {
+        size_spans.emplace_back(sizes_mem, n_sizes);
       }
+
       bank_slices.emplace_back(
-        std::move(spans), n_bytes, offsets_span {offsets_mem, static_cast<offsets_size>(n_offsets + 1)}, 1);
+        std::move(bank_spans), std::move(size_spans), n_bytes, offsets_span {offsets_mem, static_cast<offsets_size>(n_offsets + 1)}, 1);
     }
   }
   return slices;

main/src/Transpose.cpp

@@ -225,11 +225,14 @@ std::tuple<bool, bool, bool> transpose_event(
   // Where should offsets to individual banks be written
   uint32_t* banks_offsets_write = nullptr;
 
+  // Memory where bank sizes are kept. The first N entries are offsets to the sizes per event
+  uint16_t* fragment_sizes = nullptr;
+
   unsigned int bank_offset = 0;
   unsigned int bank_counter = 1;
 
-  std::array<unsigned int, NBankTypes> sizes;
-  sizes.fill(2 * sizeof(unsigned int));
+  std::array<unsigned int, NBankTypes> size_per_type;
+  size_per_type.fill(2 * sizeof(unsigned int));
 
   auto bank = bank_data.data(), bank_end = bank_data.data() + bank_data.size();
 
@@ -248,7 +251,7 @@ std::tuple<bool, bool, bool> transpose_event(
     if (bank_types.count(allen_type) || allen_type == BankTypes::ODIN) {
       sorted_banks.push_back(b);
       bank_count[to_integral(allen_type)] += 1;
-      sizes[to_integral(allen_type)] += sizeof(unsigned int) + b->size();
+      size_per_type[to_integral(allen_type)] += sizeof(unsigned int) + b->size();
     }
     bank += b->totalSize();
   }
@@ -258,8 +261,8 @@ std::tuple<bool, bool, bool> transpose_event(
   // little space to fit this event
   for (auto allen_type : bank_types) {
     auto const ia = to_integral(allen_type);
-    const auto& [slice, slice_size, slice_offsets, offsets_size] = slices[ia][slice_index];
-    if ((slice_offsets[offsets_size - 1] + sizes[ia]) > slice_size) {
+    const auto& [slice, fragment_sizes, slice_size, slice_offsets, offsets_size] = slices[ia][slice_index];
+    if ((slice_offsets[offsets_size - 1] + size_per_type[ia]) > slice_size) {
       return {true, true, false};
     }
   }
@@ -305,9 +308,10 @@ std::tuple<bool, bool, bool> transpose_event(
       // set bank version
       banks_version[to_integral(allen_type)] = b->version();
 
+      // Reset bank count
       bank_counter = 1;
-      banks_offsets = std::get<2>(slice).data();
-      n_banks_offsets = &std::get<3>(slice);
+      banks_offsets = std::get<3>(slice).data();
+      n_banks_offsets = &std::get<4>(slice);
 
       // Calculate the size taken by storing the number of banks
       // and offsets to all banks within the event
@@ -317,10 +321,22 @@ std::tuple<bool, bool, bool> transpose_event(
       // previous one and increment with the preamble size
       banks_offsets[*n_banks_offsets] = (banks_offsets[*n_banks_offsets - 1] + preamble_words * sizeof(uint32_t));
 
-      // Three things to write for a new set of banks:
+      // Five things to write for a new set of banks:
       // - number of banks/offsets
       // - offsets to individual banks
       // - bank data
+      // - offset to the start of the bank sizes
+      // - the bank size
+
+      // The offsets to the sizes for this batch of fragments is
+      // copied from the current value
+      fragment_sizes = std::get<1>(slice)[0].data();
+      fragment_sizes_offset = fragment_sizes[*n_banks_offsets] + bank_counter - 1;
+      fragment_sizes[*n_banks_offsets + 1] = fragment_sizes_offset;
+      fragment_sizes += fragment_offset;
+
+      // Size write pointer is initialiazed from the offset
+      sizes_write = sizes_data + *n_sizes_write;
 
       // Initialize point to write from offset of previous set
       banks_write = reinterpret_cast<uint32_t*>(std::get<0>(slice)[0].data() + banks_offsets[*n_banks_offsets - 1]);
@@ -349,6 +365,9 @@ std::tuple<bool, bool, bool> transpose_event(
     // Write sourceID
     banks_write[bank_offset] = b->sourceID();
 
+    // Store bank size
+    fragment_sizes[bank_counter - 1] = b->size();
+
     // Copy padded data
     auto const padded_size = b->totalSize() - b->hdrSize();
     // Write bank data