[ntuple] use TClass alignment info where possible

Author: jblomer

tree/ntuple/inc/ROOT/RField.hxx

@@ -164,7 +164,6 @@ private:
    TClass *fClass;
    /// Additional information kept for each entry in `fSubfields`
    std::vector<RSubfieldInfo> fSubfieldsInfo;
-   std::size_t fMaxAlignment = 1;
 
    /// The staging area stores inputs to I/O rules according to the offsets given by the streamer info of
    /// "TypeName@@Version". The area is allocated depending on I/O rules resp. the source members of the I/O rules.
@@ -219,8 +218,8 @@ public:
    ~RClassField() override;
 
    std::vector<RValue> SplitValue(const RValue &value) const final;
-   size_t GetValueSize() const final;
-   size_t GetAlignment() const final { return fMaxAlignment; }
+   std::size_t GetValueSize() const final;
+   std::size_t GetAlignment() const final;
    std::uint32_t GetTypeVersion() const final;
    std::uint32_t GetTypeChecksum() const final;
    /// For polymorphic classes (that declare or inherit at least one virtual method), return the expected dynamic type

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

@@ -175,8 +175,8 @@ public:
    ~RProxiedCollectionField() override = default;
 
    std::vector<RValue> SplitValue(const RValue &value) const final;
-   size_t GetValueSize() const final { return fProxy->Sizeof(); }
-   size_t GetAlignment() const final { return alignof(std::max_align_t); }
+   std::size_t GetValueSize() const final;
+   std::size_t GetAlignment() const final;
    void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final;
 };
 

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

@@ -263,8 +263,8 @@ public:
    ~ROptionalField() override = default;
 
    std::vector<RValue> SplitValue(const RValue &value) const final;
-   size_t GetValueSize() const final;
-   size_t GetAlignment() const final;
+   std::size_t GetValueSize() const final;
+   std::size_t GetAlignment() const final;
 };
 
 template <typename ItemT>
@@ -312,8 +312,8 @@ public:
    ~RUniquePtrField() override = default;
 
    std::vector<RValue> SplitValue(const RValue &value) const final;
-   size_t GetValueSize() const final { return sizeof(std::unique_ptr<char>); }
-   size_t GetAlignment() const final { return alignof(std::unique_ptr<char>); }
+   std::size_t GetValueSize() const final { return sizeof(std::unique_ptr<char>); }
+   std::size_t GetAlignment() const final { return alignof(std::unique_ptr<char>); }
 };
 
 template <typename ItemT>
@@ -362,8 +362,8 @@ public:
    RField &operator=(RField &&other) = default;
    ~RField() final = default;
 
-   size_t GetValueSize() const final { return sizeof(std::string); }
-   size_t GetAlignment() const final { return std::alignment_of<std::string>(); }
+   std::size_t GetValueSize() const final { return sizeof(std::string); }
+   std::size_t GetAlignment() const final { return alignof(std::string); }
    void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final;
 };
 
@@ -435,8 +435,8 @@ public:
    RVariantField &operator=(RVariantField &&other) = default;
    ~RVariantField() override = default;
 
-   size_t GetValueSize() const final;
-   size_t GetAlignment() const final;
+   std::size_t GetValueSize() const final;
+   std::size_t GetAlignment() const final;
 };
 
 template <typename... ItemTs>

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

@@ -260,8 +260,8 @@ public:
    CreateUntyped(std::string_view fieldName, std::unique_ptr<RFieldBase> itemField);
 
    std::vector<RValue> SplitValue(const RValue &value) const final;
-   size_t GetValueSize() const final { return sizeof(std::vector<char>); }
-   size_t GetAlignment() const final { return std::alignment_of<std::vector<char>>(); }
+   std::size_t GetValueSize() const final;
+   std::size_t GetAlignment() const final;
    void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final;
 };
 
@@ -314,8 +314,8 @@ public:
 
    std::vector<RValue> SplitValue(const RValue &value) const final;
 
-   size_t GetValueSize() const final { return sizeof(std::vector<bool>); }
-   size_t GetAlignment() const final { return std::alignment_of<std::vector<bool>>(); }
+   std::size_t GetValueSize() const final { return sizeof(std::vector<bool>); }
+   std::size_t GetAlignment() const final { return alignof(std::vector<bool>); }
    void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final;
 };
 
@@ -409,8 +409,8 @@ public:
    RArrayAsVectorField &operator=(RArrayAsVectorField &&other) = default;
    ~RArrayAsVectorField() final = default;
 
