Logo ROOT  
Reference Guide
TStorage.h
Go to the documentation of this file.
1// @(#)root/base:$Id$
2// Author: Fons Rademakers 29/07/95
3
4/*************************************************************************
5 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6 * All rights reserved. *
7 * *
8 * For the licensing terms see $ROOTSYS/LICENSE. *
9 * For the list of contributors see $ROOTSYS/README/CREDITS. *
10 *************************************************************************/
11
12#ifndef ROOT_TStorage
13#define ROOT_TStorage
14
15
16//////////////////////////////////////////////////////////////////////////
17// //
18// TStorage //
19// //
20// Storage manager. //
21// //
22//////////////////////////////////////////////////////////////////////////
23
24#include "RConfigure.h"
25#include "Rtypes.h"
26
27typedef void (*FreeHookFun_t)(void*, void *addr, size_t);
28typedef void *(*ReAllocFun_t)(void*, size_t);
29typedef void *(*ReAllocCFun_t)(void*, size_t, size_t);
30typedef char *(*ReAllocCharFun_t)(char*, size_t, size_t);
31
32
33class TStorage {
34
35private:
36 static size_t fgMaxBlockSize; // largest block allocated
37 static FreeHookFun_t fgFreeHook; // function called on free
38 static void *fgFreeHookData; // data used by this function
39 static ReAllocFun_t fgReAllocHook; // custom ReAlloc
40 static ReAllocCFun_t fgReAllocCHook; // custom ReAlloc with length check
41 static Bool_t fgHasCustomNewDelete; // true if using ROOT's new/delete
42
43 //----- Private bits, clients can only test but not change them
44 enum {
45 kIsOnHeap = 0x01000000, ///< object is on heap
46 };
47
48public:
49 static const UInt_t kObjectAllocMemValue = 0x99999999;
50 // magic number for ObjectAlloc
51
52public:
53 virtual ~TStorage() { }
54
55 static ULong_t GetHeapBegin();
56 static ULong_t GetHeapEnd();
58 static void *GetFreeHookData();
59 static size_t GetMaxBlockSize();
60 static void *Alloc(size_t size);
61 static void Dealloc(void *ptr);
62 static void *ReAlloc(void *vp, size_t size);
63 static void *ReAlloc(void *vp, size_t size, size_t oldsize);
64 static char *ReAllocChar(char *vp, size_t size, size_t oldsize);
65 static Int_t *ReAllocInt(Int_t *vp, size_t size, size_t oldsize);
66 static void *ObjectAlloc(size_t size);
67 static void *ObjectAllocArray(size_t size);
68 static void *ObjectAlloc(size_t size, void *vp);
69 static void ObjectDealloc(void *vp);
70#ifdef R__SIZEDDELETE
71 static void ObjectDealloc(void *vp, size_t size);
72#endif
73 static void ObjectDealloc(void *vp, void *ptr);
74
75 static void EnterStat(size_t size, void *p);
76 static void RemoveStat(void *p);
77 static void PrintStatistics();
78 static void SetMaxBlockSize(size_t size);
79 static void SetFreeHook(FreeHookFun_t func, void *data);
80 static void SetReAllocHooks(ReAllocFun_t func1, ReAllocCFun_t func2);
81 static void SetCustomNewDelete();
82 static void EnableStatistics(int size= -1, int ix= -1);
83
85
86 // only valid after call to a TStorage allocating method
87 static void AddToHeap(ULong_t begin, ULong_t end);
88 static Bool_t IsOnHeap(void *p);
89
90 static Bool_t FilledByObjectAlloc(volatile const UInt_t* const member);
91 static void UpdateIsOnHeap(volatile const UInt_t &uniqueID, volatile UInt_t &bits);
92
93 ClassDef(TStorage,0) //Storage manager class
94};
95
96inline Bool_t TStorage::FilledByObjectAlloc(volatile const UInt_t *const member) {
97 //called by TObject's constructor to determine if object was created by call to new
98
99 // This technique is necessary as there is one stack per thread
100 // and we can not rely on comparison with the current stack memory position.
101 // Note that a false positive (this routine returning true for an object
102 // created on the stack) requires the previous stack value to have been
103 // set to exactly kObjectAllocMemValue at exactly the right position (i.e.
104 // where this object's fUniqueID is located.
105 // The consequence of a false positive will be visible if and only if
106 // the object is auto-added to a TDirectory (i.e. TTree, TH*, TGraph,
107 // TEventList) or explicitly added to the directory by the user
108 // and
109 // the TDirectory (or TFile) object is created on the stack *before*
110 // the object.
111 // The consequence would be that those objects would be deleted twice, once
112 // by the TDirectory and once automatically when going out of scope
113 // (and thus quite visible). A false negative (which is not posible with
114 // this implementation) would have been a silent memory leak.
115
116 // This will be reported by valgrind as uninitialized memory reads for
117 // object created on the stack, use $ROOTSYS/etc/valgrind-root.supp
119 return *member == kObjectAllocMemValue;
121}
122
123// Assign the kIsOnHeap bit in 'bits' based on the pattern seen in uniqueID.
124// See Storage::FilledByObjectAlloc for details.
125// This routine is marked as inline with attribute noinline so that it never
126// inlined and thus can be used in a valgrind suppression file to suppress
127// the known/intentional uninitialized memory read but still be a 'quick'
128// function call to avoid losing performance at object creation.
129// Moving the function into the source file, results in doubling of the
130// overhead (compared to inlining)
131R__NEVER_INLINE void TStorage::UpdateIsOnHeap(volatile const UInt_t &uniqueID, volatile UInt_t &bits) {
132 if (TStorage::FilledByObjectAlloc(&uniqueID))
133 bits |= kIsOnHeap;
134 else
135 bits &= ~kIsOnHeap;
136}
137
138
139inline size_t TStorage::GetMaxBlockSize() { return fgMaxBlockSize; }
140
141inline void TStorage::SetMaxBlockSize(size_t size) { fgMaxBlockSize = size; }
142
144
145namespace ROOT {
146namespace Internal {
147using FreeIfTMapFile_t = bool(void*);
150}
151}
152
153#endif
int Int_t
Definition: CPyCppyy.h:43
unsigned int UInt_t
Definition: CPyCppyy.h:44
unsigned long ULong_t
Definition: CPyCppyy.h:51
#define R__EXTERN
Definition: DllImport.h:27
#define R__INTENTIONALLY_UNINIT_END
Definition: RConfig.hxx:560
#define R__NEVER_INLINE
Definition: RConfig.hxx:582
#define R__INTENTIONALLY_UNINIT_BEGIN
Definition: RConfig.hxx:559
bool Bool_t
Definition: RtypesCore.h:61
#define ClassDef(name, id)
Definition: Rtypes.h:322
void *(* ReAllocFun_t)(void *, size_t)
Definition: TStorage.h:28
void(* FreeHookFun_t)(void *, void *addr, size_t)
Definition: TStorage.h:27
void *(* ReAllocCFun_t)(void *, size_t, size_t)
Definition: TStorage.h:29
typedef void((*Func_t)())
Storage manager.
Definition: TStorage.h:33
static ReAllocCFun_t fgReAllocCHook
Definition: TStorage.h:40
static void RemoveStat(void *p)
Register a memory free operation.
Definition: TStorage.cxx:129
static void * Alloc(size_t size)
Allocate a block of memory, that later can be resized using TStorage::ReAlloc().
Definition: TStorage.cxx:152
static Bool_t fgHasCustomNewDelete
Definition: TStorage.h:41
static char * ReAllocChar(char *vp, size_t size, size_t oldsize)
Reallocate (i.e.
Definition: TStorage.cxx:265
static FreeHookFun_t fgFreeHook
Definition: TStorage.h:37
static Bool_t HasCustomNewDelete()
return the has custom delete flag
Definition: TStorage.cxx:490
static void EnterStat(size_t size, void *p)
Register a memory allocation operation.
Definition: TStorage.cxx:99
static ULong_t GetHeapBegin()
Definition: TStorage.cxx:463
static void ObjectDealloc(void *vp)
Used to deallocate a TObject on the heap (via TObject::operator delete()).
Definition: TStorage.cxx:359
static void SetFreeHook(FreeHookFun_t func, void *data)
Set a free handler.
Definition: TStorage.cxx:387
static void SetCustomNewDelete()
set the has custom delete flag
Definition: TStorage.cxx:498
static void AddToHeap(ULong_t begin, ULong_t end)
add a range to the heap
Definition: TStorage.cxx:507
static ULong_t GetHeapEnd()
Definition: TStorage.cxx:472
static void * GetFreeHookData()
return static free hook data
Definition: TStorage.cxx:482
static void * ReAlloc(void *vp, size_t size)
Reallocate (i.e.
Definition: TStorage.cxx:183
static void SetMaxBlockSize(size_t size)
Definition: TStorage.h:141
static void * fgFreeHookData
Definition: TStorage.h:38
static Bool_t IsOnHeap(void *p)
is object at p in the heap?
Definition: TStorage.cxx:515
@ kIsOnHeap
object is on heap
Definition: TStorage.h:45
static const UInt_t kObjectAllocMemValue
Definition: TStorage.h:49
static void UpdateIsOnHeap(volatile const UInt_t &uniqueID, volatile UInt_t &bits)
Definition: TStorage.h:131
static void Dealloc(void *ptr)
De-allocate block of memory, that was allocated via TStorage::Alloc().
Definition: TStorage.cxx:170
static size_t fgMaxBlockSize
Definition: TStorage.h:36
static Int_t * ReAllocInt(Int_t *vp, size_t size, size_t oldsize)
Reallocate (i.e.
Definition: TStorage.cxx:295
static void SetReAllocHooks(ReAllocFun_t func1, ReAllocCFun_t func2)
Set a custom ReAlloc handlers.
Definition: TStorage.cxx:397
static void * ObjectAllocArray(size_t size)
Used to allocate array of TObject on the heap (via TObject::operator new[]()).
Definition: TStorage.cxx:340
static Bool_t FilledByObjectAlloc(volatile const UInt_t *const member)
Definition: TStorage.h:96
virtual ~TStorage()
Definition: TStorage.h:53
static void EnableStatistics(int size=-1, int ix=-1)
Enable memory usage statistics gathering.
Definition: TStorage.cxx:450
static ReAllocFun_t fgReAllocHook
Definition: TStorage.h:39
static size_t GetMaxBlockSize()
Definition: TStorage.h:139
static void * ObjectAlloc(size_t size)
Used to allocate a TObject on the heap (via TObject::operator new()).
Definition: TStorage.cxx:328
static void PrintStatistics()
Print memory usage statistics.
Definition: TStorage.cxx:406
static FreeHookFun_t GetFreeHook()
Definition: TStorage.h:143
R__EXTERN FreeIfTMapFile_t * gFreeIfTMapFile
Definition: TStorage.h:148
R__EXTERN void * gMmallocDesc
Definition: TStorage.h:149
bool(void *) FreeIfTMapFile_t
Definition: TStorage.h:147
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: RNumpyDS.hxx:30