[ntuple] implement RSoAField::SplitValue()

Author: jblomer

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

@@ -22,6 +22,7 @@
 
 #include <cstddef>
 #include <memory>
+#include <mutex>
 #include <string_view>
 #include <typeinfo>
 #include <vector>
@@ -71,6 +72,13 @@ class RSoAField : public RFieldBase {
    std::size_t fMaxAlignment = 1;
    ROOT::Internal::RColumnIndex fNWritten;
 
+   /// For reading and writing, the RVecs of the SoA class do not have a dedicated field. The in-memory RVecs of the
+   /// SoA object are used directly with the subfields of the underlying record type. For splitting a SoA class object
+   /// (SplitValue()), however, we need actual RRVecFields so that we can recursively split the in-memory SoA value.
+   /// The split fields are created only when SplitField() is called.
+   mutable std::unique_ptr<std::vector<std::unique_ptr<ROOT::RRVecField>>> fSplitFields;
+   mutable std::unique_ptr<std::mutex> fLockSplitFields; ///< protects the fSplitFields member.
+
    RSoAField(std::string_view fieldName, const RSoAField &source); ///< Used by CloneImpl
    RSoAField(std::string_view fieldName, TClass *clSoA);
 

tree/ntuple/inc/ROOT/RFieldVisitor.hxx

@@ -236,6 +236,7 @@ public:
    void VisitNullableField(const ROOT::RNullableField &field) final;
    void VisitEnumField(const ROOT::REnumField &field) final;
    void VisitAtomicField(const ROOT::RAtomicField &field) final;
+   void VisitSoAField(const ROOT::Experimental::RSoAField &field) final;
 };
 
 // clang-format off

tree/ntuple/src/RFieldMeta.cxx

@@ -664,6 +664,7 @@ ROOT::Experimental::RSoAField::RSoAField(std::string_view fieldName, const RSoAF
    fRecordMemberFields = fSubfields[0]->GetMutableSubfields();
    for (const auto f : fRecordMemberFields)
       fRecordMemberDeleters.emplace_back(GetDeleterOf(*f));
+   fLockSplitFields = std::make_unique<std::mutex>();
 }
 
 ROOT::Experimental::RSoAField::RSoAField(std::string_view fieldName, std::string_view className)
@@ -774,6 +775,7 @@ ROOT::Experimental::RSoAField::RSoAField(std::string_view fieldName, TClass *clS
       fTypeAlias = renormalizedAlias;
 
    fTraits |= kTraitSoACollection | kTraitTypeChecksum;
+   fLockSplitFields = std::make_unique<std::mutex>();
 }
 
 std::unique_ptr<ROOT::RFieldBase> ROOT::Experimental::RSoAField::CloneImpl(std::string_view newName) const
@@ -878,10 +880,31 @@ void ROOT::Experimental::RSoAField::RSoADeleter::operator()(void *objPtr, bool d
    RDeleter::operator()(objPtr, dtorOnly);
 }
 
-std::vector<ROOT::RFieldBase::RValue> ROOT::Experimental::RSoAField::SplitValue(const RValue & /* value */) const
+std::vector<ROOT::RFieldBase::RValue> ROOT::Experimental::RSoAField::SplitValue(const RValue &value) const
 {
-   throw RException(R__FAIL("not yet implemented"));
-   return std::vector<RValue>();
+   const auto nSoAMembers = fSoAMemberOffsets.size();
+
+   {
+      std::lock_guard<std::mutex> lockGuard(*fLockSplitFields);
+      if (!fSplitFields) {
+         fSplitFields = std::make_unique<std::vector<std::unique_ptr<ROOT::RRVecField>>>();
+         fSplitFields->reserve(nSoAMembers);
+         for (std::size_t i = 0; i < nSoAMembers; ++i) {
+            const auto itemField = fRecordMemberFields[i];
+            fSplitFields->emplace_back(std::make_unique<RRVecField>(itemField->GetFieldName(), itemField->Clone("_0")));
+         }
+      }
+   }
+
+   auto valuePtr = value.GetPtr<void>();
+   auto soaPtr = static_cast<unsigned char *>(valuePtr.get());
+   std::vector<RValue> values;
+   values.reserve(nSoAMembers);
+   for (std::size_t i = 0; i < nSoAMembers; ++i) {
+      values.emplace_back(
+         (*fSplitFields)[i]->BindValue(std::shared_ptr<void>(valuePtr, soaPtr + fSoAMemberOffsets[i])));
+   }
+   return values;
 }
 
 size_t ROOT::Experimental::RSoAField::GetValueSize() const

tree/ntuple/src/RFieldVisitor.cxx

@@ -408,6 +408,11 @@ void ROOT::Internal::RPrintValueVisitor::VisitRVecField(const ROOT::RRVecField &
    PrintCollection(field);
 }
 
+void ROOT::Internal::RPrintValueVisitor::VisitSoAField(const ROOT::Experimental::RSoAField &field)
+{
+   PrintRecord(field);
+}
+
 //---------------------------- RNTupleFormatter --------------------------------
 
 std::string ROOT::Internal::RNTupleFormatter::FitString(const std::string &str, int availableSpace)

tree/ntuple/test/ntuple_soa.cxx

@@ -1,6 +1,7 @@
 #include <ROOT/RError.hxx>
 #include <ROOT/RField.hxx>
 #include <ROOT/RFieldUtils.hxx>
+#include <ROOT/RFieldVisitor.hxx>
 #include <ROOT/RNTupleModel.hxx>
 #include <ROOT/RNTupleReader.hxx>
 #include <ROOT/RNTupleView.hxx>
@@ -15,6 +16,7 @@
 #include <TVirtualStreamerInfo.h>
 
 #include <memory>
+#include <sstream>
 #include <utility>
 
 #include "gmock/gmock.h"
@@ -415,3 +417,54 @@ TEST(RNTuple, SoAFromVector)
                                "in-memory field simple of type SoASimple is incompatible with on-disk field simple"));
    }
 }
+
+TEST(RNTuple, SoAShow)
+{
+   ROOT::TestSupport::FileRaii fileGuard("test_rntuple_soa_show.root");
+
+   {
+      auto model = ROOT::RNTupleModel::Create();
+      model->AddField(std::make_unique<RSoAField>("simple", "SoASimple"));
+      model->AddField(std::make_unique<RSoAField>("empty", "SoA"));
+
+      auto writer = ROOT::RNTupleWriter::Recreate(std::move(model), "ntpl", fileGuard.GetPath());
+      auto simpleSoA = writer->GetModel().GetDefaultEntry().GetPtr<SoASimple>("simple");
+      auto emptySoA = writer->GetModel().GetDefaultEntry().GetPtr<SoA>("empty");
+
+      simpleSoA->fX.push_back(1.0);
+      simpleSoA->fY.push_back(2.0);
+      simpleSoA->fX.push_back(3.0);
+      simpleSoA->fY.push_back(4.0);
+      writer->Fill();
+
+      simpleSoA->fX.clear();
+      simpleSoA->fY.clear();
+      writer->Fill();
+   }
+
+   auto reader = ROOT::RNTupleReader::Open("ntpl", fileGuard.GetPath());
+
+   std::ostringstream os;
+   reader->Show(0, os);
+   reader->Show(1, os);
+
+   // clang-format off
+   std::string expected{
+R"({
+  "simple": {
+    "fX": [1, 3],
+    "fY": [2, 4]
+  },
+  "empty": {  }
+}
+{
+  "simple": {
+    "fX": [],
+    "fY": []
+  },
+  "empty": {  }
+}
+)" };
+   // clang-format on
+   EXPECT_EQ(expected, os.str());
+}