fix failing tests

Author: aalkin

Framework/Core/include/Framework/ArrowTableSlicingCache.h

@@ -21,8 +21,6 @@ namespace o2::framework
 using ListVector = std::vector<std::vector<int64_t>>;
 
 struct SliceInfoPtr {
-  gsl::span<int const> values;
-  gsl::span<int64_t const> counts;
   std::vector<int64_t> const* offsets;
   std::vector<int64_t> const* sizes;
 

Framework/Core/include/Framework/GroupSlicer.h

@@ -246,9 +246,7 @@ struct GroupSlicer {
         pos = position;
       }
       // optimized split
-      auto oc = sliceInfos[index].getSliceFor(pos);
-      uint64_t offset = oc.first;
-      auto count = oc.second;
+      auto [offset, count] = sliceInfos[index].getSliceFor(pos);
       auto groupedElementsTable = originalTable.rawSlice(offset, offset + count - 1);
       groupedElementsTable.bindInternalIndicesTo(&originalTable);
       return groupedElementsTable;

Framework/Core/src/ArrowTableSlicingCache.cxx

@@ -32,7 +32,10 @@ void updatePairList(Cache& list, std::string const& binding, std::string const&
 std::pair<int64_t, int64_t> SliceInfoPtr::getSliceFor(int value) const
 {
   int64_t offset = 0;
-  if (values.empty()) {
+  if ((*offsets).empty()) {
+    return {offset, 0};
+  }
+  if ((size_t)value > (*offsets).size()) {
     return {offset, 0};
   }
 
@@ -117,7 +120,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
   values[pos] = std::make_shared<arrow::NumericArray<arrow::Int32Type>>(pair.field(0)->data());
   counts[pos] = std::make_shared<arrow::NumericArray<arrow::Int64Type>>(pair.field(1)->data());
 
-  int maxValue = 0;
+  int maxValue = -1;
   for (auto i = values[pos]->length() - 1; i >= 0; --i) {
     if (values[pos]->Value(i) < 0) {
       continue;
@@ -128,7 +131,7 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
   }
 
   offsets[pos].resize(maxValue + 1);
-  sizes[pos].resize(maxValue);
+  sizes[pos].resize(maxValue + 1);
   std::fill(offsets[pos].begin(), offsets[pos].end(), 0);
   std::fill(sizes[pos].begin(), sizes[pos].end(), 0);
   int64_t offset = 0;
@@ -140,7 +143,6 @@ arrow::Status ArrowTableSlicingCache::updateCacheEntry(int pos, std::shared_ptr<
     }
     offset += counts[pos]->Value(i);
   }
-  offsets[pos][maxValue] = offset;
   return arrow::Status::OK();
 }
 
@@ -237,16 +239,12 @@ SliceInfoPtr ArrowTableSlicingCache::getCacheForPos(int pos) const
 {
   if (values[pos] == nullptr && counts[pos] == nullptr) {
     return {
-      {},//
-      {},//
       nullptr, //
       nullptr //
     };
   }
 
   return {
-    {reinterpret_cast<int const*>(values[pos]->values()->data()), static_cast<size_t>(values[pos]->length())},     //
-    {reinterpret_cast<int64_t const*>(counts[pos]->values()->data()), static_cast<size_t>(counts[pos]->length())}, //
     &(offsets[pos]),                                                                                               //
     &(sizes[pos])                                                                                                  //
   };

Framework/Core/test/test_GroupSlicer.cxx

@@ -260,21 +260,19 @@ TEST_CASE("GroupSlicerMismatchedGroups")
   auto s = slices.updateCacheEntry(0, trkTable);
   o2::framework::GroupSlicer g(e, tt, slices);
 
-  auto count = 0;
   for (auto& slice : g) {
     auto as = slice.associatedTables();
     auto gg = slice.groupingElement();
-    REQUIRE(gg.globalIndex() == count);
+    REQUIRE(gg.globalIndex() == (int64_t)slice.position);
     auto trks = std::get<aod::TrksX>(as);
-    if (count == 3 || count == 10 || count == 12 || count == 16 || count == 19) {
+    if (slice.position == 3 || slice.position == 10 || slice.position == 12 || slice.position == 16 || slice.position == 19) {
       REQUIRE(trks.size() == 0);
     } else {
       REQUIRE(trks.size() == 10);
     }
     for (auto& trk : trks) {
-      REQUIRE(trk.eventId() == count);
+      REQUIRE(trk.eventId() == (int64_t)slice.position);
     }
-    ++count;
   }
 }
 
@@ -510,7 +508,7 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
 {
   TableBuilder builderE;
   auto evtsWriter = builderE.cursor<aod::Events>();
-  for (auto i = 0; i < 20; ++i) {
+  for (auto i = 0; i < 10; ++i) {
     evtsWriter(0, i, 0.5f * i, 2.f * i, 3.f * i);
   }
   auto evtTable = builderE.finalize();
@@ -523,13 +521,12 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
   std::uniform_int_distribution<> distrib(0, 99);
 
   for (auto i = 0; i < 100; ++i) {
-
     filler[0] = distrib(gen);
     filler[1] = distrib(gen);
     if (filler[0] > filler[1]) {
       std::swap(filler[0], filler[1]);
     }
-    partsWriter(0, std::floor(i / 10.), i, filler);
+    partsWriter(0, std::floor( i / 10.), i, filler);
   }
   auto partsTable = builderP.finalize();
 
@@ -541,7 +538,6 @@ TEST_CASE("GroupSlicerMismatchedUnsortedFilteredGroupsWithSelfIndex")
   auto thingsTable = builderT.finalize();
 
   aod::Events e{evtTable};
-  // aod::Parts p{partsTable};
   aod::Things t{thingsTable};
   using FilteredParts = soa::Filtered<aod::Parts>;
   auto size = distrib(gen);