Logo ROOT  
Reference Guide
RNTupleDescriptorFmt.cxx
Go to the documentation of this file.
1/// \file RNTupleDescriptorFmt.cxx
2/// \ingroup NTuple ROOT7
3/// \author Jakob Blomer <jblomer@cern.ch>
4/// \date 2019-08-25
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
17#include <ROOT/RColumnModel.hxx>
19#include <ROOT/RNTupleUtil.hxx>
20
21#include <algorithm>
22#include <iomanip>
23#include <ostream>
24#include <unordered_map>
25#include <vector>
26
27namespace {
28
29struct ClusterInfo {
30 std::uint64_t fFirstEntry = 0;
31 std::uint32_t fNPages = 0;
32 std::uint32_t fNEntries = 0;
33 std::uint32_t fBytesOnStorage = 0;
34 std::uint32_t fBytesInMemory = 0;
35
36 bool operator ==(const ClusterInfo &other) const {
37 return fFirstEntry == other.fFirstEntry;
38 }
39
40 bool operator <(const ClusterInfo &other) const {
41 return fFirstEntry < other.fFirstEntry;
42 }
43};
44
45struct ColumnInfo {
48 std::uint64_t fLocalOrder = 0;
49 std::uint64_t fNElements = 0;
50 std::uint64_t fNPages = 0;
51 std::uint64_t fBytesOnStorage = 0;
52 std::uint32_t fElementSize = 0;
54 std::string fFieldName;
55 std::string fFieldDescription;
56
57 bool operator <(const ColumnInfo &other) const {
58 if (fFieldName == other.fFieldName)
59 return fLocalOrder < other.fLocalOrder;
60 return fFieldName < other.fFieldName;
61 }
62};
63
64static std::string GetFieldName(ROOT::Experimental::DescriptorId_t fieldId,
66{
67 const auto &fieldDesc = ntupleDesc.GetFieldDescriptor(fieldId);
68 if (fieldDesc.GetParentId() == ROOT::Experimental::kInvalidDescriptorId)
69 return fieldDesc.GetFieldName();
70 return GetFieldName(fieldDesc.GetParentId(), ntupleDesc) + "." + fieldDesc.GetFieldName();
71}
72
73static std::string GetFieldDescription(ROOT::Experimental::DescriptorId_t fFieldId,
75{
76 const auto &fieldDesc = ntupleDesc.GetFieldDescriptor(fFieldId);
77 return fieldDesc.GetFieldDescription();
78}
79
80} // anonymous namespace
81
83{
84 std::vector<ColumnInfo> columns;
85 std::vector<ClusterInfo> clusters;
86 std::unordered_map<DescriptorId_t, unsigned int> cluster2Idx;
87 for (const auto &cluster : fClusterDescriptors) {
88 ClusterInfo info;
89 info.fFirstEntry = cluster.second.GetFirstEntryIndex();
90 info.fNEntries = cluster.second.GetNEntries();
91 cluster2Idx[cluster.first] = clusters.size();
92 clusters.emplace_back(info);
93 }
94
95 std::uint64_t bytesOnStorage = 0;
96 std::uint64_t bytesInMemory = 0;
97 std::uint64_t nPages = 0;
98 int compression = -1;
99 for (const auto &column : fColumnDescriptors) {
100 // We generate the default memory representation for the given column type in order
101 // to report the size _in memory_ of column elements
102 auto elementSize = Detail::RColumnElementBase::Generate(column.second.GetModel().GetType())->GetSize();
103
104 ColumnInfo info;
105 info.fColumnId = column.second.GetId();
106 info.fFieldId = column.second.GetFieldId();
107 info.fLocalOrder = column.second.GetIndex();
108 info.fElementSize = elementSize;
109 info.fType = column.second.GetModel().GetType();
110
111 for (const auto &cluster : fClusterDescriptors) {
112 auto columnRange = cluster.second.GetColumnRange(column.first);
113 info.fNElements += columnRange.fNElements;
114 if (compression == -1) {
115 compression = columnRange.fCompressionSettings;
116 }
117 const auto &pageRange = cluster.second.GetPageRange(column.first);
118 auto idx = cluster2Idx[cluster.first];
119 for (const auto &page : pageRange.fPageInfos) {
120 bytesOnStorage += page.fLocator.fBytesOnStorage;
121 bytesInMemory += page.fNElements * elementSize;
122 clusters[idx].fBytesOnStorage += page.fLocator.fBytesOnStorage;
123 clusters[idx].fBytesInMemory += page.fNElements * elementSize;
124 ++clusters[idx].fNPages;
125 info.fBytesOnStorage += page.fLocator.fBytesOnStorage;
126 ++info.fNPages;
127 ++nPages;
128 }
129 }
130 columns.emplace_back(info);
131 }
132 auto headerSize = GetOnDiskHeaderSize();
133 auto footerSize = GetOnDiskFooterSize();
134 output << "============================================================" << std::endl;
135 output << "NTUPLE: " << GetName() << std::endl;
136 output << "Compression: " << compression << std::endl;
137 output << "------------------------------------------------------------" << std::endl;
138 output << " # Entries: " << GetNEntries() << std::endl;
139 output << " # Fields: " << GetNFields() << std::endl;
140 output << " # Columns: " << GetNColumns() << std::endl;
141 output << " # Pages: " << nPages << std::endl;
142 output << " # Clusters: " << GetNClusters() << std::endl;
143 output << " Size on storage: " << bytesOnStorage << " B" << std::endl;
144 output << " Compression rate: " << std::fixed << std::setprecision(2)
145 << float(bytesInMemory) / float(bytesOnStorage) << std::endl;
146 output << " Header size: " << headerSize << " B" << std::endl;
147 output << " Footer size: " << footerSize << " B" << std::endl;
148 output << " Meta-data / data: " << std::fixed << std::setprecision(3)
149 << float(headerSize + footerSize) / float(bytesOnStorage) << std::endl;
150 output << "------------------------------------------------------------" << std::endl;
151 output << "CLUSTER DETAILS" << std::endl;
152 output << "------------------------------------------------------------" << std::endl;
153
154 std::sort(clusters.begin(), clusters.end());
155 for (unsigned int i = 0; i < clusters.size(); ++i) {
156 output << " # " << std::setw(5) << i
157 << " Entry range: [" << clusters[i].fFirstEntry << ".."
158 << clusters[i].fFirstEntry + clusters[i].fNEntries - 1 << "] -- " << clusters[i].fNEntries << std::endl;
159 output << " "
160 << " # Pages: " << clusters[i].fNPages << std::endl;
161 output << " "
162 << " Size on storage: " << clusters[i].fBytesOnStorage << " B" << std::endl;
163 output << " "
164 << " Compression: " << std::fixed << std::setprecision(2)
165 << float(clusters[i].fBytesInMemory) / float(float(clusters[i].fBytesOnStorage)) << std::endl;
166 }
167
168 output << "------------------------------------------------------------" << std::endl;
169 output << "COLUMN DETAILS" << std::endl;
170 output << "------------------------------------------------------------" << std::endl;
171 for (auto &col : columns) {
172 col.fFieldName = GetFieldName(col.fFieldId, *this).substr(1);
173 col.fFieldDescription = GetFieldDescription(col.fFieldId, *this);
174 }
175 std::sort(columns.begin(), columns.end());
176 for (const auto &col : columns) {
177 auto avgPageSize = (col.fNPages == 0) ? 0 : (col.fBytesOnStorage / col.fNPages);
178 auto avgElementsPerPage = (col.fNPages == 0) ? 0 : (col.fNElements / col.fNPages);
179 std::string nameAndType = std::string(" ") + col.fFieldName + " [#" + std::to_string(col.fLocalOrder) + "]"
180 + " -- " + Detail::RColumnElementBase::GetTypeName(col.fType);
181 std::string id = std::string("{id:") + std::to_string(col.fColumnId) + "}";
182 output << nameAndType << std::setw(60 - nameAndType.length()) << id << std::endl;
183 if (!col.fFieldDescription.empty())
184 output << " Description: " << col.fFieldDescription << std::endl;
185 output << " # Elements: " << col.fNElements << std::endl;
186 output << " # Pages: " << col.fNPages << std::endl;
187 output << " Avg elements / page: " << avgElementsPerPage << std::endl;
188 output << " Avg page size: " << avgPageSize << " B" << std::endl;
189 output << " Size on storage: " << col.fBytesOnStorage << " B" << std::endl;
190 output << " Compression: " << std::fixed << std::setprecision(2)
191 << float(col.fElementSize * col.fNElements) / float(col.fBytesOnStorage) << std::endl;
192 output << "............................................................" << std::endl;
193 }
194}
Bool_t operator<(const TDatime &d1, const TDatime &d2)
Definition: TDatime.h:106
Bool_t operator==(const TDatime &d1, const TDatime &d2)
Definition: TDatime.h:102
static std::unique_ptr< RColumnElementBase > Generate(EColumnType type)
static std::string GetTypeName(EColumnType type)
The available trivial, native content types of a column.
The on-storage meta-data of an ntuple.
std::unordered_map< DescriptorId_t, RClusterDescriptor > fClusterDescriptors
May contain only a subset of all the available clusters, e.g.
std::unordered_map< DescriptorId_t, RColumnDescriptor > fColumnDescriptors
NTupleSize_t GetNEntries() const
We know the number of entries from adding the cluster summaries.
const RFieldDescriptor & GetFieldDescriptor(DescriptorId_t fieldId) const
void PrintInfo(std::ostream &output) const
std::uint64_t DescriptorId_t
Distriniguishes elements of the same type within a descriptor, e.g. different fields.
Definition: RNTupleUtil.hxx:83
constexpr DescriptorId_t kInvalidDescriptorId
Definition: RNTupleUtil.hxx:84
static void output()