50 static std::once_flag once;
51 std::call_once(once, []() {
53 <<
"Do not store real data with this version of RNTuple!";
55 fCompressor = std::make_unique<RNTupleCompressor>();
78 auto zipBuffer = std::make_unique<unsigned char[]>(
length);
79 auto szZipHeader = fCompressor->Zip(serializedHeader,
length, GetWriteOptions().GetCompression(),
81 fWriter->WriteNTupleHeader(zipBuffer.get(), szZipHeader,
length);
86 std::size_t bytesPacked)
88 std::uint64_t offsetData;
95 result.fPosition = offsetData;
97 fCounters->fNPageCommitted.Inc();
110 sealedPage = SealPage(page, *element);
114 return WriteSealedPage(sealedPage, element->GetPackedSize(page.
GetNElements()));
121 const auto nBits = fDescriptorBuilder.GetDescriptor().GetColumnDescriptor(physicalColumnId).GetBitsOnStorage();
122 const auto bytesPacked = (nBits * sealedPage.
GetNElements() + 7) / 8;
123 return WriteSealedPage(sealedPage, bytesPacked);
127 std::vector<RNTupleLocator> &locators)
133 locators.reserve(locators.size() + batch.
fSealedPages.size());
136 fWriter->WriteIntoReservedBlob(pagePtr->GetBuffer(), pagePtr->GetBufferSize(),
offset);
140 locators.push_back(locator);
141 offset += pagePtr->GetBufferSize();
144 fCounters->fNPageCommitted.Add(batch.
fSealedPages.size());
145 fCounters->fSzWritePayload.Add(batch.
fSize);
146 fNBytesCurrentCluster += batch.
fSize;
153std::vector<ROOT::Experimental::RNTupleLocator>
155 const std::vector<bool> &
mask)
157 const std::uint64_t maxKeySize = fOptions->GetMaxKeySize();
160 std::vector<ROOT::Experimental::RNTupleLocator> locators;
162 std::size_t iPage = 0;
163 for (
auto rangeIt = ranges.begin(); rangeIt != ranges.end(); ++rangeIt) {
164 auto &range = *rangeIt;
165 if (range.fFirst == range.fLast) {
170 const auto bitsOnStorage =
171 fDescriptorBuilder.GetDescriptor().GetColumnDescriptor(range.fPhysicalColumnId).GetBitsOnStorage();
173 for (
auto sealedPageIt = range.fFirst; sealedPageIt != range.fLast; ++sealedPageIt, ++iPage) {
177 const auto bytesPacked = (bitsOnStorage * sealedPageIt->GetNElements() + 7) / 8;
179 if (batch.fSize > 0 && batch.fSize + sealedPageIt->GetBufferSize() > maxKeySize) {
187 CommitBatchOfPages(batch, locators);
190 if (sealedPageIt->GetBufferSize() > maxKeySize) {
196 assert(batch.fSize == 0);
199 fWriter->WriteBlob(sealedPageIt->GetBuffer(), sealedPageIt->GetBufferSize(), bytesPacked);
203 locators.push_back(locator);
205 fCounters->fNPageCommitted.Inc();
206 fCounters->fSzWritePayload.Add(sealedPageIt->GetBufferSize());
207 fNBytesCurrentCluster += sealedPageIt->GetBufferSize();
210 batch.fSealedPages.emplace_back(&(*sealedPageIt));
211 batch.fSize += sealedPageIt->GetBufferSize();
212 batch.fBytesPacked += bytesPacked;
217 if (batch.fSize > 0) {
218 CommitBatchOfPages(batch, locators);
226 auto result = fNBytesCurrentCluster;
227 fNBytesCurrentCluster = 0;
235 auto bufPageListZip = std::make_unique<unsigned char[]>(
length);
236 auto szPageListZip = fCompressor->Zip(serializedPageList,
length, GetWriteOptions().GetCompression(),
240 result.fBytesOnStorage = szPageListZip;
241 result.fPosition = fWriter->WriteBlob(bufPageListZip.get(), szPageListZip,
length);
248 fWriter->UpdateStreamerInfos(fDescriptorBuilder.BuildStreamerInfos());
249 auto bufFooterZip = std::make_unique<unsigned char[]>(
length);
250 auto szFooterZip = fCompressor->Zip(serializedFooter,
length, GetWriteOptions().GetCompression(),
252 fWriter->WriteNTupleFooter(bufFooterZip.get(), szFooterZip,
length);
261 fClusterPool(std::make_unique<
RClusterPool>(*this, options.GetClusterBunchSize()))
267 std::unique_ptr<ROOT::Internal::RRawFile> file,
271 fFile = std::move(file);
282std::unique_ptr<ROOT::Experimental::Internal::RPageSourceFile>
287 throw RException(
R__FAIL(
"This RNTuple object was not streamed from a ROOT file (TFile or descendant)"));
289 std::unique_ptr<ROOT::Internal::RRawFile> rawFile;
295 auto protocol = std::string(url->GetProtocol());
296 if (className ==
"TFile") {
298 }
else if (className ==
"TDavixFile" || className ==
"TNetXNGFile") {
304 auto pageSource = std::make_unique<RPageSourceFile>(
"", std::move(rawFile), options);
305 pageSource->fAnchor = anchor;
306 pageSource->fNTupleName = pageSource->fDescriptorBuilder.GetDescriptor().GetName();
317 fAnchor = fReader.GetNTuple(fNTupleName).Unwrap();
321 throw RException(
R__FAIL(
"unsupported RNTuple epoch version: " + std::to_string(fAnchor->GetVersionEpoch())));
323 if (fAnchor->GetVersionEpoch() == 0) {
324 static std::once_flag once;
325 std::call_once(once, [
this]() {
330 fDescriptorBuilder.SetOnDiskHeaderSize(fAnchor->GetNBytesHeader());
331 fDescriptorBuilder.AddToOnDiskFooterSize(fAnchor->GetNBytesFooter());
334 const auto bufSize = fAnchor->GetNBytesHeader() + fAnchor->GetNBytesFooter() +
335 std::max(fAnchor->GetLenHeader(), fAnchor->GetLenFooter());
336 fStructureBuffer.fBuffer = std::make_unique<unsigned char[]>(bufSize);
337 fStructureBuffer.fPtrHeader = fStructureBuffer.fBuffer.get();
338 fStructureBuffer.fPtrFooter = fStructureBuffer.fBuffer.get() + fAnchor->GetNBytesHeader();
340 auto readvLimits = fFile->GetReadVLimits();
342 readvLimits.fMaxSingleSize = std::min<size_t>(readvLimits.fMaxSingleSize, fAnchor->GetMaxKeySize());
344 if ((readvLimits.fMaxReqs < 2) ||
345 (std::max(fAnchor->GetNBytesHeader(), fAnchor->GetNBytesFooter()) > readvLimits.fMaxSingleSize) ||
346 (fAnchor->GetNBytesHeader() + fAnchor->GetNBytesFooter() > readvLimits.fMaxTotalSize)) {
348 fReader.ReadBuffer(fStructureBuffer.fPtrHeader, fAnchor->GetNBytesHeader(), fAnchor->GetSeekHeader());
349 fReader.ReadBuffer(fStructureBuffer.fPtrFooter, fAnchor->GetNBytesFooter(), fAnchor->GetSeekFooter());
350 fCounters->fNRead.Add(2);
354 {fStructureBuffer.fPtrHeader, fAnchor->GetSeekHeader(), fAnchor->GetNBytesHeader(), 0},
355 {fStructureBuffer.fPtrFooter, fAnchor->GetSeekFooter(), fAnchor->GetNBytesFooter(), 0}};
356 fFile->ReadV(readRequests, 2);
357 fCounters->fNReadV.Inc();
363 auto unzipBuf =
reinterpret_cast<unsigned char *
>(fStructureBuffer.fPtrFooter) + fAnchor->GetNBytesFooter();
373 auto desc = fDescriptorBuilder.MoveDescriptor();
375 std::vector<unsigned char> buffer;
376 for (
const auto &cgDesc : desc.GetClusterGroupIterable()) {
378 std::max<size_t>(buffer.size(), cgDesc.GetPageListLength() + cgDesc.GetPageListLocator().fBytesOnStorage));
379 auto *zipBuffer = buffer.data() + cgDesc.GetPageListLength();
380 fReader.ReadBuffer(zipBuffer, cgDesc.GetPageListLocator().fBytesOnStorage,
381 cgDesc.GetPageListLocator().GetPosition<std::uint64_t>());
389 fFile->SetBuffering(
false);
401 auto descriptorGuard = GetSharedDescriptorGuard();
402 const auto &clusterDescriptor = descriptorGuard->GetClusterDescriptor(clusterId);
403 pageInfo = clusterDescriptor.GetPageRange(physicalColumnId).Find(clusterIndex.
GetIndex());
428 const auto clusterId = clusterInfo.
fClusterId;
429 const auto pageInfo = clusterInfo.
fPageInfo;
432 const auto elementSize = element->
GetSize();
436 pageZero.GrowUnchecked(pageInfo.fNElements);
437 pageZero.SetWindow(clusterInfo.
fColumnOffset + pageInfo.fFirstInPage,
439 return fPagePool.RegisterPage(std::move(pageZero));
445 sealedPage.
SetBufferSize(pageInfo.fLocator.fBytesOnStorage + pageInfo.fHasChecksum * kNBytesPageChecksum);
446 std::unique_ptr<unsigned char[]> directReadBuffer;
449 directReadBuffer = std::unique_ptr<unsigned char[]>(
new unsigned char[sealedPage.
GetBufferSize()]);
450 fReader.ReadBuffer(directReadBuffer.get(), sealedPage.
GetBufferSize(),
451 pageInfo.fLocator.GetPosition<std::uint64_t>());
452 fCounters->fNPageRead.Inc();
453 fCounters->fNRead.Inc();
455 sealedPage.
SetBuffer(directReadBuffer.get());
457 if (!fCurrentCluster || (fCurrentCluster->GetId() != clusterId) || !fCurrentCluster->ContainsColumn(columnId))
458 fCurrentCluster = fClusterPool->GetCluster(clusterId, fActivePhysicalColumns.ToColumnSet());
459 R__ASSERT(fCurrentCluster->ContainsColumn(columnId));
461 auto cachedPageRef = fPagePool.GetPage(columnId,
RClusterIndex(clusterId, idxInCluster));
462 if (!cachedPageRef.Get().IsNull())
463 return cachedPageRef;
466 auto onDiskPage = fCurrentCluster->GetOnDiskPage(key);
468 sealedPage.
SetBuffer(onDiskPage->GetAddress());
474 newPage = UnsealPage(sealedPage, *element, columnId).Unwrap();
475 fCounters->fSzUnzip.Add(elementSize * pageInfo.fNElements);
480 fCounters->fNPageUnsealed.Inc();
481 return fPagePool.RegisterPage(std::move(newPage));
484std::unique_ptr<ROOT::Experimental::Internal::RPageSource>
488 clone->fFile = fFile->Clone();
490 return std::unique_ptr<RPageSourceFile>(clone);
493std::unique_ptr<ROOT::Experimental::Internal::RCluster>
495 const RCluster::RKey &clusterKey, std::vector<ROOT::Internal::RRawFile::RIOVec> &readRequests)
497 struct ROnDiskPageLocator {
500 std::uint64_t fOffset = 0;
501 std::uint64_t
fSize = 0;
502 std::size_t fBufPos = 0;
505 std::vector<ROnDiskPageLocator> onDiskPages;
507 auto pageZeroMap = std::make_unique<ROnDiskPageMap>();
509 clusterKey, *pageZeroMap,
512 const auto &pageLocator = pageInfo.
fLocator;
514 activeSize += nBytes;
515 onDiskPages.push_back({physicalColumnId, pageNo, pageLocator.GetPosition<std::uint64_t>(), nBytes, 0});
519 std::sort(onDiskPages.begin(), onDiskPages.end(),
520 [](
const ROnDiskPageLocator &
a,
const ROnDiskPageLocator &
b) { return a.fOffset < b.fOffset; });
529 float maxOverhead = 0.25 * float(activeSize);
530 std::vector<std::size_t> gaps;
531 if (onDiskPages.size())
532 gaps.reserve(onDiskPages.size() - 1);
533 for (
unsigned i = 1; i < onDiskPages.size(); ++i) {
535 static_cast<int64_t
>(onDiskPages[i].fOffset) - (onDiskPages[i - 1].
fSize + onDiskPages[i - 1].fOffset);
536 gaps.emplace_back(std::max(gap, std::int64_t(0)));
538 activeSize += std::min(gap, std::int64_t(0));
540 std::sort(gaps.begin(), gaps.end());
541 std::size_t gapCut = 0;
542 std::size_t currentGap = 0;
544 for (
auto g : gaps) {
545 if (
g != currentGap) {
550 if (szExtra > maxOverhead)
558 const auto currentReadRequestIdx = readRequests.size();
561 std::size_t szPayload = 0;
562 std::size_t szOverhead = 0;
563 const std::uint64_t maxKeySize = fReader.GetMaxKeySize();
564 for (
auto &s : onDiskPages) {
568 const std::uint64_t overhead = std::max(
static_cast<std::int64_t
>(s.fOffset) - readUpTo, std::int64_t(0));
569 const std::uint64_t extent = std::max(
static_cast<std::int64_t
>(s.fOffset + s.fSize) - readUpTo, std::int64_t(0));
571 if (req.
fSize + extent < maxKeySize && overhead <= gapCut) {
572 szOverhead += overhead;
573 s.fBufPos =
reinterpret_cast<intptr_t
>(req.
fBuffer) + s.fOffset - req.
fOffset;
580 readRequests.emplace_back(req);
583 s.fBufPos =
reinterpret_cast<intptr_t
>(req.
fBuffer);
588 readRequests.emplace_back(req);
589 fCounters->fSzReadPayload.Add(szPayload);
590 fCounters->fSzReadOverhead.Add(szOverhead);
593 auto buffer =
new unsigned char[
reinterpret_cast<intptr_t
>(req.
fBuffer) + req.
fSize];
594 auto pageMap = std::make_unique<ROnDiskPageMapHeap>(std::unique_ptr<
unsigned char[]>(buffer));
595 for (
const auto &s : onDiskPages) {
597 pageMap->Register(key,
ROnDiskPage(buffer + s.fBufPos, s.fSize));
599 fCounters->fNPageRead.Add(onDiskPages.size());
600 for (
auto i = currentReadRequestIdx; i < readRequests.size(); ++i) {
601 readRequests[i].fBuffer = buffer +
reinterpret_cast<intptr_t
>(readRequests[i].fBuffer);
604 auto cluster = std::make_unique<RCluster>(clusterKey.
fClusterId);
605 cluster->Adopt(std::move(pageMap));
606 cluster->Adopt(std::move(pageZeroMap));
608 cluster->SetColumnAvailable(colId);
612std::vector<std::unique_ptr<ROOT::Experimental::Internal::RCluster>>
615 fCounters->fNClusterLoaded.Add(clusterKeys.size());
617 std::vector<std::unique_ptr<ROOT::Experimental::Internal::RCluster>> clusters;
618 std::vector<ROOT::Internal::RRawFile::RIOVec> readRequests;
620 clusters.reserve(clusterKeys.size());
621 for (
auto key : clusterKeys) {
622 clusters.emplace_back(PrepareSingleCluster(key, readRequests));
625 auto nReqs = readRequests.size();
626 auto readvLimits = fFile->GetReadVLimits();
628 readvLimits.fMaxSingleSize = std::min<size_t>(readvLimits.fMaxSingleSize, fReader.GetMaxKeySize());
632 auto nBatch = std::min(nReqs, readvLimits.fMaxReqs);
634 if (readvLimits.HasSizeLimit()) {
635 std::uint64_t totalSize = 0;
636 for (std::size_t i = 0; i < nBatch; ++i) {
637 if (readRequests[iReq + i].
fSize > readvLimits.fMaxSingleSize) {
642 totalSize += readRequests[iReq + i].fSize;
643 if (totalSize > readvLimits.fMaxTotalSize) {
653 fReader.ReadBuffer(readRequests[iReq].
fBuffer, readRequests[iReq].
fSize, readRequests[iReq].fOffset);
656 fFile->ReadV(&readRequests[iReq], nBatch);
658 fCounters->fNReadV.Inc();
659 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(...)
#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 mask
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
RColumnElementBase * GetElement() const
Read RNTuple data blocks from a TFile container, provided by a RRawFile.
static Writer_t MakeMemCopyWriter(unsigned char *dest)
static void Unzip(const void *from, size_t nbytes, size_t dataLen, void *to)
The nbytes parameter provides the size ls of the from buffer.
static std::unique_ptr< RNTupleFileWriter > Append(std::string_view ntupleName, TFile &file, std::uint64_t maxKeySize)
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, EContainerFormat containerFormat, const RNTupleWriteOptions &options)
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.
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.
Storage provider that write ntuple pages into a file.
std::uint64_t CommitClusterImpl() final
Returns the number of bytes written to storage (excluding metadata)
std::vector< RNTupleLocator > CommitSealedPageVImpl(std::span< RPageStorage::RSealedPageGroup > ranges, const std::vector< bool > &mask) final
Vector commit of preprocessed pages.
RNTupleLocator WriteSealedPage(const RPageStorage::RSealedPage &sealedPage, std::size_t bytesPacked)
We pass bytesPacked so that TFile::ls() reports a reasonable value for the compression ratio of the c...
void InitImpl(unsigned char *serializedHeader, std::uint32_t length) final
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
void CommitBatchOfPages(CommitBatch &batch, std::vector< RNTupleLocator > &locators)
Subroutine of CommitSealedPageVImpl, used to perform a vector write of the (multi-)range of pages con...
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.
RPageRef LoadPageImpl(ColumnHandle_t columnHandle, const RClusterInfo &clusterInfo, ClusterSize_t::ValueType idxInCluster) final
RPageSourceFile(std::string_view ntupleName, const RNTupleReadOptions &options)
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 > CloneImpl() 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.
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 sealedPage.
~RPageSourceFile() override
void LoadStructureImpl() final
RNTupleDescriptor AttachImpl() final
LoadStructureImpl() has been called before AttachImpl() is called
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.
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.
std::uint64_t GetMaxKeySize() const
Representation of an RNTuple data set in a ROOT file.
static constexpr std::uint16_t kVersionEpoch
TFile * fFile
! The file from which the ntuple was streamed, registered in the custom streamer
void ThrowOnError()
Short-hand method to throw an exception in the case of errors.
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.
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.
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.
size_t fBytesPacked
Total uncompressed size of the elements in the page batch.
size_t fSize
Total size in bytes of the batch.
std::vector< const RSealedPage * > fSealedPages
The list of pages to commit.
Summarizes cluster-level information that are necessary to load a certain page.
DescriptorId_t fClusterId
std::uint64_t fColumnOffset
The first element number of the page's column in the given cluster.
RClusterDescriptor::RPageRange::RPageInfoExtended fPageInfo
Location of the page on disk.
DescriptorId_t fPhysicalId
A sealed page contains the bytes of a page as written to storage (packed & compressed).
const void * GetBuffer() const
void SetHasChecksum(bool hasChecksum)
void SetNElements(std::uint32_t nElements)
std::uint32_t GetDataSize() const
void SetBuffer(const void *buffer)
RResult< void > VerifyChecksumIfEnabled() const
std::uint32_t GetBufferSize() const
std::uint32_t GetNElements() const
void SetBufferSize(std::uint32_t bufferSize)
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.