49 static std::once_flag once;
50 std::call_once(once, []() {
52 <<
"Do not store real data with this version of RNTuple!";
54 fCompressor = std::make_unique<RNTupleCompressor>();
77 auto zipBuffer = std::make_unique<unsigned char[]>(
length);
78 auto szZipHeader = fCompressor->Zip(serializedHeader,
length, GetWriteOptions().GetCompression(),
80 fWriter->WriteNTupleHeader(zipBuffer.get(), szZipHeader,
length);
85 std::size_t bytesPacked)
87 std::uint64_t offsetData;
90 offsetData = fWriter->WriteBlob(sealedPage.
GetBuffer(), sealedPage.
GetSize(), bytesPacked);
94 result.fPosition = offsetData;
96 fCounters->fNPageCommitted.Inc();
97 fCounters->fSzWritePayload.Add(sealedPage.
GetSize());
98 fNBytesCurrentCluster += sealedPage.
GetSize();
109 sealedPage = SealPage(page, *element);
113 return WriteSealedPage(sealedPage, element->GetPackedSize(page.
GetNElements()));
121 fDescriptorBuilder.GetDescriptor().GetColumnDescriptor(physicalColumnId).GetModel().GetType());
122 const auto bytesPacked = (bitsOnStorage * sealedPage.
GetNElements() + 7) / 8;
124 return WriteSealedPage(sealedPage, bytesPacked);
127std::vector<ROOT::Experimental::RNTupleLocator>
130 size_t size = 0, bytesPacked = 0;
131 for (
auto &range : ranges) {
132 if (range.fFirst == range.fLast) {
138 fDescriptorBuilder.GetDescriptor().GetColumnDescriptor(range.fPhysicalColumnId).GetModel().GetType());
139 for (
auto sealedPageIt = range.fFirst; sealedPageIt != range.fLast; ++sealedPageIt) {
140 size += sealedPageIt->GetSize();
141 bytesPacked += (bitsOnStorage * sealedPageIt->GetNElements() + 7) / 8;
144 if (
size >= std::numeric_limits<std::int32_t>::max() || bytesPacked >= std::numeric_limits<std::int32_t>::max()) {
152 std::uint64_t
offset = fWriter->ReserveBlob(
size, bytesPacked);
155 std::vector<ROOT::Experimental::RNTupleLocator> locators;
156 for (
auto &range : ranges) {
157 for (
auto sealedPageIt = range.fFirst; sealedPageIt != range.fLast; ++sealedPageIt) {
158 fWriter->WriteIntoReservedBlob(sealedPageIt->GetBuffer(), sealedPageIt->GetSize(),
offset);
162 locators.push_back(locator);
163 offset += sealedPageIt->GetSize();
167 fCounters->fNPageCommitted.Add(locators.size());
168 fCounters->fSzWritePayload.Add(
size);
169 fNBytesCurrentCluster +=
size;
176 auto result = fNBytesCurrentCluster;
177 fNBytesCurrentCluster = 0;
185 auto bufPageListZip = std::make_unique<unsigned char[]>(
length);
186 auto szPageListZip = fCompressor->Zip(serializedPageList,
length, GetWriteOptions().GetCompression(),
190 result.fBytesOnStorage = szPageListZip;
191 result.fPosition = fWriter->WriteBlob(bufPageListZip.get(), szPageListZip,
length);
198 auto bufFooterZip = std::make_unique<unsigned char[]>(
length);
199 auto szFooterZip = fCompressor->Zip(serializedFooter,
length, GetWriteOptions().GetCompression(),
201 fWriter->WriteNTupleFooter(bufFooterZip.get(), szFooterZip,
length);
211 return fPageAllocator->NewPage(columnHandle.
fPhysicalId, elementSize, nElements);
216 fPageAllocator->DeletePage(page);
224 fClusterPool(std::make_unique<
RClusterPool>(*this, options.GetClusterBunchSize()))
231 std::unique_ptr<ROOT::Internal::RRawFile> file,
235 fFile = std::move(file);
253 static std::once_flag once;
254 std::call_once(once, [&anchor]() {
264 auto buffer = std::make_unique<unsigned char[]>(bufSize);
265 auto headerBuf = buffer.get();
269 auto readvLimits = fFile->GetReadVLimits();
270 if ((readvLimits.fMaxReqs < 2) ||
276 fCounters->fNRead.Add(2);
282 fFile->ReadV(readRequests, 2);
283 fCounters->fNReadV.Inc();
293std::unique_ptr<ROOT::Experimental::Internal::RPageSourceFile>
298 throw RException(
R__FAIL(
"This RNTuple object was not streamed from a ROOT file (TFile or descendant)"));
300 std::unique_ptr<ROOT::Internal::RRawFile> rawFile;
306 auto protocol = std::string(url->GetProtocol());
307 if (className ==
"TFile") {
309 }
else if (className ==
"TDavixFile" || className ==
"TNetXNGFile") {
315 auto pageSource = std::make_unique<RPageSourceFile>(
"", std::move(rawFile), options);
316 pageSource->InitDescriptor(anchor);
317 pageSource->fNTupleName = pageSource->fDescriptorBuilder.GetDescriptor().GetName();
327 if (fDescriptorBuilder.GetDescriptor().GetOnDiskHeaderSize() == 0) {
328 auto anchor = fReader.GetNTuple(fNTupleName).Unwrap();
329 InitDescriptor(anchor);
332 auto desc = fDescriptorBuilder.MoveDescriptor();
334 std::vector<unsigned char> buffer;
335 for (
const auto &cgDesc : desc.GetClusterGroupIterable()) {
337 std::max<size_t>(buffer.size(), cgDesc.GetPageListLength() + cgDesc.GetPageListLocator().fBytesOnStorage));
338 auto *zipBuffer = buffer.data() + cgDesc.GetPageListLength();
339 fReader.ReadBuffer(zipBuffer, cgDesc.GetPageListLocator().fBytesOnStorage,
340 cgDesc.GetPageListLocator().GetPosition<std::uint64_t>());
341 fDecompressor->Unzip(zipBuffer, cgDesc.GetPageListLocator().fBytesOnStorage, cgDesc.GetPageListLength(),
348 fFile->SetBuffering(
false);
360 auto descriptorGuard = GetSharedDescriptorGuard();
361 const auto &clusterDescriptor = descriptorGuard->GetClusterDescriptor(clusterId);
362 pageInfo = clusterDescriptor.GetPageRange(physicalColumnId).Find(clusterIndex.
GetIndex());
366 sealedPage.
SetSize(bytesOnStorage);
371 fReader.ReadBuffer(
const_cast<void *
>(sealedPage.
GetBuffer()), bytesOnStorage,
384 const auto clusterId = clusterInfo.
fClusterId;
385 const auto pageInfo = clusterInfo.
fPageInfo;
388 const auto elementSize = element->
GetSize();
389 const auto bytesOnStorage = pageInfo.fLocator.fBytesOnStorage;
391 const void *sealedPageBuffer =
nullptr;
392 std::unique_ptr<unsigned char[]> directReadBuffer;
396 pageZero.GrowUnchecked(pageInfo.fNElements);
397 pageZero.SetWindow(clusterInfo.
fColumnOffset + pageInfo.fFirstInPage,
399 fPagePool->RegisterPage(pageZero,
RPageDeleter([](
const RPage &,
void *) {},
nullptr));
404 directReadBuffer = std::unique_ptr<unsigned char[]>(
new unsigned char[bytesOnStorage]);
405 fReader.ReadBuffer(directReadBuffer.get(), bytesOnStorage, pageInfo.fLocator.GetPosition<std::uint64_t>());
406 fCounters->fNPageLoaded.Inc();
407 fCounters->fNRead.Inc();
408 fCounters->fSzReadPayload.Add(bytesOnStorage);
409 sealedPageBuffer = directReadBuffer.get();
411 if (!fCurrentCluster || (fCurrentCluster->GetId() != clusterId) || !fCurrentCluster->ContainsColumn(columnId))
412 fCurrentCluster = fClusterPool->GetCluster(clusterId, fActivePhysicalColumns.ToColumnSet());
413 R__ASSERT(fCurrentCluster->ContainsColumn(columnId));
415 auto cachedPage = fPagePool->GetPage(columnId,
RClusterIndex(clusterId, idxInCluster));
416 if (!cachedPage.IsNull())
420 auto onDiskPage = fCurrentCluster->GetOnDiskPage(key);
421 R__ASSERT(onDiskPage && (bytesOnStorage == onDiskPage->GetSize()));
422 sealedPageBuffer = onDiskPage->GetAddress();
428 newPage = UnsealPage({sealedPageBuffer, bytesOnStorage, pageInfo.fNElements}, *element, columnId);
429 fCounters->fSzUnzip.Add(elementSize * pageInfo.fNElements);
434 fPagePool->RegisterPage(
436 fCounters->fNPagePopulated.Inc();
444 auto cachedPage = fPagePool->GetPage(columnId, globalIndex);
445 if (!cachedPage.IsNull())
448 std::uint64_t idxInCluster;
451 auto descriptorGuard = GetSharedDescriptorGuard();
452 clusterInfo.
fClusterId = descriptorGuard->FindClusterId(columnId, globalIndex);
455 throw RException(
R__FAIL(
"entry with index " + std::to_string(globalIndex) +
" out of bounds"));
457 const auto &clusterDescriptor = descriptorGuard->GetClusterDescriptor(clusterInfo.
fClusterId);
458 clusterInfo.
fColumnOffset = clusterDescriptor.GetColumnRange(columnId).fFirstElementIndex;
461 clusterInfo.
fPageInfo = clusterDescriptor.GetPageRange(columnId).Find(idxInCluster);
464 return PopulatePageFromCluster(columnHandle, clusterInfo, idxInCluster);
471 const auto idxInCluster = clusterIndex.
GetIndex();
473 auto cachedPage = fPagePool->GetPage(columnId, clusterIndex);
474 if (!cachedPage.IsNull())
482 auto descriptorGuard = GetSharedDescriptorGuard();
483 const auto &clusterDescriptor = descriptorGuard->GetClusterDescriptor(clusterId);
485 clusterInfo.
fColumnOffset = clusterDescriptor.GetColumnRange(columnId).fFirstElementIndex;
486 clusterInfo.
fPageInfo = clusterDescriptor.GetPageRange(columnId).Find(idxInCluster);
489 return PopulatePageFromCluster(columnHandle, clusterInfo, idxInCluster);
494 fPagePool->ReturnPage(page);
502 return std::unique_ptr<RPageSourceFile>(
clone);
505std::unique_ptr<ROOT::Experimental::Internal::RCluster>
507 const RCluster::RKey &clusterKey, std::vector<ROOT::Internal::RRawFile::RIOVec> &readRequests)
509 struct ROnDiskPageLocator {
512 std::uint64_t fOffset = 0;
513 std::uint64_t
fSize = 0;
514 std::size_t fBufPos = 0;
517 std::vector<ROnDiskPageLocator> onDiskPages;
519 auto pageZeroMap = std::make_unique<ROnDiskPageMap>();
520 PrepareLoadCluster(clusterKey, *pageZeroMap,
523 const auto &pageLocator = pageInfo.
fLocator;
525 onDiskPages.push_back({physicalColumnId, pageNo, pageLocator.GetPosition<std::uint64_t>(),
526 pageLocator.fBytesOnStorage, 0});
530 std::sort(onDiskPages.begin(), onDiskPages.end(),
531 [](
const ROnDiskPageLocator &
a,
const ROnDiskPageLocator &
b) { return a.fOffset < b.fOffset; });
540 float maxOverhead = 0.25 * float(activeSize);
541 std::vector<std::size_t> gaps;
542 if (onDiskPages.size())
543 gaps.reserve(onDiskPages.size() - 1);
544 for (
unsigned i = 1; i < onDiskPages.size(); ++i) {
545 gaps.emplace_back(onDiskPages[i].fOffset - (onDiskPages[i - 1].
fSize + onDiskPages[i - 1].fOffset));
547 std::sort(gaps.begin(), gaps.end());
548 std::size_t gapCut = 0;
549 std::size_t currentGap = 0;
551 for (
auto g : gaps) {
552 if (
g != currentGap) {
557 if (szExtra > maxOverhead)
565 const auto currentReadRequestIdx = readRequests.size();
568 std::size_t szPayload = 0;
569 std::size_t szOverhead = 0;
570 for (
auto &s : onDiskPages) {
574 auto overhead = s.fOffset - readUpTo;
575 szPayload += s.fSize;
576 if (overhead <= gapCut) {
577 szOverhead += overhead;
578 s.fBufPos =
reinterpret_cast<intptr_t
>(req.
fBuffer) + req.
fSize + overhead;
579 req.
fSize += overhead + s.fSize;
585 readRequests.emplace_back(req);
588 s.fBufPos =
reinterpret_cast<intptr_t
>(req.
fBuffer);
593 readRequests.emplace_back(req);
594 fCounters->fSzReadPayload.Add(szPayload);
595 fCounters->fSzReadOverhead.Add(szOverhead);
598 auto buffer =
new unsigned char[
reinterpret_cast<intptr_t
>(req.
fBuffer) + req.
fSize];
599 auto pageMap = std::make_unique<ROnDiskPageMapHeap>(std::unique_ptr<
unsigned char[]>(buffer));
600 for (
const auto &s : onDiskPages) {
602 pageMap->Register(key,
ROnDiskPage(buffer + s.fBufPos, s.fSize));
604 fCounters->fNPageLoaded.Add(onDiskPages.size());
605 for (
auto i = currentReadRequestIdx; i < readRequests.size(); ++i) {
606 readRequests[i].fBuffer = buffer +
reinterpret_cast<intptr_t
>(readRequests[i].fBuffer);
609 auto cluster = std::make_unique<RCluster>(clusterKey.
fClusterId);
610 cluster->Adopt(std::move(pageMap));
611 cluster->Adopt(std::move(pageZeroMap));
613 cluster->SetColumnAvailable(colId);
617std::vector<std::unique_ptr<ROOT::Experimental::Internal::RCluster>>
620 fCounters->fNClusterLoaded.Add(clusterKeys.size());
622 std::vector<std::unique_ptr<ROOT::Experimental::Internal::RCluster>> clusters;
623 std::vector<ROOT::Internal::RRawFile::RIOVec> readRequests;
625 clusters.reserve(clusterKeys.size());
626 for (
auto key : clusterKeys) {
627 clusters.emplace_back(PrepareSingleCluster(key, readRequests));
630 auto nReqs = readRequests.size();
631 auto readvLimits = fFile->GetReadVLimits();
635 auto nBatch = std::min(nReqs, readvLimits.fMaxReqs);
637 if (readvLimits.HasSizeLimit()) {
638 std::uint64_t totalSize = 0;
639 for (std::size_t i = 0; i < nBatch; ++i) {
640 if (readRequests[iReq + i].
fSize > readvLimits.fMaxSingleSize) {
645 totalSize += readRequests[iReq + i].fSize;
646 if (totalSize > readvLimits.fMaxTotalSize) {
656 fFile->ReadAt(readRequests[iReq].
fBuffer, readRequests[iReq].
fSize, readRequests[iReq].fOffset);
659 fFile->ReadV(&readRequests[iReq], nBatch);
661 fCounters->fNReadV.Inc();
662 fCounters->fNRead.Add(nBatch);
#define R__FAIL(msg)
Short-hand to return an RResult<T> in an error state; the RError is implicitly converted into RResult...
#define R__LOG_WARNING(...)
TObject * clone(const char *newname) const override
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h offset
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h length
Record wall time and CPU time between construction and destruction.
Managed a set of clusters containing compressed and packed pages.
std::size_t GetSize() const
std::size_t GetBitsOnStorage() const
RColumnElementBase * GetElement() const
Read RNTuple data blocks from a TFile container, provided by a RRawFile.
static Writer_t MakeMemCopyWriter(unsigned char *dest)
static std::unique_ptr< RNTupleFileWriter > Append(std::string_view ntupleName, TFile &file)
Add a new RNTuple identified by ntupleName to the existing TFile.
static std::unique_ptr< RNTupleFileWriter > Recreate(std::string_view ntupleName, std::string_view path, int defaultCompression, EContainerFormat containerFormat)
Create or truncate the local file given by path with the new empty RNTuple identified by ntupleName.
static RResult< void > DeserializeHeader(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder)
static RResult< void > DeserializeFooter(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder)
static RResult< void > DeserializePageList(const void *buffer, std::uint64_t bufSize, DescriptorId_t clusterGroupId, RNTupleDescriptor &desc)
A page as being stored on disk, that is packed and compressed.
Uses standard C++ memory allocation for the column data pages.
static void DeletePage(const RPage &page)
Releases the memory pointed to by page and resets the page's information.
A closure that can free the memory associated with a mapped page.
Base class for a sink with a physical storage backend.
void EnableDefaultMetrics(const std::string &prefix)
Enables the default set of metrics provided by RPageSink.
virtual std::vector< RNTupleLocator > CommitSealedPageVImpl(std::span< RPageStorage::RSealedPageGroup > ranges)
Vector commit of preprocessed pages.
Storage provider that write ntuple pages into a file.
void ReleasePage(RPage &page) final
Every page store needs to be able to free pages it handed out.
std::vector< RNTupleLocator > CommitSealedPageVImpl(std::span< RPageStorage::RSealedPageGroup > ranges) final
Vector commit of preprocessed pages.
std::uint64_t CommitClusterImpl() final
Returns the number of bytes written to storage (excluding metadata)
RNTupleLocator WriteSealedPage(const RPageStorage::RSealedPage &sealedPage, std::size_t bytesPacked)
void InitImpl(unsigned char *serializedHeader, std::uint32_t length) final
RPage ReservePage(ColumnHandle_t columnHandle, std::size_t nElements) final
Get a new, empty page for the given column that can be filled with up to nElements.
RNTupleLocator CommitPageImpl(ColumnHandle_t columnHandle, const RPage &page) final
RNTupleLocator CommitSealedPageImpl(DescriptorId_t physicalColumnId, const RPageStorage::RSealedPage &sealedPage) final
RNTupleLocator CommitClusterGroupImpl(unsigned char *serializedPageList, std::uint32_t length) final
Returns the locator of the page list envelope of the given buffer that contains the serialized page l...
~RPageSinkFile() override
RPageSinkFile(std::string_view ntupleName, const RNTupleWriteOptions &options)
std::unique_ptr< RNTupleFileWriter > fWriter
void CommitDatasetImpl() final
std::unique_ptr< RNTupleCompressor > fCompressor
Helper to zip pages and header/footer; includes a 16MB (kMAXZIPBUF) zip buffer.
Storage provider that reads ntuple pages from a file.
static std::unique_ptr< RPageSourceFile > CreateFromAnchor(const RNTuple &anchor, const RNTupleReadOptions &options=RNTupleReadOptions())
Used from the RNTuple class to build a datasource if the anchor is already available.
RPage PopulatePage(ColumnHandle_t columnHandle, NTupleSize_t globalIndex) final
Allocates and fills a page that contains the index-th element.
RPageSourceFile(std::string_view ntupleName, const RNTupleReadOptions &options)
void ReleasePage(RPage &page) final
Every page store needs to be able to free pages it handed out.
std::vector< std::unique_ptr< RCluster > > LoadClusters(std::span< RCluster::RKey > clusterKeys) final
Populates all the pages of the given cluster ids and columns; it is possible that some columns do not...
std::unique_ptr< RPageSource > Clone() const final
The cloned page source creates a new raw file and reader and opens its own file descriptor to the dat...
std::unique_ptr< RCluster > PrepareSingleCluster(const RCluster::RKey &clusterKey, std::vector< ROOT::Internal::RRawFile::RIOVec > &readRequests)
Helper function for LoadClusters: it prepares the memory buffer (page map) and the read requests for ...
RMiniFileReader fReader
Takes the fFile to read ntuple blobs from it.
RPage PopulatePageFromCluster(ColumnHandle_t columnHandle, const RClusterInfo &clusterInfo, ClusterSize_t::ValueType idxInCluster)
void LoadSealedPage(DescriptorId_t physicalColumnId, RClusterIndex clusterIndex, RSealedPage &sealedPage) final
Read the packed and compressed bytes of a page into the memory buffer provided by selaedPage.
~RPageSourceFile() override
void InitDescriptor(const RNTuple &anchor)
Deserialized header and footer into a minimal descriptor held by fDescriptorBuilder.
RNTupleDescriptor AttachImpl() final
std::unique_ptr< ROOT::Internal::RRawFile > fFile
An RRawFile is used to request the necessary byte ranges from a local or a remote file.
Abstract interface to read data from an ntuple.
void EnableDefaultMetrics(const std::string &prefix)
Enables the default set of metrics provided by RPageSource.
std::unique_ptr< RNTupleDecompressor > fDecompressor
Helper to unzip pages and header/footer; comprises a 16MB (kMAXZIPBUF) unzip buffer.
Stores information about the cluster in which this page resides.
A page is a slice of a column that is mapped into memory.
static RPage MakePageZero(ColumnId_t columnId, ClusterSize_t::ValueType elementSize)
Make a 'zero' page for column columnId (that is comprised of 0x00 bytes only).
std::uint32_t GetNBytes() const
The space taken by column elements in the buffer.
std::uint32_t GetNElements() const
void SetWindow(const NTupleSize_t rangeFirst, const RClusterInfo &clusterInfo)
Seek the page to a certain position of the column.
static const void * GetPageZeroBuffer()
Return a pointer to the page zero buffer used if there is no on-disk data for a particular deferred c...
Addresses a column element or field item relative to a particular cluster, instead of a global NTuple...
DescriptorId_t GetClusterId() const
ClusterSize_t::ValueType GetIndex() const
Base class for all ROOT issued exceptions.
The on-storage meta-data of an ntuple.
Common user-tunable settings for reading ntuples.
Common user-tunable settings for storing ntuples.
int GetCompression() const
Representation of an RNTuple data set in a ROOT file.
std::uint64_t GetLenFooter() const
static constexpr std::uint16_t kVersionEpoch
std::uint64_t GetNBytesHeader() const
std::uint64_t GetLenHeader() const
std::uint16_t GetVersionEpoch() const
std::uint64_t GetNBytesFooter() const
TFile * fFile
! The file from which the ntuple was streamed, registered in the custom streamer
std::uint64_t GetSeekHeader() const
std::uint16_t GetVersionMajor() const
std::uint64_t GetSeekFooter() const
The RRawFileTFile wraps an open TFile, but does not take ownership.
The RRawFile provides read-only access to local and remote files.
static std::unique_ptr< RRawFile > Create(std::string_view url, ROptions options=ROptions())
Factory method that returns a suitable concrete implementation according to the transport in the url.
A ROOT file is an on-disk file, usually with extension .root, that stores objects in a file-system-li...
virtual const TUrl * GetEndpointUrl() const
TClass * IsA() const override
const char * GetName() const override
Returns name of object.
virtual TObject * Clone(const char *newname="") const
Make a clone of an object using the Streamer facility.
RLogChannel & NTupleLog()
Log channel for RNTuple diagnostics.
std::uint64_t NTupleSize_t
Integer type long enough to hold the maximum number of entries in a column.
std::uint64_t DescriptorId_t
Distriniguishes elements of the same type within a descriptor, e.g. different fields.
constexpr DescriptorId_t kInvalidDescriptorId
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
The identifiers that specifies the content of a (partial) cluster.
DescriptorId_t fClusterId
ColumnSet_t fPhysicalColumnSet
On-disk pages within a page source are identified by the column and page number.
Summarizes cluster-level information that are necessary to populate a certain page.
RClusterDescriptor::RPageRange::RPageInfoExtended fPageInfo
Location of the page on disk.
DescriptorId_t fClusterId
std::uint64_t fColumnOffset
The first element number of the page's column in the given cluster.
DescriptorId_t fPhysicalId
A sealed page contains the bytes of a page as written to storage (packed & compressed).
const void * GetBuffer() const
void SetNElements(std::uint32_t nElements)
void SetSize(std::uint32_t size)
std::uint32_t GetSize() const
std::uint32_t GetNElements() const
Generic information about the physical location of data.
ELocatorType fType
For non-disk locators, the value for the Type field.
std::uint32_t fBytesOnStorage
std::variant< std::uint64_t, std::string, RNTupleLocatorObject64 > fPosition
Simple on-disk locators consisting of a 64-bit offset use variant type uint64_t; extended locators ha...
const T & GetPosition() const
Used for vector reads from multiple offsets into multiple buffers.
std::size_t fSize
The number of desired bytes.
void * fBuffer
The destination for reading.
std::uint64_t fOffset
The file offset.