40#include <unordered_map>
88 return R__FAIL(
"page checksum verification failed, data corruption detected");
95 return R__FAIL(
"invalid attempt to extract non-existing page checksum");
97 assert(fBufferSize >= kNBytesPageChecksum);
100 reinterpret_cast<const unsigned char *
>(
fBuffer) + fBufferSize - kNBytesPageChecksum,
checksum);
124 for (std::size_t i = 0; i <
itr->second.size(); ++i) {
128 itr->second[i].fRefCounter--;
129 if (
itr->second[i].fRefCounter == 0) {
131 if (
itr->second.empty()) {
132 fColumnInfos.erase(
itr);
158 if (
clusterDesc.GetFirstEntryIndex() >= (fFirstEntry + fNEntries))
170std::unique_ptr<ROOT::Internal::RPageSource>
177 if (location.empty()) {
180 if (location.find(
"daos://") == 0)
182 return std::make_unique<ROOT::Experimental::Internal::RPageSourceDaos>(
ntupleName, location, options);
187 return std::make_unique<ROOT::Internal::RPageSourceFile>(
ntupleName, location, options);
208 if ((
range.fFirstEntry +
range.fNEntries) > GetNEntries()) {
218 fHasStructure =
true;
225 GetExclDescriptorGuard().MoveIn(AttachImpl(
mode));
231 auto clone = CloneImpl();
233 clone->GetExclDescriptorGuard().MoveIn(GetSharedDescriptorGuard()->Clone());
234 clone->fHasStructure =
true;
235 clone->fIsAttached =
true;
242 return GetSharedDescriptorGuard()->GetNEntries();
247 return GetSharedDescriptorGuard()->GetNElements(
columnHandle.fPhysicalId);
258 RNTupleAtomicTimer
timer(fCounters->fTimeWallUnzip, fCounters->fTimeCpuUnzip);
268 std::vector<std::unique_ptr<RColumnElementBase>>
allElements;
274 if (!fActivePhysicalColumns.HasColumnInfos(
columnId))
285 for (
const auto &pi :
pageRange.GetPageInfos()) {
290 sealedPage.SetBufferSize(pi.GetLocator().GetNBytesOnStorage() + pi.HasChecksum() * kNBytesPageChecksum);
317 fCounters->fNPageUnsealed.Add(
pageNo);
321 fTaskScheduler->Wait();
324 throw RException(
R__FAIL(
"page checksum verification failed, data corruption detected"));
346 pageInfo.GetLocator().GetNBytesOnStorage()));
361 GetSharedDescriptorGuard()->GetClusterDescriptor(
clusterId).GetFirstEntryIndex();
362 auto itr = fPreloadedClusters.
begin();
364 fPagePool.Evict(
itr->second);
365 itr = fPreloadedClusters.erase(
itr);
368 while ((
itr != fPreloadedClusters.
end()) &&
373 while (
itr != fPreloadedClusters.
end()) {
374 fPagePool.Evict(
itr->second);
375 itr = fPreloadedClusters.erase(
itr);
389 UpdateLastUsedCluster(
cachedPageRef.Get().GetClusterInfo().GetId());
460 fCounters = std::make_unique<RCounters>(
RCounters{
463 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"szReadPayload",
"B",
"volume read from storage (required)"),
464 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"szReadOverhead",
"B",
"volume read from storage (overhead)"),
467 "number of partial clusters preloaded from storage"),
468 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"nPageRead",
"",
"number of pages read from storage"),
469 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"nPageUnsealed",
"",
"number of pages unzipped and decoded"),
470 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"timeWallRead",
"ns",
"wall clock time spent reading"),
471 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"timeWallUnzip",
"ns",
"wall clock time spent decompressing"),
474 "CPU time spent decompressing"),
476 "bwRead",
"MB/s",
"bandwidth compressed bytes read per second", fMetrics,
493 "bwReadUnzip",
"MB/s",
"bandwidth uncompressed bytes read per second", fMetrics,
507 "bwUnzip",
"MB/s",
"decompression bandwidth of uncompressed bytes per second", fMetrics,
521 "rtReadEfficiency",
"",
"ratio of payload over all bytes read", fMetrics,
527 return {
true, 1. / (1. + (1. *
szReadOverhead->GetValueAsInt()) / payload)};
533 *fMetrics.MakeCounter<
RNTupleCalcPerf *>(
"rtCompression",
"",
"ratio of compressed bytes / uncompressed bytes",
536 metrics.GetLocalCounter(
"szReadPayload")) {
585 page = std::move(tmp);
597 if (fCurrentPageSize ==
other.fCurrentPageSize)
598 return fColumn->GetOnDiskId() >
other.fColumn->GetOnDiskId();
599 return fCurrentPageSize >
other.fCurrentPageSize;
607 auto itr = fColumnsSortedByPageSize.
begin();
608 while (
itr != fColumnsSortedByPageSize.
end()) {
611 if (
itr->fCurrentPageSize ==
itr->fInitialPageSize) {
620 if (
itr != fColumnsSortedByPageSize.
end())
629 itr = fColumnsSortedByPageSize.find(next);
638 auto itr = fColumnsSortedByPageSize.find(key);
639 if (
itr == fColumnsSortedByPageSize.
end()) {
653 fColumnsSortedByPageSize.erase(
itr);
659 fColumnsSortedByPageSize.insert(
elem);
668 fColumnsSortedByPageSize.insert(
elem);
673 fColumnsSortedByPageSize.insert(
elem);
680 :
RPageStorage(
name), fOptions(options.Clone()), fWritePageMemoryManager(options.GetPageBufferBudget())
693 unsigned char *
pageBuf =
reinterpret_cast<unsigned char *
>(config.
fPage->GetBuffer());
698 if (!config.
fElement->IsMappable()) {
727 const auto nBytes =
page.GetNBytes() + GetWriteOptions().GetEnablePageChecksums() * kNBytesPageChecksum;
728 if (fSealPageBuffer.size() <
nBytes)
729 fSealPageBuffer.resize(
nBytes);
735 config.
fWriteChecksum = GetWriteOptions().GetEnablePageChecksums();
737 config.
fBuffer = fSealPageBuffer.data();
739 return SealPage(config);
744 for (
const auto &cb : fOnDatasetCommitCallbacks)
761std::unique_ptr<ROOT::Internal::RPageSink>
768 if (location.empty()) {
771 if (location.find(
"daos://") == 0) {
773 return std::make_unique<ROOT::Experimental::Internal::RPageSinkDaos>(
ntupleName, location, options);
780 return std::make_unique<ROOT::Internal::RPageSinkFile>(
ntupleName, location, options);
794 auto columnId = fDescriptorBuilder.GetDescriptor().GetNPhysicalColumns();
809 fDescriptorBuilder.AddColumn(
columnBuilder.MakeDescriptor().Unwrap());
816 const auto &
descriptor = fDescriptorBuilder.GetDescriptor();
822 const auto &
reps =
f.GetColumnRepresentatives();
825 return reps.size() *
reps[0].size();
839 fDescriptorBuilder.AddFieldLink(
f.GetParent()->GetOnDiskId(),
fieldId);
848 fDescriptorBuilder.AddFieldLink(
f.GetParent()->GetOnDiskId(),
fieldId);
855 .PhysicalColumnId(
source.GetLogicalId())
857 .BitsOnStorage(
source.GetBitsOnStorage())
858 .ValueRange(
source.GetValueRange())
861 .RepresentationIndex(
source.GetRepresentationIndex());
862 fDescriptorBuilder.AddColumn(
columnBuilder.MakeDescriptor().Unwrap());
873 for (
auto f :
changeset.fAddedProjectedFields) {
890 columnRange.SetCompressionSettings(GetWriteOptions().GetCompression());
894 fOpenPageRanges.emplace_back(std::move(
pageRange));
899 if (fSerializationContext.GetHeaderSize() > 0)
900 fSerializationContext.MapSchema(
descriptor,
true);
906 throw RException(
R__FAIL(
"ROOT bug: unexpected type extra info in UpdateExtraTypeInfo()"));
913 fDescriptorBuilder.SetNTuple(fNTupleName, model.
GetDescription());
914 const auto &
descriptor = fDescriptorBuilder.GetDescriptor();
924 for (
auto f :
fieldZero.GetMutableSubfields())
934 InitImpl(buffer.get(), fSerializationContext.GetHeaderSize());
936 fDescriptorBuilder.BeginHeaderExtension();
939std::unique_ptr<ROOT::RNTupleModel>
944 const auto &
descriptor = fDescriptorBuilder.GetDescriptor();
948 R__ASSERT(fOpenColumnRanges.empty() && fOpenPageRanges.empty());
949 fOpenColumnRanges.reserve(
nColumns);
952 const auto &column =
descriptor.GetColumnDescriptor(i);
955 columnRange.SetFirstElementIndex(column.GetFirstElementIndex());
957 columnRange.SetCompressionSettings(GetWriteOptions().GetCompression());
961 fOpenPageRanges.emplace_back(std::move(
pageRange));
970 for (
unsigned int i = 0; i < fOpenColumnRanges.size(); ++i) {
971 R__ASSERT(fOpenColumnRanges[i].GetPhysicalColumnId() == i);
972 if (!
cluster.ContainsColumn(i))
977 fOpenColumnRanges[i].IncrementFirstElementIndex(
columnRange.GetNElements());
979 fDescriptorBuilder.AddCluster(
cluster.Clone());
988 modelOpts.SetReconstructProjections(
true);
992 projectedFields.GetFieldZero().SetOnDiskId(model->GetConstFieldZero().GetOnDiskId());
999 InitImpl(buffer.get(), fSerializationContext.GetHeaderSize());
1001 fDescriptorBuilder.BeginHeaderExtension();
1004 fIsInitialized =
true;
1011 fOpenColumnRanges.at(
columnHandle.fPhysicalId).SetIsSuppressed(
true);
1016 fOpenColumnRanges.at(
columnHandle.fPhysicalId).IncrementNElements(
page.GetNElements());
1021 pageInfo.SetHasChecksum(GetWriteOptions().GetEnablePageChecksums());
1037std::vector<ROOT::RNTupleLocator>
1039 const std::vector<bool> &
mask)
1041 std::vector<ROOT::RNTupleLocator>
locators;
1044 for (
auto &
range : ranges) {
1062 std::vector<bool>
mask;
1066 std::unordered_map<std::uint64_t, RSealedPageLink>
originalPages;
1068 for (
auto &
range : ranges) {
1074 if (!fFeatures.fCanMergePages || !fOptions->GetEnableSamePageMerging()) {
1075 mask.emplace_back(
true);
1086 mask.emplace_back(
true);
1091 const auto *
p =
itr->second.fSealedPage;
1094 mask.emplace_back(
true);
1099 mask.emplace_back(
false);
1103 mask.shrink_to_fit();
1110 for (
auto &
range : ranges) {
1112 fOpenColumnRanges.at(
range.fPhysicalColumnId).IncrementNElements(
sealedPageIt->GetNElements());
1118 fOpenPageRanges.at(
range.fPhysicalColumnId).GetPageInfos().emplace_back(
pageInfo);
1130 for (
unsigned int i = 0; i < fOpenColumnRanges.size(); ++i) {
1132 columnInfo.fCompressionSettings = fOpenColumnRanges[i].GetCompressionSettings().value();
1133 if (fOpenColumnRanges[i].IsSuppressed()) {
1134 assert(fOpenPageRanges[i].GetPageInfos().empty());
1135 columnInfo.fPageRange.SetPhysicalColumnId(i);
1138 fOpenColumnRanges[i].SetNElements(0);
1139 fOpenColumnRanges[i].SetIsSuppressed(
false);
1141 std::swap(
columnInfo.fPageRange, fOpenPageRanges[i]);
1142 fOpenPageRanges[i].SetPhysicalColumnId(i);
1144 columnInfo.fNElements = fOpenColumnRanges[i].GetNElements();
1145 fOpenColumnRanges[i].SetNElements(0);
1157 clusterBuilder.ClusterId(fDescriptorBuilder.GetDescriptor().GetNActiveClusters())
1158 .FirstEntryIndex(fPrevClusterNEntries)
1168 fOpenColumnRanges[
colId].IncrementFirstElementIndex(
columnInfo.fNElements);
1172 clusterBuilder.CommitSuppressedColumnRanges(fDescriptorBuilder.GetDescriptor()).ThrowOnError();
1185 fDescriptorBuilder.AddCluster(
clusterBuilder.MoveDescriptor().Unwrap());
1186 fPrevClusterNEntries +=
cluster.fNEntries;
1192 const auto &
descriptor = fDescriptorBuilder.GetDescriptor();
1197 for (
auto i = fNextClusterInGroup; i <
nClusters; ++i) {
1198 physClusterIDs.emplace_back(fSerializationContext.MapClusterId(i));
1211 cgBuilder.MinEntry(0).EntrySpan(0).NClusters(0);
1218 .NClusters(
nClusters - fNextClusterInGroup);
1220 std::vector<ROOT::DescriptorId_t>
clusterIds;
1222 for (
auto i = fNextClusterInGroup; i <
nClusters; ++i) {
1226 fDescriptorBuilder.AddClusterGroup(
cgBuilder.MoveDescriptor().Unwrap());
1234 if (!fStreamerInfos.empty()) {
1237 for (
const auto &
etDesc : fDescriptorBuilder.GetDescriptor().GetExtraTypeInfoIterable()) {
1244 fStreamerInfos.merge(
etInfo);
1251 fDescriptorBuilder.ReplaceExtraTypeInfo(
extraInfoBuilder.MoveDescriptor().Unwrap());
1254 const auto &
descriptor = fDescriptorBuilder.GetDescriptor();
1266 fCounters = std::make_unique<RCounters>(
RCounters{
1267 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"nPageCommitted",
"",
"number of pages committed to storage"),
1268 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"szWritePayload",
"B",
"volume written for committed pages"),
1270 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"timeWallWrite",
"ns",
"wall clock time spent writing"),
1271 *fMetrics.MakeCounter<
RNTupleAtomicCounter *>(
"timeWallZip",
"ns",
"wall clock time spent compressing"),
1274 "CPU time spent compressing")});
#define R__FORWARD_ERROR(res)
Short-hand to return an RResult<T> in an error state (i.e. after checking)
#define R__FAIL(msg)
Short-hand to return an RResult<T> in an error state; the RError is implicitly converted into RResult...
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
winID h TVirtualViewer3D TVirtualGLPainter p
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 result
Option_t Option_t TPoint TPoint const char mode
A thread-safe integral performance counter.
A metric element that computes its floating point value from other counters.
A collection of Counter objects with a name, a unit, and a description.
A helper class for piece-wise construction of an RClusterDescriptor.
A helper class for piece-wise construction of an RClusterGroupDescriptor.
An in-memory subset of the packed and compressed pages of a cluster.
std::unordered_set< ROOT::DescriptorId_t > ColumnSet_t
A helper class for piece-wise construction of an RColumnDescriptor.
A column element encapsulates the translation between basic C++ types and their column representation...
virtual RIdentifier GetIdentifier() const =0
A column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into ...
std::optional< std::pair< double, double > > GetValueRange() const
std::uint16_t GetRepresentationIndex() const
ROOT::Internal::RColumnElementBase * GetElement() const
ROOT::ENTupleColumnType GetType() const
ROOT::NTupleSize_t GetFirstElementIndex() const
std::size_t GetWritePageCapacity() const
std::uint16_t GetBitsOnStorage() const
std::uint32_t GetIndex() const
A helper class for piece-wise construction of an RFieldDescriptor.
static RFieldDescriptorBuilder FromField(const ROOT::RFieldBase &field)
Make a new RFieldDescriptorBuilder based off a live RNTuple field.
static std::size_t Zip(const void *from, std::size_t nbytes, int compression, void *to)
Returns the size of the compressed data, written into the provided output buffer.
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 unsigned int GetClusterBunchSize(const RNTupleReadOptions &options)
A helper class for serializing and deserialization of the RNTuple binary format.
static std::uint32_t SerializeXxHash3(const unsigned char *data, std::uint64_t length, std::uint64_t &xxhash3, void *buffer)
Writes a XxHash-3 64bit checksum of the byte range given by data and length.
static RResult< StreamerInfoMap_t > DeserializeStreamerInfos(const std::string &extraTypeInfoContent)
static RResult< void > VerifyXxHash3(const unsigned char *data, std::uint64_t length, std::uint64_t &xxhash3)
Expects an xxhash3 checksum in the 8 bytes following data + length and verifies it.
EDescriptorDeserializeMode
static RResult< std::uint32_t > SerializePageList(void *buffer, const RNTupleDescriptor &desc, std::span< ROOT::DescriptorId_t > physClusterIDs, const RContext &context)
static RResult< std::uint32_t > SerializeFooter(void *buffer, const RNTupleDescriptor &desc, const RContext &context)
static std::uint32_t DeserializeUInt64(const void *buffer, std::uint64_t &val)
static RResult< RContext > SerializeHeader(void *buffer, const RNTupleDescriptor &desc)
static std::string SerializeStreamerInfos(const StreamerInfoMap_t &infos)
A memory region that contains packed and compressed pages.
A page as being stored on disk, that is packed and compressed.
Uses standard C++ memory allocation for the column data pages.
Abstract interface to allocate and release pages.
RStagedCluster StageCluster(ROOT::NTupleSize_t nNewEntries) final
Stage the current cluster and create a new one for the following data.
void CommitSealedPage(ROOT::DescriptorId_t physicalColumnId, const RPageStorage::RSealedPage &sealedPage) final
Write a preprocessed page to storage. The column must have been added before.
std::unique_ptr< RNTupleModel > InitFromDescriptor(const ROOT::RNTupleDescriptor &descriptor, bool copyClusters)
Initialize sink based on an existing descriptor and fill into the descriptor builder,...
void UpdateExtraTypeInfo(const ROOT::RExtraTypeInfoDescriptor &extraTypeInfo) final
Adds an extra type information record to schema.
ColumnHandle_t AddColumn(ROOT::DescriptorId_t fieldId, ROOT::Internal::RColumn &column) final
Register a new column.
virtual std::vector< RNTupleLocator > CommitSealedPageVImpl(std::span< RPageStorage::RSealedPageGroup > ranges, const std::vector< bool > &mask)
Vector commit of preprocessed pages.
RPagePersistentSink(std::string_view ntupleName, const ROOT::RNTupleWriteOptions &options)
void CommitDatasetImpl() final
void CommitSuppressedColumn(ColumnHandle_t columnHandle) final
Commits a suppressed column for the current cluster.
void UpdateSchema(const ROOT::Internal::RNTupleModelChangeset &changeset, ROOT::NTupleSize_t firstEntry) final
Incorporate incremental changes to the model into the ntuple descriptor.
void CommitStagedClusters(std::span< RStagedCluster > clusters) final
Commit staged clusters, logically appending them to the ntuple descriptor.
static std::unique_ptr< RPageSink > Create(std::string_view ntupleName, std::string_view location, const ROOT::RNTupleWriteOptions &options=ROOT::RNTupleWriteOptions())
Guess the concrete derived page source from the location.
void CommitPage(ColumnHandle_t columnHandle, const ROOT::Internal::RPage &page) final
Write a page to the storage. The column must have been added before.
~RPagePersistentSink() override
virtual void InitImpl(unsigned char *serializedHeader, std::uint32_t length)=0
void CommitClusterGroup() final
Write out the page locations (page list envelope) for all the committed clusters since the last call ...
void CommitSealedPageV(std::span< RPageStorage::RSealedPageGroup > ranges) final
Write a vector of preprocessed pages to storage. The corresponding columns must have been added befor...
void EnableDefaultMetrics(const std::string &prefix)
Enables the default set of metrics provided by RPageSink.
Abstract interface to write data into an ntuple.
virtual ROOT::Internal::RPage ReservePage(ColumnHandle_t columnHandle, std::size_t nElements)
Get a new, empty page for the given column that can be filled with up to nElements; nElements must be...
RSealedPage SealPage(const ROOT::Internal::RPage &page, const ROOT::Internal::RColumnElementBase &element)
Helper for streaming a page.
RPageSink(std::string_view ntupleName, const ROOT::RNTupleWriteOptions &options)
void CommitDataset()
Run the registered callbacks and finalize the current cluster and the entrire data set.
void Insert(ROOT::DescriptorId_t physicalColumnId, ROOT::Internal::RColumnElementBase::RIdentifier elementId)
ROOT::Internal::RCluster::ColumnSet_t ToColumnSet() const
void Erase(ROOT::DescriptorId_t physicalColumnId, ROOT::Internal::RColumnElementBase::RIdentifier elementId)
void LoadStructure()
Loads header and footer without decompressing or deserializing them.
virtual ROOT::Internal::RPageRef LoadPage(ColumnHandle_t columnHandle, ROOT::NTupleSize_t globalIndex)
Allocates and fills a page that contains the index-th element.
void Attach(ROOT::Internal::RNTupleSerializer::EDescriptorDeserializeMode mode=ROOT::Internal::RNTupleSerializer::EDescriptorDeserializeMode::kForReading)
Open the physical storage container and deserialize header and footer.
ColumnHandle_t AddColumn(ROOT::DescriptorId_t fieldId, ROOT::Internal::RColumn &column) override
Register a new column.
void UnzipCluster(ROOT::Internal::RCluster *cluster)
Parallel decompression and unpacking of the pages in the given cluster.
void PrepareLoadCluster(const ROOT::Internal::RCluster::RKey &clusterKey, ROOT::Internal::ROnDiskPageMap &pageZeroMap, std::function< void(ROOT::DescriptorId_t, ROOT::NTupleSize_t, const ROOT::RClusterDescriptor::RPageInfo &)> perPageFunc)
Prepare a page range read for the column set in clusterKey.
void EnableDefaultMetrics(const std::string &prefix)
Enables the default set of metrics provided by RPageSource.
ROOT::NTupleSize_t GetNEntries()
void UpdateLastUsedCluster(ROOT::DescriptorId_t clusterId)
Does nothing if fLastUsedCluster == clusterId.
ROOT::NTupleSize_t GetNElements(ColumnHandle_t columnHandle)
void DropColumn(ColumnHandle_t columnHandle) override
Unregisters a column.
virtual void UnzipClusterImpl(ROOT::Internal::RCluster *cluster)
RPageSource(std::string_view ntupleName, const ROOT::RNTupleReadOptions &fOptions)
void SetEntryRange(const REntryRange &range)
Promise to only read from the given entry range.
std::unique_ptr< RPageSource > Clone() const
Open the same storage multiple time, e.g.
static std::unique_ptr< RPageSource > Create(std::string_view ntupleName, std::string_view location, const ROOT::RNTupleReadOptions &options=ROOT::RNTupleReadOptions())
Guess the concrete derived page source from the file name (location)
static RResult< ROOT::Internal::RPage > UnsealPage(const RSealedPage &sealedPage, const ROOT::Internal::RColumnElementBase &element, ROOT::Internal::RPageAllocator &pageAlloc)
Helper for unstreaming a page.
Common functionality of an ntuple storage for both reading and writing.
RPageStorage(std::string_view name)
Stores information about the cluster in which this page resides.
A page is a slice of a column that is mapped into memory.
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...
const ROOT::RFieldBase * GetSourceField(const ROOT::RFieldBase *target) const
bool TryEvict(std::size_t targetAvailableSize, std::size_t pageSizeLimit)
Flush columns in order of allocated write page size until the sum of all write page allocations leave...
bool TryUpdate(ROOT::Internal::RColumn &column, std::size_t newWritePageSize)
Try to register the new write page size for the given column.
The window of element indexes of a particular column in a particular cluster.
Metadata for RNTuple clusters.
Base class for all ROOT issued exceptions.
A field translates read and write calls from/to underlying columns to/from tree values.
The on-storage metadata of an RNTuple.
Addresses a column element or field item relative to a particular cluster, instead of a global NTuple...
The RNTupleModel encapulates the schema of an RNTuple.
const std::string & GetDescription() const
Common user-tunable settings for reading RNTuples.
Common user-tunable settings for storing RNTuples.
const_iterator begin() const
const_iterator end() const
void ThrowOnError()
Short-hand method to throw an exception in the case of errors.
The class is used as a return type for operations that can fail; wraps a value of type T or an RError...
ROOT::RFieldZero & GetFieldZeroOfModel(RNTupleModel &model)
RResult< void > EnsureValidNameForRNTuple(std::string_view name, std::string_view where)
Check whether a given string is a valid name according to the RNTuple specification.
std::unique_ptr< T[]> MakeUninitArray(std::size_t size)
Make an array of default-initialized elements.
RProjectedFields & GetProjectedFieldsOfModel(RNTupleModel &model)
std::unique_ptr< RColumnElementBase > GenerateColumnElement(std::type_index inMemoryType, ROOT::ENTupleColumnType onDiskType)
void CallConnectPageSinkOnField(RFieldBase &, ROOT::Internal::RPageSink &, ROOT::NTupleSize_t firstEntry=0)
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
std::uint64_t DescriptorId_t
Distriniguishes elements of the same type within a descriptor, e.g. different fields.
constexpr NTupleSize_t kInvalidNTupleIndex
std::uint64_t NTupleSize_t
Integer type long enough to hold the maximum number of entries in a column.
constexpr DescriptorId_t kInvalidDescriptorId
The identifiers that specifies the content of a (partial) cluster.
Every concrete RColumnElement type is identified by its on-disk type (column type) and the in-memory ...
The incremental changes to a RNTupleModel
On-disk pages within a page source are identified by the column and page number.
Default I/O performance counters that get registered in fMetrics.
Parameters for the SealPage() method.
bool fWriteChecksum
Adds a 8 byte little-endian xxhash3 checksum to the page payload.
std::uint32_t fCompressionSettings
Compression algorithm and level to apply.
void * fBuffer
Location for sealed output. The memory buffer has to be large enough.
const ROOT::Internal::RPage * fPage
Input page to be sealed.
bool fAllowAlias
If false, the output buffer must not point to the input page buffer, which would otherwise be an opti...
const ROOT::Internal::RColumnElementBase * fElement
Corresponds to the page's elements, for size calculation etc.
Cluster that was staged, but not yet logically appended to the RNTuple.
Summarizes cluster-level information that are necessary to load a certain page.
Default I/O performance counters that get registered in fMetrics
Used in SetEntryRange / GetEntryRange.
bool IntersectsWith(const ROOT::RClusterDescriptor &clusterDesc) const
Returns true if the given cluster has entries within the entry range.
A sealed page contains the bytes of a page as written to storage (packed & compressed).
RResult< void > VerifyChecksumIfEnabled() const
RResult< std::uint64_t > GetChecksum() const
Returns a failure if the sealed page has no checksum.
ROOT::Internal::RColumn * fColumn
bool operator>(const RColumnInfo &other) const
Information about a single page in the context of a cluster's page range.
Modifiers passed to CreateModel()