[ntuple] optimize bulk read for RVec of array of PoD

Author: jblomer

tree/ntuple/inc/ROOT/RField/RFieldSequenceContainer.hxx

@@ -143,6 +143,11 @@ protected:
    ROOT::Internal::RColumnIndex fNWritten;
    std::size_t fValueSize;
 
+   // For bulk read optimzation
+   std::size_t fBulkNRepetition = 1;
+   /// May be a direct PoD subfield or a sub-subfield of a fixed-size array of PoD
+   RFieldBase *fBulkSubfield = nullptr;
+
    std::unique_ptr<RFieldBase> CloneImpl(std::string_view newName) const final;
    const RColumnRepresentations &GetColumnRepresentations() const final;
    void GenerateColumns() final;

tree/ntuple/src/RFieldSequenceContainer.cxx

@@ -237,6 +237,19 @@ ROOT::RRVecField::RRVecField(std::string_view fieldName, std::unique_ptr<RFieldB
       fItemDeleter = GetDeleterOf(*itemField);
    Attach(std::move(itemField));
    fValueSize = EvalRVecValueSize(fSubfields[0]->GetAlignment(), fSubfields[0]->GetValueSize(), GetAlignment());
+
+   // Determine if we can optimimize bulk reading
+   if (fSubfields[0]->IsSimple()) {
+      fBulkSubfield = fSubfields[0].get();
+   } else {
+      if (auto f = dynamic_cast<RArrayField *>(fSubfields[0].get())) {
+         auto grandChildFields = fSubfields[0]->GetMutableSubfields();
+         if (grandChildFields[0]->IsSimple()) {
+            fBulkSubfield = grandChildFields[0];
+            fBulkNRepetition = f->GetLength();
+         }
+      }
+   }
 }
 
 std::unique_ptr<ROOT::RFieldBase> ROOT::RRVecField::CloneImpl(std::string_view newName) const
@@ -351,14 +364,14 @@ void ROOT::RRVecField::ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to)
 
 std::size_t ROOT::RRVecField::ReadBulkImpl(const RBulkSpec &bulkSpec)
 {
-   if (!fSubfields[0]->IsSimple())
+   if (!fBulkSubfield)
       return RFieldBase::ReadBulkImpl(bulkSpec);
 
    if (bulkSpec.fAuxData->empty()) {
       /// Initialize auxiliary memory: the first sizeof(size_t) bytes store the value size of the item field.
       /// The following bytes store the item values, consecutively.
       bulkSpec.fAuxData->resize(sizeof(std::size_t));
-      *reinterpret_cast<std::size_t *>(bulkSpec.fAuxData->data()) = fSubfields[0]->GetValueSize();
+      *reinterpret_cast<std::size_t *>(bulkSpec.fAuxData->data()) = fBulkNRepetition * fBulkSubfield->GetValueSize();
    }
    const auto itemValueSize = *reinterpret_cast<std::size_t *>(bulkSpec.fAuxData->data());
    unsigned char *itemValueArray = bulkSpec.fAuxData->data() + sizeof(std::size_t);
@@ -410,7 +423,8 @@ std::size_t ROOT::RRVecField::ReadBulkImpl(const RBulkSpec &bulkSpec)
       }
    }
 
-   GetPrincipalColumnOf(*fSubfields[0])->ReadV(firstItemIndex, nItems, itemValueArray - delta);
+   GetPrincipalColumnOf(*fBulkSubfield)
+      ->ReadV(firstItemIndex * fBulkNRepetition, nItems * fBulkNRepetition, itemValueArray - delta);
    return RBulkSpec::kAllSet;
 }
 

tree/ntuple/test/ntuple_bulk.cxx