-   size_t GetValueSize() const final { return sizeof(std::vector<char>); }
-   size_t GetAlignment() const final { return std::alignment_of<std::vector<char>>(); }
+   std::size_t GetValueSize() const final;
+   std::size_t GetAlignment() const final;
 
    std::vector<RFieldBase::RValue> SplitValue(const RFieldBase::RValue &value) const final;
    void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final;

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

@@ -66,7 +66,6 @@ class RSoAField : public RFieldBase {
    /// The offset of the RVec members in the SoA type in the order of subfields of the underlying record type.
    /// In particular, the order is not necessarily the same then the order of RVec members in the SoA class.
    std::vector<std::size_t> fSoAMemberOffsets;
-   std::size_t fMaxAlignment = 1;
    ROOT::Internal::RColumnIndex fNWritten;
 
    RSoAField(std::string_view fieldName, const RSoAField &source); ///< Used by CloneImpl
@@ -97,7 +96,7 @@ public:
 
    std::vector<RValue> SplitValue(const RValue &value) const final;
    size_t GetValueSize() const final;
-   size_t GetAlignment() const final { return fMaxAlignment; }
+   size_t GetAlignment() const final;
    std::uint32_t GetTypeVersion() const final;
    std::uint32_t GetTypeChecksum() const final;
    /// For polymorphic classes (that declare or inherit at least one virtual method), return the expected dynamic type

tree/ntuple/inc/ROOT/RFieldBase.hxx

@@ -555,6 +555,9 @@ protected:
           const ROOT::RNTupleDescriptor *desc, ROOT::DescriptorId_t fieldId);
 
 public:
+   /// Maximum supported alignment for field types, i.e. maximum returned by GetAlignment()
+   static constexpr std::size_t kMaxAlignment = 4096;
+
    template <bool IsConstT>
    class RSchemaIteratorTemplate;
    using RSchemaIterator = RSchemaIteratorTemplate<false>;
@@ -623,10 +626,9 @@ public:
    /// correct `std::variant` or all the elements of a collection. The default implementation assumes no subvalues
    /// and returns an empty vector.
    virtual std::vector<RValue> SplitValue(const RValue &value) const;
-   /// The number of bytes taken by a value of the appropriate type
+   /// What sizeof(T) for this type returns
    virtual size_t GetValueSize() const = 0;
-   /// As a rule of thumb, the alignment is equal to the size of the type. There are, however, various exceptions
-   /// to this rule depending on OS and CPU architecture. So enforce the alignment to be explicitly spelled out.
+   /// What alignof(T) for this type returns
    virtual size_t GetAlignment() const = 0;
    std::uint32_t GetTraits() const { return fTraits; }
    bool HasReadCallbacks() const { return !fReadCallbacks.empty(); }

tree/ntuple/src/RFieldMeta.cxx

@@ -14,6 +14,7 @@
 //  - RField<TObject>
 //  - RVariantField
 
+#include <ROOT/BitUtils.hxx>
 #include <ROOT/RField.hxx>
 #include <ROOT/RFieldBase.hxx>
 #include <ROOT/RFieldUtils.hxx>
@@ -116,6 +117,12 @@ TEnum *EnsureValidEnum(std::string_view enumName)
    return e;
 }
 
+void EnsureValidAlignment(std::size_t align)
+{
+   if (align == 0 || align > ROOT::RFieldBase::kMaxAlignment || !ROOT::Internal::IsPowerOfTwo(align))
+      throw ROOT::RException(R__FAIL(std::string("invalid alignment: ") + std::to_string(align)));
+}
+
 /// Create a comma-separated list of type names from the given fields. Uses either the real type names or the
 /// type aliases (if there are any, otherwise the actual type name). Used to construct template argument lists
 /// for templated types such as std::pair<...>, std::tuple<...>, std::variant<...>.
