Logo ROOT  
Reference Guide
RPageStorage.hxx
Go to the documentation of this file.
1 /// \file ROOT/RPageStorage.hxx
2 /// \ingroup NTuple ROOT7
3 /// \author Jakob Blomer <jblomer@cern.ch>
4 /// \date 2018-07-19
5 /// \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback
6 /// is welcome!
7 
8 /*************************************************************************
9  * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers. *
10  * All rights reserved. *
11  * *
12  * For the licensing terms see $ROOTSYS/LICENSE. *
13  * For the list of contributors see $ROOTSYS/README/CREDITS. *
14  *************************************************************************/
15 
16 #ifndef ROOT7_RPageStorage
17 #define ROOT7_RPageStorage
18 
20 #include <ROOT/RNTupleOptions.hxx>
21 #include <ROOT/RNTupleUtil.hxx>
22 #include <ROOT/RPage.hxx>
23 #include <ROOT/RPageAllocator.hxx>
24 #include <ROOT/RStringView.hxx>
25 
26 #include <atomic>
27 #include <cstddef>
28 #include <functional>
29 #include <memory>
30 #include <unordered_set>
31 
32 namespace ROOT {
33 namespace Experimental {
34 
35 class RNTupleModel;
36 // TODO(jblomer): factory methods to create tree sinks and sources outside Detail namespace
37 
38 namespace Detail {
39 
40 class RCluster;
41 class RColumn;
42 class RPagePool;
43 class RFieldBase;
44 class RNTupleMetrics;
45 
46 enum class EPageStorageType {
47  kSink,
48  kSource,
49 };
50 
51 // clang-format off
52 /**
53 \class ROOT::Experimental::Detail::RPageStorage
54 \ingroup NTuple
55 \brief Common functionality of an ntuple storage for both reading and writing
56 
57 The RPageStore provides access to a storage container that keeps the bits of pages and clusters comprising
58 an ntuple. Concrete implementations can use a TFile, a raw file, an object store, and so on.
59 */
60 // clang-format on
61 class RPageStorage {
62 public:
63  /// The interface of a task scheduler to schedule page (de)compression tasks
65  public:
66  virtual ~RTaskScheduler() = default;
67  /// Start a new set of tasks
68  virtual void Reset() = 0;
69  /// Take a callable that represents a task
70  virtual void AddTask(const std::function<void(void)> &taskFunc) = 0;
71  /// Blocks until all scheduled tasks finished
72  virtual void Wait() = 0;
73  };
74 
75 protected:
76  std::string fNTupleName;
78 
79 public:
81  RPageStorage(const RPageStorage &other) = delete;
82  RPageStorage& operator =(const RPageStorage &other) = delete;
83  RPageStorage(RPageStorage &&other) = default;
84  RPageStorage& operator =(RPageStorage &&other) = default;
85  virtual ~RPageStorage();
86 
87  /// Whether the concrete implementation is a sink or a source
88  virtual EPageStorageType GetType() = 0;
89 
90  struct RColumnHandle {
92  const RColumn *fColumn = nullptr;
93 
94  /// Returns true for a valid column handle; fColumn and fId should always either both
95  /// be valid or both be invalid.
96  operator bool() const { return fId != kInvalidDescriptorId && fColumn; }
97  };
98  /// The column handle identifies a column with the current open page storage
100 
101  /// Register a new column. When reading, the column must exist in the ntuple on disk corresponding to the meta-data.
102  /// When writing, every column can only be attached once.
103  virtual ColumnHandle_t AddColumn(DescriptorId_t fieldId, const RColumn &column) = 0;
104  /// Unregisters a column. A page source decreases the reference counter for the corresponding active column.
105  /// For a page sink, dropping columns is currently a no-op.
106  virtual void DropColumn(ColumnHandle_t columnHandle) = 0;
107 
108  /// Every page store needs to be able to free pages it handed out. But Sinks and sources have different means
109  /// of allocating pages.
110  virtual void ReleasePage(RPage &page) = 0;
111 
112  /// Returns an empty metrics. Page storage implementations usually have their own metrics.
113  virtual RNTupleMetrics &GetMetrics();
114 
115  void SetTaskScheduler(RTaskScheduler *taskScheduler) { fTaskScheduler = taskScheduler; }
116 };
117 
118 // clang-format off
119 /**
120 \class ROOT::Experimental::Detail::RPageSink
121 \ingroup NTuple
122 \brief Abstract interface to write data into an ntuple
123 
124 The page sink takes the list of columns and afterwards a series of page commits and cluster commits.
125 The user is responsible to commit clusters at a consistent point, i.e. when all pages corresponding to data
126 up to the given entry number are committed.
127 */
128 // clang-format on
129 class RPageSink : public RPageStorage {
130 protected:
132 
133  /// Building the ntuple descriptor while writing is done in the same way for all the storage sink implementations.
134  /// Field, column, cluster ids and page indexes per cluster are issued sequentially starting with 0
139  /// Keeps track of the number of elements in the currently open cluster. Indexed by column id.
140  std::vector<RClusterDescriptor::RColumnRange> fOpenColumnRanges;
141  /// Keeps track of the written pages in the currently open cluster. Indexed by column id.
142  std::vector<RClusterDescriptor::RPageRange> fOpenPageRanges;
144 
145  virtual void CreateImpl(const RNTupleModel &model) = 0;
146  virtual RClusterDescriptor::RLocator CommitPageImpl(ColumnHandle_t columnHandle, const RPage &page) = 0;
148  virtual void CommitDatasetImpl() = 0;
149 
150 public:
151  RPageSink(std::string_view ntupleName, const RNTupleWriteOptions &options);
152 
153  RPageSink(const RPageSink&) = delete;
154  RPageSink& operator=(const RPageSink&) = delete;
155  RPageSink(RPageSink&&) = default;
157  virtual ~RPageSink();
158 
159  /// Guess the concrete derived page source from the file name (location)
160  static std::unique_ptr<RPageSink> Create(std::string_view ntupleName, std::string_view location,
161  const RNTupleWriteOptions &options = RNTupleWriteOptions());
163 
164  ColumnHandle_t AddColumn(DescriptorId_t fieldId, const RColumn &column) final;
165  void DropColumn(ColumnHandle_t /*columnHandle*/) final {}
166 
167  /// Physically creates the storage container to hold the ntuple (e.g., a keys a TFile or an S3 bucket)
168  /// To do so, Create() calls CreateImpl() after updating the descriptor.
169  /// Create() associates column handles to the columns referenced by the model
170  void Create(RNTupleModel &model);
171  /// Write a page to the storage. The column must have been added before.
172  void CommitPage(ColumnHandle_t columnHandle, const RPage &page);
173  /// Finalize the current cluster and create a new one for the following data.
174  void CommitCluster(NTupleSize_t nEntries);
175  /// Finalize the current cluster and the entrire data set.
177 
178  /// Get a new, empty page for the given column that can be filled with up to nElements. If nElements is zero,
179  /// the page sink picks an appropriate size.
180  virtual RPage ReservePage(ColumnHandle_t columnHandle, std::size_t nElements = 0) = 0;
181 };
182 
183 // clang-format off
184 /**
185 \class ROOT::Experimental::Detail::RPageSource
186 \ingroup NTuple
187 \brief Abstract interface to read data from an ntuple
188 
189 The page source is initialized with the columns of interest. Pages from those columns can then be
190 mapped into memory. The page source also gives access to the ntuple's meta-data.
191 */
192 // clang-format on
193 class RPageSource : public RPageStorage {
194 public:
195  /// Derived from the model (fields) that are actually being requested at a given point in time
196  using ColumnSet_t = std::unordered_set<DescriptorId_t>;
197 
198 protected:
201  /// The active columns are implicitly defined by the model fields or views
203 
205  // Only called if a task scheduler is set. No-op be default.
206  virtual void UnzipClusterImpl(RCluster * /* cluster */)
207  { }
208 
209 public:
211  RPageSource(const RPageSource&) = delete;
212  RPageSource& operator=(const RPageSource&) = delete;
213  RPageSource(RPageSource&&) = default;
215  virtual ~RPageSource();
216  /// Guess the concrete derived page source from the file name (location)
217  static std::unique_ptr<RPageSource> Create(std::string_view ntupleName, std::string_view location,
218  const RNTupleReadOptions &options = RNTupleReadOptions());
219  /// Open the same storage multiple time, e.g. for reading in multiple threads
220  virtual std::unique_ptr<RPageSource> Clone() const = 0;
221 
223  const RNTupleDescriptor &GetDescriptor() const { return fDescriptor; }
224  ColumnHandle_t AddColumn(DescriptorId_t fieldId, const RColumn &column) final;
225  void DropColumn(ColumnHandle_t columnHandle) final;
226 
227  /// Open the physical storage container for the tree
228  void Attach() { fDescriptor = AttachImpl(); }
231  ColumnId_t GetColumnId(ColumnHandle_t columnHandle);
232 
233  /// Allocates and fills a page that contains the index-th element
234  virtual RPage PopulatePage(ColumnHandle_t columnHandle, NTupleSize_t globalIndex) = 0;
235  /// Another version of PopulatePage that allows to specify cluster-relative indexes
236  virtual RPage PopulatePage(ColumnHandle_t columnHandle, const RClusterIndex &clusterIndex) = 0;
237 
238  /// Populates all the pages of the given cluster id and columns; it is possible that some columns do not
239  /// contain any pages. The pages source may load more columns than the minimal necessary set from `columns`.
240  /// To indicate which columns have been loaded, LoadCluster() must mark them with SetColumnAvailable().
241  /// That includes the ones from the `columns` that don't have pages; otherwise subsequent requests
242  /// for the cluster would assume an incomplete cluster and trigger loading again.
243  /// LoadCluster() is typically called from the I/O thread of a cluster pool, i.e. the method runs
244  /// concurrently to other methods of the page source.
245  virtual std::unique_ptr<RCluster> LoadCluster(DescriptorId_t clusterId, const ColumnSet_t &columns) = 0;
246 
247  /// Parallel decompression and unpacking of the pages in the given cluster. The unzipped pages are supposed
248  /// to be preloaded in a page pool attached to the source. The method is triggered by the cluster pool's
249  /// unzip thread. It is an optional optimization, the method can safely do nothing. In particular, the
250  /// actual implementation will only run if a task scheduler is set. In practice, a task scheduler is set
251  /// if implicit multi-threading is turned on.
252  void UnzipCluster(RCluster *cluster);
253 };
254 
255 } // namespace Detail
256 
257 } // namespace Experimental
258 } // namespace ROOT
259 
260 #endif
ROOT::Experimental::RNTupleWriteOptions
Common user-tunable settings for storing ntuples.
Definition: RNTupleOptions.hxx:46
ROOT::Experimental::Detail::RPageStorage::~RPageStorage
virtual ~RPageStorage()
Definition: RPageStorage.cxx:38
ROOT::Experimental::Detail::RPageSource::~RPageSource
virtual ~RPageSource()
Definition: RPageStorage.cxx:57
ROOT::Experimental::Detail::RPageSource::AttachImpl
virtual RNTupleDescriptor AttachImpl()=0
ROOT::Experimental::Detail::RPageStorage::RPageStorage
RPageStorage(const RPageStorage &other)=delete
ROOT::Experimental::Detail::RPage
A page is a slice of a column that is mapped into memory.
Definition: RPage.hxx:41
ROOT::Experimental::Detail::RPageSource::UnzipClusterImpl
virtual void UnzipClusterImpl(RCluster *)
Definition: RPageStorage.hxx:206
ROOT::Experimental::Detail::RNTupleMetrics
A collection of Counter objects with a name, a unit, and a description.
Definition: RNTupleMetrics.hxx:285
ROOT::Experimental::Detail::RPageStorage::RTaskScheduler
The interface of a task scheduler to schedule page (de)compression tasks.
Definition: RPageStorage.hxx:64
ROOT::Experimental::Detail::RPageSource::Create
static std::unique_ptr< RPageSource > Create(std::string_view ntupleName, std::string_view location, const RNTupleReadOptions &options=RNTupleReadOptions())
Guess the concrete derived page source from the file name (location)
Definition: RPageStorage.cxx:61
ROOT::Experimental::Detail::RPageSink::CommitPage
void CommitPage(ColumnHandle_t columnHandle, const RPage &page)
Write a page to the storage. The column must have been added before.
Definition: RPageStorage.cxx:175
ROOT::Experimental::Detail::RPageSink::RPageSink
RPageSink(RPageSink &&)=default
ROOT::Experimental::DescriptorId_t
std::uint64_t DescriptorId_t
Distriniguishes elements of the same type within a descriptor, e.g. different fields.
Definition: RNTupleUtil.hxx:91
ROOT::Experimental::Detail::RPageStorage
Common functionality of an ntuple storage for both reading and writing.
Definition: RPageStorage.hxx:61
RPage.hxx
ROOT::Experimental::Detail::RPageSource::fActiveColumns
ColumnSet_t fActiveColumns
The active columns are implicitly defined by the model fields or views.
Definition: RPageStorage.hxx:202
ROOT::Experimental::Detail::RPageSink::DropColumn
void DropColumn(ColumnHandle_t) final
Unregisters a column.
Definition: RPageStorage.hxx:165
string_view
basic_string_view< char > string_view
Definition: libcpp_string_view.h:785
ROOT::Experimental::Detail::RPageSource::AddColumn
ColumnHandle_t AddColumn(DescriptorId_t fieldId, const RColumn &column) final
Register a new column.
Definition: RPageStorage.cxx:68
ROOT::Experimental::Detail::RPageSink::fOpenPageRanges
std::vector< RClusterDescriptor::RPageRange > fOpenPageRanges
Keeps track of the written pages in the currently open cluster. Indexed by column id.
Definition: RPageStorage.hxx:142
ROOT::Experimental::Detail::RPageStorage::RTaskScheduler::Reset
virtual void Reset()=0
Start a new set of tasks.
ROOT::Experimental::Detail::RPageSink::fLastClusterId
DescriptorId_t fLastClusterId
Definition: RPageStorage.hxx:137
ROOT::Experimental::Detail::RPageStorage::SetTaskScheduler
void SetTaskScheduler(RTaskScheduler *taskScheduler)
Definition: RPageStorage.hxx:115
ROOT::Experimental::Detail::RPageSource::ColumnSet_t
std::unordered_set< DescriptorId_t > ColumnSet_t
Derived from the model (fields) that are actually being requested at a given point in time.
Definition: RPageStorage.hxx:196
ROOT::Experimental::RNTupleDescriptorBuilder
A helper class for piece-wise construction of an RNTupleDescriptor.
Definition: RNTupleDescriptor.hxx:616
ROOT::Experimental::Detail::RPageSink::CommitPageImpl
virtual RClusterDescriptor::RLocator CommitPageImpl(ColumnHandle_t columnHandle, const RPage &page)=0
ROOT::Experimental::Detail::RPageStorage::fTaskScheduler
RTaskScheduler * fTaskScheduler
Definition: RPageStorage.hxx:77
ROOT::Experimental::Detail::RPageSink::fDescriptorBuilder
RNTupleDescriptorBuilder fDescriptorBuilder
Definition: RPageStorage.hxx:143
ROOT::Experimental::NTupleSize_t
std::uint64_t NTupleSize_t
Integer type long enough to hold the maximum number of entries in a column.
Definition: RNTupleUtil.hxx:55
ROOT::Experimental::RNTupleReadOptions
Common user-tunable settings for reading ntuples.
Definition: RNTupleOptions.hxx:71
ROOT::Experimental::Detail::RPageStorage::fNTupleName
std::string fNTupleName
Definition: RPageStorage.hxx:76
ROOT::Experimental::Detail::RPageSource
Abstract interface to read data from an ntuple.
Definition: RPageStorage.hxx:193
ROOT::Experimental::Detail::RPageSink::fLastColumnId
DescriptorId_t fLastColumnId
Definition: RPageStorage.hxx:136
ROOT::Experimental::Detail::EPageStorageType::kSource
@ kSource
ROOT::Experimental::Detail::RPageSource::Attach
void Attach()
Open the physical storage container for the tree.
Definition: RPageStorage.hxx:228
ROOT::Experimental::Detail::RPageSink::RPageSink
RPageSink(const RPageSink &)=delete
ROOT::Experimental::Detail::RPageStorage::RColumnHandle::fColumn
const RColumn * fColumn
Definition: RPageStorage.hxx:92
bool
ROOT::Experimental::Detail::RPageSource::Clone
virtual std::unique_ptr< RPageSource > Clone() const =0
Open the same storage multiple time, e.g. for reading in multiple threads.
RFieldBase
A field translates read and write calls from/to underlying columns to/from tree values.
Definition: RField.hxx:59
ROOT::Experimental::Detail::RPageSource::PopulatePage
virtual RPage PopulatePage(ColumnHandle_t columnHandle, const RClusterIndex &clusterIndex)=0
Another version of PopulatePage that allows to specify cluster-relative indexes.
ROOT::Experimental::Detail::RPageStorage::RPageStorage
RPageStorage(std::string_view name)
Definition: RPageStorage.cxx:34
ROOT::Experimental::RNTupleDescriptor
The on-storage meta-data of an ntuple.
Definition: RNTupleDescriptor.hxx:279
ROOT::Experimental::Detail::RPageStorage::ColumnHandle_t
RColumnHandle ColumnHandle_t
The column handle identifies a column with the current open page storage.
Definition: RPageStorage.hxx:99
ROOT::Experimental::Detail::RPageSink::fLastFieldId
DescriptorId_t fLastFieldId
Building the ntuple descriptor while writing is done in the same way for all the storage sink impleme...
Definition: RPageStorage.hxx:135
ROOT::Experimental::Detail::RPageSource::GetNElements
NTupleSize_t GetNElements(ColumnHandle_t columnHandle)
Definition: RPageStorage.cxx:87
ROOT::Experimental::Detail::RPageSink::AddColumn
ColumnHandle_t AddColumn(DescriptorId_t fieldId, const RColumn &column) final
Register a new column.
Definition: RPageStorage.cxx:124
ROOT::Experimental::Detail::RPageSource::RPageSource
RPageSource(std::string_view ntupleName, const RNTupleReadOptions &fOptions)
Definition: RPageStorage.cxx:52
ROOT::Experimental::Detail::RPageSink::CommitClusterImpl
virtual RClusterDescriptor::RLocator CommitClusterImpl(NTupleSize_t nEntries)=0
ROOT::Experimental::Detail::RPageSink::operator=
RPageSink & operator=(const RPageSink &)=delete
ROOT::Experimental::Detail::EPageStorageType
EPageStorageType
Definition: RPageStorage.hxx:46
RStringView.hxx
ROOT::Experimental::Detail::RPageSource::RPageSource
RPageSource(const RPageSource &)=delete
ROOT::Experimental::Detail::RPageSource::GetDescriptor
const RNTupleDescriptor & GetDescriptor() const
Definition: RPageStorage.hxx:223
ROOT::R::function
void function(const Char_t *name_, T fun, const Char_t *docstring=0)
Definition: RExports.h:151
ROOT::Experimental::Detail::RPageStorage::RColumnHandle
Definition: RPageStorage.hxx:90
ROOT::Experimental::Detail::RPageStorage::RPageStorage
RPageStorage(RPageStorage &&other)=default
ROOT::Experimental::RNTupleModel
The RNTupleModel encapulates the schema of an ntuple.
Definition: RNTupleModel.hxx:46
ROOT::Experimental::Detail::RPageSource::RPageSource
RPageSource(RPageSource &&)=default
ROOT::Experimental::Detail::RPageSink::Create
static std::unique_ptr< RPageSink > Create(std::string_view ntupleName, std::string_view location, const RNTupleWriteOptions &options=RNTupleWriteOptions())
Guess the concrete derived page source from the file name (location)
Definition: RPageStorage.cxx:117
ROOT::Experimental::Detail::RPageSink::CreateImpl
virtual void CreateImpl(const RNTupleModel &model)=0
ROOT::Experimental::Detail::RPageSink::operator=
RPageSink & operator=(RPageSink &&)=default
ROOT::Experimental::Detail::RPageSink
Abstract interface to write data into an ntuple.
Definition: RPageStorage.hxx:129
ROOT::Experimental::Detail::RPageStorage::GetType
virtual EPageStorageType GetType()=0
Whether the concrete implementation is a sink or a source.
RNTupleUtil.hxx
ROOT::Experimental::Detail::RPageSink::RPageSink
RPageSink(std::string_view ntupleName, const RNTupleWriteOptions &options)
Definition: RPageStorage.cxx:108
ROOT::Experimental::RClusterIndex
Addresses a column element or field item relative to a particular cluster, instead of a global NTuple...
Definition: RNTupleUtil.hxx:95
ROOT::Experimental::Detail::RPageSource::GetNEntries
NTupleSize_t GetNEntries()
Definition: RPageStorage.cxx:82
ROOT::Experimental::Detail::RPageSource::DropColumn
void DropColumn(ColumnHandle_t columnHandle) final
Unregisters a column.
Definition: RPageStorage.cxx:77
ROOT::Experimental::Detail::RPageSource::GetColumnId
ColumnId_t GetColumnId(ColumnHandle_t columnHandle)
Definition: RPageStorage.cxx:92
RPageAllocator.hxx
ROOT::Experimental::Detail::RPageStorage::operator=
RPageStorage & operator=(const RPageStorage &other)=delete
ROOT::Experimental::Detail::RPageStorage::ReleasePage
virtual void ReleasePage(RPage &page)=0
Every page store needs to be able to free pages it handed out.
ROOT::Experimental::Detail::RPageSource::fDescriptor
RNTupleDescriptor fDescriptor
Definition: RPageStorage.hxx:200
ROOT::Experimental::Detail::RColumn
Definition: RColumn.hxx:43
ROOT::Experimental::Detail::RPageSink::CommitCluster
void CommitCluster(NTupleSize_t nEntries)
Finalize the current cluster and create a new one for the following data.
Definition: RPageStorage.cxx:188
ROOT::Experimental::RClusterDescriptor::RLocator
Generic information about the physical location of data.
Definition: RNTupleDescriptor.hxx:160
name
char name[80]
Definition: TGX11.cxx:110
ROOT::Experimental::Detail::RPageSink::fOptions
RNTupleWriteOptions fOptions
Definition: RPageStorage.hxx:131
ROOT::Experimental::Detail::RPageStorage::RColumnHandle::fId
DescriptorId_t fId
Definition: RPageStorage.hxx:91
ROOT::Experimental::Detail::RPageSource::UnzipCluster
void UnzipCluster(RCluster *cluster)
Parallel decompression and unpacking of the pages in the given cluster.
Definition: RPageStorage.cxx:98
make_cnn_model.model
model
Definition: make_cnn_model.py:6
ROOT::Experimental::Detail::RPageSink::ReservePage
virtual RPage ReservePage(ColumnHandle_t columnHandle, std::size_t nElements=0)=0
Get a new, empty page for the given column that can be filled with up to nElements.
ROOT::Experimental::kInvalidDescriptorId
constexpr DescriptorId_t kInvalidDescriptorId
Definition: RNTupleUtil.hxx:92
ROOT::Experimental::Detail::RPageStorage::RTaskScheduler::~RTaskScheduler
virtual ~RTaskScheduler()=default
ROOT::Experimental::Detail::RPageSink::GetType
EPageStorageType GetType() final
Whether the concrete implementation is a sink or a source.
Definition: RPageStorage.hxx:162
ROOT::Experimental::Detail::RPageSink::CommitDatasetImpl
virtual void CommitDatasetImpl()=0
RColumn
A column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into ...
ROOT::Experimental::Detail::RPageSource::PopulatePage
virtual RPage PopulatePage(ColumnHandle_t columnHandle, NTupleSize_t globalIndex)=0
Allocates and fills a page that contains the index-th element.
ROOT::Experimental::Detail::RPageStorage::AddColumn
virtual ColumnHandle_t AddColumn(DescriptorId_t fieldId, const RColumn &column)=0
Register a new column.
ROOT::Experimental::Detail::RPageSource::LoadCluster
virtual std::unique_ptr< RCluster > LoadCluster(DescriptorId_t clusterId, const ColumnSet_t &columns)=0
Populates all the pages of the given cluster id and columns; it is possible that some columns do not ...
RNTupleOptions.hxx
ROOT::Experimental::Detail::RPageStorage::RTaskScheduler::AddTask
virtual void AddTask(const std::function< void(void)> &taskFunc)=0
Take a callable that represents a task.
ROOT::Experimental::ColumnId_t
std::int64_t ColumnId_t
Uniquely identifies a physical column within the scope of the current process, used to tag pages.
Definition: RNTupleUtil.hxx:87
ROOT::Experimental::Detail::EPageStorageType::kSink
@ kSink
ROOT
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: EExecutionPolicy.hxx:4
ROOT::Experimental::Detail::RPageSource::fOptions
RNTupleReadOptions fOptions
Definition: RPageStorage.hxx:199
ROOT::Experimental::Detail::RPageSource::GetType
EPageStorageType GetType() final
Whether the concrete implementation is a sink or a source.
Definition: RPageStorage.hxx:222
ROOT::Experimental::Detail::RCluster
An in-memory subset of the packed and compressed pages of a cluster.
Definition: RCluster.hxx:154
ROOT::Experimental::Detail::RPageSink::fPrevClusterNEntries
NTupleSize_t fPrevClusterNEntries
Definition: RPageStorage.hxx:138
ROOT::Experimental::Detail::RPageStorage::DropColumn
virtual void DropColumn(ColumnHandle_t columnHandle)=0
Unregisters a column.
ROOT::Experimental::Detail::RPageSink::fOpenColumnRanges
std::vector< RClusterDescriptor::RColumnRange > fOpenColumnRanges
Keeps track of the number of elements in the currently open cluster. Indexed by column id.
Definition: RPageStorage.hxx:140
ROOT::Experimental::Detail::RPageSink::CommitDataset
void CommitDataset()
Finalize the current cluster and the entrire data set.
Definition: RPageStorage.hxx:176
ROOT::Experimental::Detail::RPageSource::operator=
RPageSource & operator=(const RPageSource &)=delete
ROOT::Experimental::Detail::RPageStorage::GetMetrics
virtual RNTupleMetrics & GetMetrics()
Returns an empty metrics. Page storage implementations usually have their own metrics.
Definition: RPageStorage.cxx:42
ROOT::Experimental::Detail::RPageSink::~RPageSink
virtual ~RPageSink()
Definition: RPageStorage.cxx:113
RNTupleDescriptor.hxx
ROOT::Experimental::Detail::RPageStorage::RTaskScheduler::Wait
virtual void Wait()=0
Blocks until all scheduled tasks finished.
ROOT::Experimental::Detail::RPageSource::operator=
RPageSource & operator=(RPageSource &&)=default