@@ -151,21 +151,25 @@ TEST(RNTupleBulk, RVec)
    FileRaii fileGuard("test_ntuple_bulk_rvec.root");
    {
       auto model = RNTupleModel::Create();
-      auto fldVecI = model->MakeField<ROOT::RVecI>("vint");
-      auto fldVecS = model->MakeField<ROOT::RVec<CustomStruct>>("vs");
-      auto fldVecVI = model->MakeField<ROOT::RVec<ROOT::RVecI>>("vvint");
+      auto ptrVecI = model->MakeField<ROOT::RVecI>("vint");
+      auto ptrVecS = model->MakeField<ROOT::RVec<CustomStruct>>("vs");
+      auto ptrVecVI = model->MakeField<ROOT::RVec<ROOT::RVecI>>("vvint");
+      auto ptrVecArrI = model->MakeField<ROOT::RVec<std::array<int, 2>>>("varrint");
       auto writer = RNTupleWriter::Recreate(std::move(model), "ntpl", fileGuard.GetPath());
       for (int i = 0; i < 10; ++i) {
-         fldVecI->resize(i);
-         fldVecS->resize(i);
-         fldVecVI->resize(i);
+         ptrVecI->resize(i);
+         ptrVecS->resize(i);
+         ptrVecVI->resize(i);
+         ptrVecArrI->resize(i);
          for (int j = 0; j < i; ++j) {
-            fldVecI->at(j) = j;
-            fldVecS->at(j).a = j;
-            fldVecVI->at(j).resize(j);
+            ptrVecI->at(j) = j;
+            ptrVecS->at(j).a = j;
+            ptrVecVI->at(j).resize(j);
             for (int k = 0; k < j; ++k) {
-               fldVecVI->at(j).at(k) = k;
+               ptrVecVI->at(j).at(k) = k;
             }
+            ptrVecArrI->at(j).at(0) = 1000 * i + 2 * j;
+            ptrVecArrI->at(j).at(1) = 1000 * i + 2 * j + 1;
          }
          writer->Fill();
       }
@@ -177,6 +181,7 @@ TEST(RNTupleBulk, RVec)
    RFieldBase::RBulkValues bulkI = model.CreateBulk("vint");
    RFieldBase::RBulkValues bulkS = model.CreateBulk("vs");
    RFieldBase::RBulkValues bulkVI = model.CreateBulk("vvint");
+   RFieldBase::RBulkValues bulkVArrI = model.CreateBulk("varrint");
 
    auto mask = std::make_unique<bool[]>(10);
    std::fill(mask.get(), mask.get() + 10, true);
@@ -185,12 +190,17 @@ TEST(RNTupleBulk, RVec)
    auto iArr = static_cast<ROOT::RVecI *>(bulkI.ReadBulk(RNTupleLocalIndex(0, 0), mask.get(), 10));
    auto sArr = static_cast<ROOT::RVec<CustomStruct> *>(bulkS.ReadBulk(RNTupleLocalIndex(0, 0), mask.get(), 10));
    auto viArr = static_cast<ROOT::RVec<ROOT::RVecI> *>(bulkVI.ReadBulk(RNTupleLocalIndex(0, 0), mask.get(), 10));
+   auto arriArr =
+      static_cast<ROOT::RVec<std::array<int, 2>> *>(bulkVArrI.ReadBulk(RNTupleLocalIndex(0, 0), mask.get(), 10));
    for (int i = 0; i < 10; ++i) {
       EXPECT_EQ(i, iArr[i].size());
+      EXPECT_EQ(i, arriArr[i].size());
       EXPECT_EQ(i == 1 ? 0 : i, sArr[i].size());
       EXPECT_EQ(i == 1 ? 0 : i, viArr[i].size());
-      for (std::size_t j = 0; j < iArr[i].size(); ++j) {
+      for (int j = 0; j < i; ++j) {
          EXPECT_EQ(j, iArr[i].at(j));
+         EXPECT_EQ(1000 * i + 2 * j, arriArr[i].at(j).at(0));
+         EXPECT_EQ(1000 * i + 2 * j + 1, arriArr[i].at(j).at(1));
       }
       // RVec<PoD> should have all the vector elements of the bulk stored consecutively in memory
       if (i > 1) {