@@ -186,8 +193,7 @@ std::string BuildMapTypeName(ROOT::RMapField::EMapType mapType, const ROOT::RFie
 ROOT::RClassField::RClassField(std::string_view fieldName, const RClassField &source)
    : ROOT::RFieldBase(fieldName, source.GetTypeName(), ROOT::ENTupleStructure::kRecord, false /* isSimple */),
      fClass(source.fClass),
-     fSubfieldsInfo(source.fSubfieldsInfo),
-     fMaxAlignment(source.fMaxAlignment)
+     fSubfieldsInfo(source.fSubfieldsInfo)
 {
    for (const auto &f : source.GetConstSubfields()) {
       RFieldBase::Attach(f->Clone(f->GetFieldName()));
@@ -280,7 +286,6 @@ ROOT::RClassField::~RClassField()
 
 void ROOT::RClassField::Attach(std::unique_ptr<RFieldBase> child, RSubfieldInfo info)
 {
-   fMaxAlignment = std::max(fMaxAlignment, child->GetAlignment());
    fSubfieldsInfo.push_back(info);
    RFieldBase::Attach(std::move(child));
 }
@@ -622,11 +627,18 @@ std::vector<ROOT::RFieldBase::RValue> ROOT::RClassField::SplitValue(const RValue
    return result;
 }
 
-size_t ROOT::RClassField::GetValueSize() const
+std::size_t ROOT::RClassField::GetValueSize() const
 {
    return fClass->GetClassSize();
 }
 
+std::size_t ROOT::RClassField::GetAlignment() const
+{
+   const auto align = fClass->GetClassAlignment();
+   EnsureValidAlignment(align);
+   return align;
+}
+
 std::uint32_t ROOT::RClassField::GetTypeVersion() const
 {
    return fClass->GetClassVersion();
@@ -656,8 +668,7 @@ void ROOT::RClassField::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) cons
 ROOT::Experimental::RSoAField::RSoAField(std::string_view fieldName, const RSoAField &source)
    : ROOT::RFieldBase(fieldName, source.GetTypeName(), ROOT::ENTupleStructure::kCollection, false /* isSimple */),
      fSoAClass(source.fSoAClass),
-     fSoAMemberOffsets(source.fSoAMemberOffsets),
-     fMaxAlignment(source.fMaxAlignment)
+     fSoAMemberOffsets(source.fSoAMemberOffsets)
 {
    fTraits = source.GetTraits();
    Attach(source.fSubfields[0]->Clone(source.fSubfields[0]->GetFieldName()));
@@ -756,8 +767,6 @@ ROOT::Experimental::RSoAField::RSoAField(std::string_view fieldName, TClass *clS
                                   leftType + " vs. " + rightType + ")"));
       }
 
-      fMaxAlignment = std::max(fMaxAlignment, vecField->GetAlignment());
-
       assert(itr->second < fSoAMemberOffsets.size());
       fSoAMemberOffsets[itr->second] = dataMember->GetOffset();
       nMembers++;
@@ -862,7 +871,7 @@ std::vector<ROOT::RFieldBase::RValue> ROOT::Experimental::RSoAField::SplitValue(
    return std::vector<RValue>();
 }
 
-size_t ROOT::Experimental::RSoAField::GetValueSize() const
+std::size_t ROOT::Experimental::RSoAField::GetValueSize() const
 {
    return fSoAClass->GetClassSize();
 }
@@ -877,6 +886,13 @@ std::uint32_t ROOT::Experimental::RSoAField::GetTypeChecksum() const
    return fSoAClass->GetCheckSum();
 }
 
+std::size_t ROOT::Experimental::RSoAField::GetAlignment() const
+{
+   const auto align = fSoAClass->GetClassAlignment();
+   EnsureValidAlignment(align);
+   return align;
+}
+
 const std::type_info *ROOT::Experimental::RSoAField::GetPolymorphicTypeInfo() const
 {
    // TODO(jblomer): factor out
@@ -1197,6 +1213,18 @@ std::vector<ROOT::RFieldBase::RValue> ROOT::RProxiedCollectionField::SplitValue(
    return result;
 }
 
+std::size_t ROOT::RProxiedCollectionField::GetValueSize() const
+{
+   return fProxy->Sizeof();
+}
+
+std::size_t ROOT::RProxiedCollectionField::GetAlignment() const
+{
+   const auto align = fProxy->GetCollectionClass()->GetClassAlignment();
+   EnsureValidAlignment(align);
+   return align;
+}
+
 void ROOT::RProxiedCollectionField::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const
 {
    visitor.VisitProxiedCollectionField(*this);
@@ -1404,7 +1432,9 @@ ROOT::RExtraTypeInfoDescriptor ROOT::RStreamerField::GetExtraTypeInfo() const
 
 std::size_t ROOT::RStreamerField::GetAlignment() const
 {
-   return std::min(alignof(std::max_align_t), GetValueSize()); // TODO(jblomer): fix me
+   const auto align = fClass->GetClassAlignment();
+   EnsureValidAlignment(align);
+   return align;
 }
 
 std::size_t ROOT::RStreamerField::GetValueSize() const

tree/ntuple/src/RFieldSequenceContainer.cxx

@@ -2,6 +2,7 @@
 /// \author Jonas Hahnfeld <jonas.hahnfeld@cern.ch>
 /// \date 2024-11-19
 
+#include <ROOT/BitUtils.hxx>
 #include <ROOT/RField.hxx>
 #include <ROOT/RFieldBase.hxx>
 #include <ROOT/RFieldVisitor.hxx>
@@ -29,6 +30,20 @@ std::vector<ROOT::RFieldBase::RValue> SplitVector(std::shared_ptr<void> valuePtr
    return result;
 }
 
+std::size_t GetSizeOfVector()
+{
+   static_assert(sizeof(std::vector<char>) ==
+                 sizeof(std::vector<ROOT::Internal::RAlignedStorage<ROOT::RFieldBase::kMaxAlignment>>));
+   return sizeof(std::vector<char>);
+}
+
+std::size_t GetAlignOfVector()
+{
+   static_assert(alignof(std::vector<char>) ==
+                 alignof(std::vector<ROOT::Internal::RAlignedStorage<ROOT::RFieldBase::kMaxAlignment>>));
+   return alignof(std::vector<char>);
+}
+
 } // anonymous namespace
 
 ROOT::RArrayField::RArrayField(std::string_view fieldName, std::unique_ptr<RFieldBase> itemField,
@@ -647,6 +662,16 @@ std::vector<ROOT::RFieldBase::RValue> ROOT::RVectorField::SplitValue(const RValu
    return SplitVector(value.GetPtr<void>(), *fSubfields[0]);
 }
 
+std::size_t ROOT::RVectorField::GetValueSize() const
+{
+   return GetSizeOfVector();
+}
+
+std::size_t ROOT::RVectorField::GetAlignment() const
+{
+   return GetAlignOfVector();
+}
+
 void ROOT::RVectorField::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const
 {
    visitor.VisitVectorField(*this);
@@ -973,6 +998,16 @@ std::vector<ROOT::RFieldBase::RValue> ROOT::RArrayAsVectorField::SplitValue(cons
    return SplitVector(value.GetPtr<void>(), *fSubfields[0]);
 }
 
+std::size_t ROOT::RArrayAsVectorField::GetValueSize() const
+{
+   return GetSizeOfVector();
+}
+
+std::size_t ROOT::RArrayAsVectorField::GetAlignment() const
+{
+   return GetAlignOfVector();
+}
+
 void ROOT::RArrayAsVectorField::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const
 {
    visitor.VisitArrayAsVectorField(*this);

tree/ntuple/test/CMakeLists.txt

@@ -11,7 +11,7 @@ ROOT_STANDARD_LIBRARY_PACKAGE(CustomStruct
                               HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/CustomStruct.hxx
                               SOURCES CustomStruct.cxx
                               LINKDEF CustomStructLinkDef.h
-                              DEPENDENCIES RIO)
+                              DEPENDENCIES RIO ROOTVecOps)
 configure_file(CustomStruct.hxx . COPYONLY)
 if(MSVC AND NOT CMAKE_GENERATOR MATCHES Ninja)
   add_custom_command(TARGET CustomStruct POST_BUILD

tree/ntuple/test/CustomStruct.hxx

@@ -1,11 +1,14 @@
 #ifndef ROOT_RNTuple_Test_CustomStruct
 #define ROOT_RNTuple_Test_CustomStruct
 
+#include <ROOT/RVec.hxx>
+
 #include <RtypesCore.h> // for Double32_t
 #include <TObject.h>
 #include <TRootIOCtor.h>
 #include <TVirtualCollectionProxy.h>
 
+#include <array>
 #include <chrono>
 #include <stdexcept>
 #include <cstddef>
@@ -478,4 +481,20 @@ struct MemberWithCustomStreamer {
    ClassDefNV(MemberWithCustomStreamer, 2);
 };
 
+struct AlignmentDeterminedByTransientMember {
+   short int fA;
+   float fTransient; ///<!
+};
+
+struct alignas(8) AlignedAs {};
+
+struct alignas(64) OverAligned {
+   std::uint32_t fA;
+};
+
+struct AlignmentEnvelope {
+   ROOT::RVec<OverAligned> fVec;
+   std::array<OverAligned, 2> fArr;
+};
+
 #endif