Draft Support for Very Large Collection

core/base/inc/TBuffer.h

@@ -45,10 +45,12 @@ class TBuffer : public TObject {
 
 protected:
    typedef std::vector<TVirtualArray*> CacheList_t;
+   // FIXME: decide if this is signed or unsigned.
+   using Size_t = std::size_t;
 
    Bool_t           fMode;          //Read or write mode
    Int_t            fVersion;       //Buffer format version
-   Int_t            fBufSize;       //Size of buffer
+   Size_t           fBufSize;       //Size of buffer
    char            *fBuffer;        //Buffer used to store objects
    char            *fBufCur;        //Current position in buffer
    char            *fBufMax;        //End of buffer
@@ -88,29 +90,29 @@ class TBuffer : public TObject {
    enum { kInitialSize = 1024, kMinimalSize = 128 };
 
    TBuffer(EMode mode);
-   TBuffer(EMode mode, Long64_t bufsize);
-   TBuffer(EMode mode, Long64_t bufsize, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = nullptr);
+   TBuffer(EMode mode, ULong64_t bufsize);
+   TBuffer(EMode mode, ULong64_t bufsize, void *buf, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = nullptr);
    virtual ~TBuffer();
 
    Int_t    GetBufferVersion() const { return fVersion; }
    Bool_t   IsReading() const { return (fMode & kWrite) == 0; }
    Bool_t   IsWriting() const { return (fMode & kWrite) != 0; }
    void     SetReadMode();
    void     SetWriteMode();
-   void     SetBuffer(void *buf, Long64_t bufsize = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = nullptr);
+   void     SetBuffer(void *buf, ULong64_t bufsize = 0, Bool_t adopt = kTRUE, ReAllocCharFun_t reallocfunc = nullptr);
    ReAllocCharFun_t GetReAllocFunc() const;
    void     SetReAllocFunc(ReAllocCharFun_t reallocfunc = nullptr);
-   void     SetBufferOffset(Long64_t offset = 0) { fBufCur = fBuffer+offset; }
+   void     SetBufferOffset(ULong64_t offset = 0) { fBufCur = fBuffer+offset; }
    void     SetParent(TObject *parent);
    TObject *GetParent()  const;
    char    *Buffer()     const { return fBuffer; }
    char    *GetCurrent() const { return fBufCur; }
-   Int_t    BufferSize() const { return fBufSize; }
+   Size_t   BufferSize() const { return fBufSize; }
    void     DetachBuffer() { fBuffer = nullptr; }
-   Int_t    Length()     const { return (Int_t)(fBufCur - fBuffer); }
-   void     Expand(Long64_t newsize, Bool_t copy = kTRUE);  // expand buffer to newsize
-   void     AutoExpand(Long64_t size_needed);  // expand buffer to newsize
-   Bool_t   ByteSwapBuffer(Long64_t n, EDataType type);  // Byte-swap N primitive-elements in the buffer
+   Size_t   Length()     const { return (Size_t)(fBufCur - fBuffer); }
+   void     Expand(ULong64_t newsize, Bool_t copy = kTRUE);  // expand buffer to newsize
+   void     AutoExpand(ULong64_t size_needed);  // expand buffer to newsize
+   Bool_t   ByteSwapBuffer(ULong64_t n, EDataType type);  // Byte-swap N primitive-elements in the buffer
 
    virtual Bool_t     CheckObject(const TObject *obj) = 0;
    virtual Bool_t     CheckObject(const void *obj, const TClass *ptrClass) = 0;
@@ -320,7 +322,7 @@ class TBuffer : public TObject {
    virtual   void     ReadFastArray(ULong_t   *l, Int_t n) = 0;
    virtual   void     ReadFastArray(Long64_t  *l, Int_t n) = 0;
    virtual   void     ReadFastArray(ULong64_t *l, Int_t n) = 0;
-   virtual   void     ReadFastArray(Float_t   *f, Int_t n) = 0;
+   virtual   void     ReadFastArray(Float_t   *f, Long64_t n) = 0;
    virtual   void     ReadFastArray(Double_t  *d, Int_t n) = 0;
    virtual   void     ReadFastArrayFloat16(Float_t  *f, Int_t n, TStreamerElement *ele = nullptr) = 0;
    virtual   void     ReadFastArrayDouble32(Double_t  *d, Int_t n, TStreamerElement *ele = nullptr) = 0;

core/base/src/TBuffer.cxx

@@ -19,8 +19,9 @@ Buffer base class used for serializing objects.
 #include "TClass.h"
 #include "TProcessID.h"
 
-constexpr Int_t kExtraSpace    = 8;   // extra space at end of buffer (used for free block count)
-constexpr Int_t kMaxBufferSize  = 0x7FFFFFFE;  // largest possible size.
+constexpr UInt_t kExtraSpace    = 8;   // extra space at end of buffer (used for free block count)
+constexpr UInt_t kMaxBufferSize = 0x7FFFFFFE;  // largest possible size before we need to switch to the large buffer format (see TBufferFile::SetByteCount).
+constexpr ULong64_t kMaxLargeBufferSize  = 0x7FFFFFFFFFFFFFFE;  // largest possible size.
 
 
 
@@ -69,7 +70,7 @@ TBuffer::TBuffer(EMode mode)
 /// Create an I/O buffer object. Mode should be either TBuffer::kRead or
 /// TBuffer::kWrite.
 
-TBuffer::TBuffer(EMode mode, Long64_t bufsize)
+TBuffer::TBuffer(EMode mode, ULong64_t bufsize)
 {
    if (bufsize > kMaxBufferSize)
       Fatal("TBuffer","Request to create a too large buffer: 0x%llx for a max of 0x%x.", bufsize, kMaxBufferSize);
@@ -100,23 +101,31 @@ TBuffer::TBuffer(EMode mode, Long64_t bufsize)
 /// is provided, a Fatal error will be issued if the Buffer attempts to
 /// expand.
 
-TBuffer::TBuffer(EMode mode, Long64_t bufsize, void *buf, Bool_t adopt, ReAllocCharFun_t reallocfunc)
+TBuffer::TBuffer(EMode mode, ULong64_t bufsize, void *buf, Bool_t adopt, ReAllocCharFun_t reallocfunc)
 {
-   if (bufsize > kMaxBufferSize)
-      Fatal("TBuffer","Request to create a too large buffer: 0x%llx for a max of 0x%x.", bufsize, kMaxBufferSize);
+   if (bufsize > kMaxLargeBufferSize)
+      Fatal("TBuffer","Request to create a too large buffer: 0x%llx for a max of 0x%llx.", bufsize, kMaxLargeBufferSize);
    fBufSize  = bufsize;
    fMode     = mode;
    fVersion  = 0;
    fParent   = nullptr;
 
    SetBit(kIsOwner);
 
+   if (buf && !adopt)
+      ResetBit(kIsOwner);
+
+   SetReAllocFunc( reallocfunc );
+
    if (buf) {
       fBuffer = (char *)buf;
       if ( (fMode&kWrite)!=0 ) {
-         fBufSize -= kExtraSpace;
+         if (fBufSize < kExtraSpace) {
+            Expand( kMinimalSize );
+         } else {
+            fBufSize -= kExtraSpace;
+         }
       }
-      if (!adopt) ResetBit(kIsOwner);
    } else {
       if (fBufSize < kMinimalSize) {
          fBufSize = kMinimalSize;
@@ -125,12 +134,6 @@ TBuffer::TBuffer(EMode mode, Long64_t bufsize, void *buf, Bool_t adopt, ReAllocC
    }
    fBufCur = fBuffer;
    fBufMax = fBuffer + fBufSize;
-
-   SetReAllocFunc( reallocfunc );
-
-   if (buf && ( (fMode&kWrite)!=0 ) && fBufSize < 0) {
-      Expand( kMinimalSize );
-   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -154,15 +157,15 @@ TBuffer::~TBuffer()
 /// If the size_needed is larger than the current size, the policy
 /// is to expand to double the current size or the size_needed which ever is largest.
 
-void TBuffer::AutoExpand(Long64_t size_needed)
+void TBuffer::AutoExpand(ULong64_t size_needed)
 {
-   if (size_needed > kMaxBufferSize) {
-      Fatal("AutoExpand","Request to expand a too large buffer: 0x%llx for a max of 0x%x.", size_needed, kMaxBufferSize);
+   if (size_needed > kMaxLargeBufferSize) {
+      Fatal("AutoExpand","Request to expand a too large buffer: 0x%llx for a max of 0x%llx.", size_needed, kMaxLargeBufferSize);
    }
    if (size_needed > fBufSize) {
-      Long64_t doubling = 2LLU * fBufSize;
-      if (doubling > kMaxBufferSize)
-         doubling = kMaxBufferSize;
+      ULong64_t doubling = 2LLU * fBufSize;
+      if (doubling > kMaxLargeBufferSize)
+         doubling = kMaxLargeBufferSize;
       if (size_needed > doubling) {
          Expand(size_needed);
       } else {
@@ -183,7 +186,7 @@ void TBuffer::AutoExpand(Long64_t size_needed)
 /// is provided, a Fatal error will be issued if the Buffer attempts to
 /// expand.
 
-void TBuffer::SetBuffer(void *buf, Long64_t newsiz, Bool_t adopt, ReAllocCharFun_t reallocfunc)
+void TBuffer::SetBuffer(void *buf, ULong64_t newsiz, Bool_t adopt, ReAllocCharFun_t reallocfunc)
 {
    if (newsiz > kMaxBufferSize)
       Fatal("SetBuffer","Request to create a too large buffer: 0x%llx for a max of 0x%x.", newsiz, kMaxBufferSize);
@@ -195,22 +198,22 @@ void TBuffer::SetBuffer(void *buf, Long64_t newsiz, Bool_t adopt, ReAllocCharFun
    else
       ResetBit(kIsOwner);
 
+   SetReAllocFunc( reallocfunc );
+
    fBuffer = (char *)buf;
    fBufCur = fBuffer;
    if (newsiz > 0) {
       if ( (fMode&kWrite)!=0 ) {
-         fBufSize = newsiz - kExtraSpace;
+         if (newsiz >= kExtraSpace) {
+            fBufSize = newsiz - kExtraSpace;
+         } else {
+            Expand( kMinimalSize );
+         }
       } else {
          fBufSize = newsiz;
       }
    }
    fBufMax = fBuffer + fBufSize;
-
-   SetReAllocFunc( reallocfunc );
-
-   if (buf && ( (fMode&kWrite)!=0 ) && fBufSize < 0) {
-      Expand( kMinimalSize );
-   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -221,22 +224,23 @@ void TBuffer::SetBuffer(void *buf, Long64_t newsiz, Bool_t adopt, ReAllocCharFun
 /// In order to avoid losing data, if the current length is greater than
 /// the requested size, we only shrink down to the current length.
 
-void TBuffer::Expand(Long64_t newsize, Bool_t copy)
+void TBuffer::Expand(ULong64_t newsize, Bool_t copy)
 {
-   Int_t l  = Length();
-   if ( (Long64_t(l) > newsize) && copy ) {
+   ULong64_t l  = Length();
+   if ( l > newsize && copy ) {
       newsize = l;
    }
-   const Int_t extraspace = (fMode&kWrite)!=0 ? kExtraSpace : 0;
+   const ULong64_t extraspace = (fMode&kWrite)!=0 ? kExtraSpace : 0;
 
-   if ( newsize > kMaxBufferSize - kExtraSpace) {
-      if (l < kMaxBufferSize) {
-         newsize = kMaxBufferSize - extraspace;
+   if ( newsize > kMaxLargeBufferSize - kExtraSpace) {
+      if (l < kMaxLargeBufferSize) {
+         newsize = kMaxLargeBufferSize - extraspace;
       } else {
-         Fatal("Expand","Requested size (%lld) is too large (max is %d).", newsize, kMaxBufferSize);
+         Fatal("Expand","Requested size (%llu) is too large (max is %llu).", newsize, kMaxLargeBufferSize);
       }
    }
    if ( (fMode&kWrite)!=0 ) {
+      // FIXME-LARGE: The size can overflow and the signature of fReAllocFunc is not large enough to handle the size of the buffer.
       fBuffer  = fReAllocFunc(fBuffer, newsize+kExtraSpace,
                               copy ? fBufSize+kExtraSpace : 0);
    } else {
@@ -390,13 +394,13 @@ TVirtualArray *TBuffer::PopDataCache()
 /// Byte-swap N primitive-elements in the buffer.
 /// Bulk API relies on this function.
 
-Bool_t TBuffer::ByteSwapBuffer(Long64_t n, EDataType type)
+Bool_t TBuffer::ByteSwapBuffer(ULong64_t n, EDataType type)
 {
    char *input_buf = GetCurrent();
    if ((type == EDataType::kShort_t) || (type == EDataType::kUShort_t)) {
 #ifdef R__BYTESWAP
       Short_t *buf __attribute__((aligned(8))) = reinterpret_cast<Short_t*>(input_buf);
-      for (int idx=0; idx<n; idx++) {
+      for (unsigned int idx=0; idx<n; idx++) {
          Short_t tmp = *reinterpret_cast<Short_t*>(buf + idx); // Makes a copy of the values; frombuf can't handle aliasing.
          char *tmp_ptr = reinterpret_cast<char *>(&tmp);
          frombuf(tmp_ptr, buf + idx);
@@ -405,7 +409,7 @@ Bool_t TBuffer::ByteSwapBuffer(Long64_t n, EDataType type)
    } else if ((type == EDataType::kFloat_t) || (type == EDataType::kInt_t) || (type == EDataType::kUInt_t)) {
 #ifdef R__BYTESWAP
       Float_t *buf __attribute__((aligned(8))) = reinterpret_cast<Float_t*>(input_buf);
-      for (int idx=0; idx<n; idx++) {
+      for (unsigned int idx=0; idx<n; idx++) {
          Float_t tmp = *reinterpret_cast<Float_t*>(buf + idx); // Makes a copy of the values; frombuf can't handle aliasing.
          char *tmp_ptr = reinterpret_cast<char *>(&tmp);
          frombuf(tmp_ptr, buf + idx);
@@ -414,7 +418,7 @@ Bool_t TBuffer::ByteSwapBuffer(Long64_t n, EDataType type)
    } else if ((type == EDataType::kDouble_t) || (type == EDataType::kLong64_t) || (type == EDataType::kULong64_t)) {
 #ifdef R__BYTESWAP
       Double_t *buf __attribute__((aligned(8))) = reinterpret_cast<Double_t*>(input_buf);
-      for (int idx=0; idx<n; idx++) {
+      for (unsigned int idx=0; idx<n; idx++) {
          Double_t tmp = *reinterpret_cast<Double_t*>(buf + idx); // Makes a copy of the values; frombuf can't handle aliasing.
          char *tmp_ptr = reinterpret_cast<char*>(&tmp);
          frombuf(tmp_ptr, buf + idx);

core/cont/inc/TVirtualCollectionProxy.h

@@ -71,6 +71,8 @@ class TVirtualCollectionProxy {
       kCustomAlloc = BIT(5) ///< The collection has a custom allocator.
    };
 
+   using size_type = ULong64_t;
+
    /// RAII helper class that ensures that `PushProxy()` / `PopProxy()` are called when entering / leaving a C++ context
    class TPushPop {
    public:
@@ -123,19 +125,19 @@ class TVirtualCollectionProxy {
    }
 
    /// Construct an array of `nElements` container objects and return the base address of the array
-   virtual void *NewArray(Int_t nElements) const { return !fClass.GetClass() ? nullptr : fClass->NewArray(nElements); }
+   virtual void *NewArray(Long64_t nElements) const { return !fClass.GetClass() ? nullptr : fClass->NewArray(nElements); }
    /// Construct an array of `nElements` container objects at the address given by `arena`
-   virtual void *NewArray(Int_t nElements, void *arena) const
+   virtual void *NewArray(Long64_t nElements, void *arena) const
    {
       return !fClass.GetClass() ? nullptr : fClass->NewArray(nElements, arena);
    }
    /// Construct an array of `nElements` container objects and return the base address of the array
-   virtual TClass::ObjectPtr NewObjectArray(Int_t nElements) const
+   virtual TClass::ObjectPtr NewObjectArray(Long64_t nElements) const
    {
       return !fClass.GetClass() ? TClass::ObjectPtr{} : fClass->NewObjectArray(nElements);
    }
    /// Construct an array of `nElements` container objects at the address given by `arena`
-   virtual TClass::ObjectPtr NewObjectArray(Int_t nElements, void *arena) const
+   virtual TClass::ObjectPtr NewObjectArray(Long64_t nElements, void *arena) const
    {
       return !fClass.GetClass() ? TClass::ObjectPtr{} : fClass->NewObjectArray(nElements, arena);
    }
@@ -155,7 +157,7 @@ class TVirtualCollectionProxy {
    }
 
    /// Return the `sizeof()` of the collection object
-   virtual UInt_t Sizeof() const = 0;
+   virtual size_type Sizeof() const = 0;
 
    /// Set the address of the container being proxied and keep track of the previous one
    virtual void PushProxy(void *objectstart) = 0;
@@ -174,19 +176,19 @@ class TVirtualCollectionProxy {
    virtual EDataType GetType() const = 0;
 
    /// Return the address of the value at index `idx`
-   virtual void *At(UInt_t idx) = 0;
+   virtual void *At(size_type idx) = 0;
 
    /// Clear the container
    virtual void Clear(const char *opt = "") = 0;
 
    /// Return the current number of elements in the container
-   virtual UInt_t Size() const = 0;
+   virtual size_type Size() const = 0;
 
    /// Allocates space for storing at least `n` elements.  This function returns a pointer to the actual object on
    /// which insertions should take place.  For associative collections, this function returns a pointer to a temporary
    /// buffer known as the staging area.  If the insertion happened in a staging area (i.e. the returned pointer !=
    /// proxied object), `Commit()` should be called on the value returned by this function.
-   virtual void*     Allocate(UInt_t n, Bool_t forceDelete) = 0;
+   virtual void*     Allocate(size_type n, Bool_t forceDelete) = 0;
 
    /// Commits pending elements in a staging area (see Allocate() for more information).
    virtual void      Commit(void*) = 0;
@@ -196,7 +198,7 @@ class TVirtualCollectionProxy {
    virtual void Insert(const void *data, void *container, size_t size) = 0;
 
    /// Return the address of the value at index `idx`
-   char *operator[](UInt_t idx) const { return (char *)(const_cast<TVirtualCollectionProxy *>(this))->At(idx); }
+   char *operator[](size_type idx) const { return (char *)(const_cast<TVirtualCollectionProxy *>(this))->At(idx); }
 
    // Functions related to member-wise actions
    virtual TStreamerInfoActions::TActionSequence *GetConversionReadMemberWiseActions(TClass *oldClass, Int_t version) = 0;

core/meta/inc/TClass.h

@@ -541,12 +541,12 @@ friend class TStreamerInfo;
    void               Move(void *arenaFrom, void *arenaTo) const;
    void              *New(ENewType defConstructor = kClassNew, Bool_t quiet = kFALSE) const;
    void              *New(void *arena, ENewType defConstructor = kClassNew) const;
-   void              *NewArray(Long_t nElements, ENewType defConstructor = kClassNew) const;
-   void              *NewArray(Long_t nElements, void *arena, ENewType defConstructor = kClassNew) const;
+   void              *NewArray(Long64_t nElements, ENewType defConstructor = kClassNew) const;
+   void              *NewArray(Long64_t nElements, void *arena, ENewType defConstructor = kClassNew) const;
    ObjectPtr          NewObject(ENewType defConstructor = kClassNew, Bool_t quiet = kFALSE) const;
    ObjectPtr          NewObject(void *arena, ENewType defConstructor = kClassNew) const;
-   ObjectPtr          NewObjectArray(Long_t nElements, ENewType defConstructor = kClassNew) const;
-   ObjectPtr          NewObjectArray(Long_t nElements, void *arena, ENewType defConstructor = kClassNew) const;
+   ObjectPtr          NewObjectArray(Long64_t nElements, ENewType defConstructor = kClassNew) const;
+   ObjectPtr          NewObjectArray(Long64_t nElements, void *arena, ENewType defConstructor = kClassNew) const;
    virtual void       PostLoadCheck();
    Long_t             Property() const override;
    Int_t              ReadBuffer(TBuffer &b, void *pointer, Int_t version, UInt_t start, UInt_t count);

core/meta/src/TClass.cxx

@@ -5245,8 +5245,9 @@ TClass::ObjectPtr TClass::NewObject(void *arena, ENewType defConstructor) const
 /// The class must have a default constructor. For meaning of
 /// defConstructor, see TClass::IsCallingNew().
 
-void *TClass::NewArray(Long_t nElements, ENewType defConstructor) const
+void *TClass::NewArray(Long64_t nElements, ENewType defConstructor) const
 {
+   R__ASSERT(nElements >= 0 && "Possible corruption of the heap: negative number of elements requested in TClass::NewObjectArray");
    auto obj = NewObjectArray(nElements, defConstructor);
    if (obj.GetPtr() && obj.GetAllocator()) {
       // Register the object for special handling in the destructor.
@@ -5261,8 +5262,9 @@ void *TClass::NewArray(Long_t nElements, ENewType defConstructor) const
 /// The class must have a default constructor. For meaning of
 /// defConstructor, see TClass::IsCallingNew().
 
-TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, ENewType defConstructor) const
+TClass::ObjectPtr TClass::NewObjectArray(Long64_t nElements, ENewType defConstructor) const
 {
+   R__ASSERT(nElements >= 0 && "Possible corruption of the heap: negative number of elements requested in TClass::NewObjectArray");
    ObjectPtr p;
 
    if (fNewArray) {
@@ -5347,8 +5349,9 @@ TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, ENewType defConstruct
 /// The class must have a default constructor. For meaning of
 /// defConstructor, see TClass::IsCallingNew().
 
-void *TClass::NewArray(Long_t nElements, void *arena, ENewType defConstructor) const
+void *TClass::NewArray(Long64_t nElements, void *arena, ENewType defConstructor) const
 {
+   R__ASSERT(nElements >= 0 && "Possible corruption of the heap: negative number of elements requested in TClass::NewObjectArray");
    auto obj = NewObjectArray(nElements, arena, defConstructor);
    if (obj.GetPtr() && obj.GetAllocator()) {
       // Register the object for special handling in the destructor.
@@ -5362,8 +5365,9 @@ void *TClass::NewArray(Long_t nElements, void *arena, ENewType defConstructor) c
 /// The class must have a default constructor. For meaning of
 /// defConstructor, see TClass::IsCallingNew().
 
-TClass::ObjectPtr TClass::NewObjectArray(Long_t nElements, void *arena, ENewType defConstructor) const
+TClass::ObjectPtr TClass::NewObjectArray(Long64_t nElements, void *arena, ENewType defConstructor) const
 {
+   R__ASSERT(nElements >= 0 && "Possible corruption of the heap: negative number of elements requested in TClass::NewObjectArray");
    ObjectPtr p;
 
    if (fNewArray) {