33 std::unique_ptr<ROOT::Experimental::Internal::RPageSource> pageSource)
34 : fPageSource(std::move(pageSource))
37 auto descriptorGuard =
fPageSource->GetSharedDescriptorGuard();
50 fUncompressedSize = 0;
52 for (
const auto &colDesc : fDescriptor->GetColumnIterable()) {
53 if (colDesc.IsAliasColumn())
56 auto colId = colDesc.GetPhysicalId();
61 std::uint64_t nElems = 0;
62 std::vector<std::uint64_t> compressedPageSizes{};
64 for (
const auto &clusterDescriptor : fDescriptor->GetClusterIterable()) {
65 if (!clusterDescriptor.ContainsColumn(colId)) {
69 auto columnRange = clusterDescriptor.GetColumnRange(colId);
70 if (columnRange.fIsSuppressed)
73 nElems += columnRange.fNElements;
75 if (fCompressionSettings == -1) {
76 fCompressionSettings = columnRange.fCompressionSettings;
77 }
else if (fCompressionSettings != columnRange.fCompressionSettings &&
83 std::to_string(fCompressionSettings) +
" vs " +
84 std::to_string(columnRange.fCompressionSettings) +
85 ") for column with physical ID " + std::to_string(colId)));
88 const auto &pageRange = clusterDescriptor.GetPageRange(colId);
90 for (
const auto &page : pageRange.fPageInfos) {
91 compressedPageSizes.emplace_back(page.fLocator.fBytesOnStorage);
92 fUncompressedSize += page.fNElements * elemSize;
96 fCompressedSize += std::accumulate(compressedPageSizes.begin(), compressedPageSizes.end(),
static_cast<std::uint64_t
>(0));
97 fColumnInfo.emplace(colId,
RColumnInspector(colDesc, compressedPageSizes, elemSize, nElems));
104 std::uint64_t compressedSize = 0;
105 std::uint64_t uncompressedSize = 0;
107 for (
const auto &colDescriptor : fDescriptor->GetColumnIterable(fieldId)) {
108 auto colInfo = GetColumnInspector(colDescriptor.GetPhysicalId());
109 compressedSize += colInfo.GetCompressedSize();
110 uncompressedSize += colInfo.GetUncompressedSize();
113 for (
const auto &subFieldDescriptor : fDescriptor->GetFieldIterable(fieldId)) {
116 auto subFieldInfo = CollectFieldTreeInfo(subFieldId);
118 compressedSize += subFieldInfo.GetCompressedSize();
119 uncompressedSize += subFieldInfo.GetUncompressedSize();
122 auto fieldInfo =
RFieldTreeInspector(fDescriptor->GetFieldDescriptor(fieldId), compressedSize, uncompressedSize);
123 fFieldTreeInfo.emplace(fieldId, fieldInfo);
127std::vector<ROOT::Experimental::DescriptorId_t>
130 std::vector<DescriptorId_t> colIds;
131 std::deque<DescriptorId_t> fieldIdQueue{fieldId};
133 while (!fieldIdQueue.empty()) {
134 auto currId = fieldIdQueue.front();
135 fieldIdQueue.pop_front();
137 for (
const auto &col : fDescriptor->GetColumnIterable(currId)) {
138 if (col.IsAliasColumn()) {
142 colIds.emplace_back(col.GetPhysicalId());
145 for (
const auto &fld : fDescriptor->GetFieldIterable(currId)) {
146 fieldIdQueue.push_back(fld.GetId());
153std::unique_ptr<ROOT::Experimental::RNTupleInspector>
157 return std::unique_ptr<RNTupleInspector>(
new RNTupleInspector(std::move(pageSource)));
160std::unique_ptr<ROOT::Experimental::RNTupleInspector>
164 return std::unique_ptr<RNTupleInspector>(
new RNTupleInspector(std::move(pageSource)));
169 int algorithm = fCompressionSettings / 100;
170 int level = fCompressionSettings - (algorithm * 100);
173 " (level " + std::to_string(level) +
")";
181 if (physicalColumnId > fDescriptor->GetNPhysicalColumns()) {
182 throw RException(
R__FAIL(
"No column with physical ID " + std::to_string(physicalColumnId) +
" present"));
185 return fColumnInfo.at(physicalColumnId);
190 size_t typeCount = 0;
192 for (
auto &[colId, colInfo] : fColumnInfo) {
193 if (colInfo.GetType() == colType) {
201const std::vector<ROOT::Experimental::DescriptorId_t>
204 std::vector<DescriptorId_t> colIds;
206 for (
const auto &[colId, colInfo] : fColumnInfo) {
207 if (colInfo.GetType() == colType)
208 colIds.emplace_back(colId);
216 std::set<EColumnType> colTypes;
218 for (
const auto &[colId, colInfo] : fColumnInfo) {
219 colTypes.emplace(colInfo.GetType());
222 return std::vector(colTypes.begin(), colTypes.end());
227 struct ColumnTypeInfo {
229 std::uint64_t nElems, compressedSize, uncompressedSize;
240 std::map<EColumnType, ColumnTypeInfo> colTypeInfo;
242 for (
const auto &[colId, colInfo] : fColumnInfo) {
243 colTypeInfo[colInfo.GetType()] += colInfo;
248 output <<
" column type | count | # elements | compressed bytes | uncompressed bytes\n"
249 <<
"----------------|---------|-----------------|-------------------|--------------------" << std::endl;
250 for (
const auto &[colType, typeInfo] : colTypeInfo) {
252 << typeInfo.count <<
" |" << std::setw(16) << typeInfo.nElems <<
" |" << std::setw(18)
253 << typeInfo.compressedSize <<
" |" << std::setw(18) << typeInfo.uncompressedSize <<
" " << std::endl;
257 output <<
"columnType,count,nElements,compressedSize,uncompressedSize" << std::endl;
258 for (
const auto &[colType, typeInfo] : colTypeInfo) {
260 <<
"," << typeInfo.compressedSize <<
"," << typeInfo.uncompressedSize << std::endl;
269 std::string_view histName, std::string_view histTitle)
271 if (histName.empty()) {
281 if (histTitle.empty()) {
291 auto hist = std::make_unique<TH1D>(std::string(histName).c_str(), std::string(histTitle).c_str(), 1, 0, 1);
294 for (
const auto &[colId, colInfo] : fColumnInfo) {
311 std::string histName,
312 std::string histTitle,
size_t nBins)
314 if (histTitle.empty())
315 histTitle =
"Page size distribution for column with ID " + std::to_string(physicalColumnId);
317 return GetPageSizeDistribution({physicalColumnId}, histName, histTitle, nBins);
322 std::string histName, std::string histTitle,
size_t nBins)
324 if (histName.empty())
326 if (histTitle.empty())
329 auto perTypeHist = GetPageSizeDistribution({colType}, histName, histTitle, nBins);
331 if (perTypeHist->GetNhists() < 1)
332 return std::make_unique<TH1D>(histName.c_str(), histTitle.c_str(), 64, 0, 0);
334 auto hist = std::unique_ptr<TH1D>(
dynamic_cast<TH1D *
>(perTypeHist->GetHists()->First()));
336 hist->SetName(histName.c_str());
337 hist->SetTitle(histTitle.c_str());
338 hist->SetXTitle(
"Page size (B)");
339 hist->SetYTitle(
"N_{pages}");
345 std::string histName, std::string histTitle,
size_t nBins)
347 auto hist = std::make_unique<TH1D>();
349 if (histName.empty())
350 histName =
"pageSizeHist";
351 hist->SetName(histName.c_str());
352 if (histTitle.empty())
353 histTitle =
"Page size distribution";
354 hist->SetTitle(histTitle.c_str());
355 hist->SetXTitle(
"Page size (B)");
356 hist->SetYTitle(
"N_{pages}");
358 std::vector<std::uint64_t> pageSizes;
359 std::for_each(colIds.begin(), colIds.end(), [
this, &pageSizes](
const auto colId) {
360 auto colInfo = GetColumnInspector(colId);
361 pageSizes.insert(pageSizes.end(), colInfo.GetCompressedPageSizes().begin(),
362 colInfo.GetCompressedPageSizes().end());
365 auto histMinMax = std::minmax_element(pageSizes.begin(), pageSizes.end());
366 hist->SetBins(nBins, *histMinMax.first,
367 *histMinMax.second + ((*histMinMax.second - *histMinMax.first) /
static_cast<double>(nBins)));
369 for (
const auto pageSize : pageSizes) {
370 hist->Fill(pageSize);
377 std::initializer_list<ROOT::Experimental::EColumnType> colTypes, std::string histName, std::string histTitle,
380 if (histName.empty())
381 histName =
"pageSizeHist";
382 if (histTitle.empty())
383 histTitle =
"Per-column type page size distribution";
385 auto stackedHist = std::make_unique<THStack>(histName.c_str(), histTitle.c_str());
387 double histMin = std::numeric_limits<double>::max();
389 std::map<EColumnType, std::vector<std::uint64_t>> pageSizes;
391 std::vector<EColumnType> colTypeVec = colTypes;
392 if (std::empty(colTypes)) {
393 colTypeVec = GetColumnTypes();
396 for (
const auto colType : colTypeVec) {
397 auto colIds = GetColumnsByType(colType);
402 std::vector<std::uint64_t> pageSizesForColType;
403 std::for_each(colIds.cbegin(), colIds.cend(), [
this, &pageSizesForColType](
const auto colId) {
404 auto colInfo = GetColumnInspector(colId);
405 pageSizesForColType.insert(pageSizesForColType.end(), colInfo.GetCompressedPageSizes().begin(),
406 colInfo.GetCompressedPageSizes().end());
408 pageSizes.emplace(colType, pageSizesForColType);
410 auto histMinMax = std::minmax_element(pageSizesForColType.begin(), pageSizesForColType.end());
411 histMin = std::min(histMin,
static_cast<double>(*histMinMax.first));
412 histMax = std::max(histMax,
static_cast<double>(*histMinMax.second));
415 for (
const auto &[colType, pageSizesForColType] : pageSizes) {
416 auto hist = std::make_unique<TH1D>(
419 histMax + ((histMax - histMin) /
static_cast<double>(nBins)));
421 for (
const auto pageSize : pageSizesForColType) {
422 hist->Fill(pageSize);
425 stackedHist->Add(hist.release());
436 if (fieldId >= fDescriptor->GetNFields()) {
437 throw RException(
R__FAIL(
"No field with ID " + std::to_string(fieldId) +
" present"));
440 return fFieldTreeInfo.at(fieldId);
449 throw RException(
R__FAIL(
"Could not find field `" + std::string(fieldName) +
"`"));
452 return GetFieldTreeInspector(fieldId);
456 bool includeSubFields)
const
458 size_t typeCount = 0;
460 for (
auto &[fldId, fldInfo] : fFieldTreeInfo) {
461 if (!includeSubFields && fldInfo.GetDescriptor().GetParentId() != fDescriptor->GetFieldZeroId()) {
465 if (std::regex_match(fldInfo.GetDescriptor().GetTypeName(), typeNamePattern)) {
473const std::vector<ROOT::Experimental::DescriptorId_t>
476 std::vector<DescriptorId_t> fieldIds;
478 for (
auto &[fldId, fldInfo] : fFieldTreeInfo) {
480 if (!searchInSubFields && fldInfo.GetDescriptor().GetParentId() != fDescriptor->GetFieldZeroId()) {
484 if (std::regex_match(fldInfo.GetDescriptor().GetFieldName(), fieldNamePattern)) {
485 fieldIds.emplace_back(fldId);
#define R__FAIL(msg)
Short-hand to return an RResult<T> in an error state; the RError is implicitly converted into RResult...
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
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 Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t format
std::string & operator+=(std::string &left, const TString &right)
The available trivial, native content types of a column.
static std::string GetTypeName(EColumnType type)
static std::unique_ptr< RColumnElementBase > Generate(EColumnType type)
If CppT == void, use the default C++ type for the given column type.
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.
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)
Base class for all ROOT issued exceptions.
Provides column-level storage information.
std::uint64_t GetCompressedSize() const
std::uint64_t GetUncompressedSize() const
std::uint64_t GetNElements() const
Provides field-level storage information.
Inspect on-disk and storage-related information of an RNTuple.
const RColumnInspector & GetColumnInspector(DescriptorId_t physicalColumnId) const
Get storage information for a given column.
const std::vector< DescriptorId_t > GetFieldsByName(const std::regex &fieldNamePattern, bool searchInSubFields=true) const
Get the IDs of (sub-)fields whose name matches the given string.
std::unique_ptr< Internal::RPageSource > fPageSource
const std::vector< EColumnType > GetColumnTypes()
Get all column types present in the RNTuple being inspected.
size_t GetColumnCountByType(EColumnType colType) const
Get the number of columns of a given type present in the RNTuple.
RNTupleInspector(std::unique_ptr< Internal::RPageSource > pageSource)
std::string GetCompressionSettingsAsString() const
Get a string describing compression settings of the RNTuple being inspected.
std::unique_ptr< TH1D > GetPageSizeDistribution(DescriptorId_t physicalColumnId, std::string histName="", std::string histTitle="", size_t nBins=64)
Get a histogram containing the size distribution of the compressed pages for an individual column.
const std::vector< DescriptorId_t > GetColumnsByType(EColumnType colType)
Get the IDs of all columns with the given type.
void PrintColumnTypeInfo(ENTupleInspectorPrintFormat format=ENTupleInspectorPrintFormat::kTable, std::ostream &output=std::cout)
Print storage information per column type.
RFieldTreeInspector CollectFieldTreeInfo(DescriptorId_t fieldId)
Recursively gather field-level information.
std::unique_ptr< RNTupleDescriptor > fDescriptor
std::vector< DescriptorId_t > GetColumnsByFieldId(DescriptorId_t fieldId) const
Get the columns that make up the given field, including its subfields.
static std::unique_ptr< RNTupleInspector > Create(const RNTuple &sourceNTuple)
Create a new RNTupleInspector.
void CollectColumnInfo()
Gather column-level and RNTuple-level information.
size_t GetFieldCountByType(const std::regex &typeNamePattern, bool searchInSubFields=true) const
Get the number of fields of a given type or class present in the RNTuple.
const RFieldTreeInspector & GetFieldTreeInspector(DescriptorId_t fieldId) const
Get storage information for a given (sub)field by ID.
std::unique_ptr< TH1D > GetColumnTypeInfoAsHist(ENTupleInspectorHist histKind, std::string_view histName="", std::string_view histTitle="")
Get a histogram showing information for each column type present,.
Representation of an RNTuple data set in a ROOT file.
1-D histogram with a double per channel (see TH1 documentation)
static TString Format(const char *fmt,...)
Static method which formats a string using a printf style format descriptor and return a TString.
ENTupleInspectorPrintFormat
constexpr int kUnknownCompressionSettings
std::uint64_t DescriptorId_t
Distriniguishes elements of the same type within a descriptor, e.g. different fields.
constexpr DescriptorId_t kInvalidDescriptorId
EValues
Note: this is only temporarily a struct and will become a enum class hence the name convention used.
static std::string AlgorithmToString(EAlgorithm::EValues algorithm)