314 fBrNames(new
TList), fTree(
tree), fPrefillType(GetConfiguredPrefillType())
317 Int_t nleaves =
tree->GetListOfLeaves()->GetEntries();
381 const char *bname =
b->GetName();
389 const char *mothername =
b->GetMother()->GetName();
390 if (
b !=
b->GetMother() && mothername[strlen(mothername)-1] !=
'.') {
393 if (bem->GetType() < 3) {
397 if (strncmp(bname,build.
Data(),build.
Length()) != 0) {
399 bname = build.
Data();
406 if (
gDebug > 0) printf(
"Entry: %lld, registering branch: %s\n",
b->GetTree()->GetReadEntry(),
b->GetName());
414 for (
Int_t j = 0; j < nb; j++) {
416 if (!branch)
continue;
441 TLeaf *leaf, *leafcount;
452 if (!strcmp(bname,
"*")) all =
kTRUE;
453 for (i=0;i<nleaves;i++) {
460 if (strcmp(bname,branch->
GetName())
462 &&
s.Index(re) ==
kNPOS)
continue;
469 if (leafcount && !all) {
476 if (nb==0 && strchr(bname,
'*')==0) {
497 char *subbranch = (
char*)strstr(bname,fe->
GetName());
498 if (subbranch!=bname) subbranch = 0;
500 subbranch += strlen(fe->
GetName());
501 if ( *subbranch !=
'.' ) subbranch = 0;
513 if (!nb && !foundInFriend) {
514 if (
gDebug > 0) printf(
"AddBranch: unknown branch -> %s \n", bname);
515 Error(
"AddBranch",
"unknown branch -> %s", bname);
545 if (
gDebug > 0) printf(
"Entry: %lld, un-registering branch: %s\n",
b->GetTree()->GetReadEntry(),
b->GetName());
554 for (
Int_t j = 0; j < nb; j++) {
556 if (!branch)
continue;
581 TLeaf *leaf, *leafcount;
592 if (!strcmp(bname,
"*")) all =
kTRUE;
593 for (i=0;i<nleaves;i++) {
600 if (strcmp(bname,branch->
GetName())
602 &&
s.Index(re) ==
kNPOS)
continue;
609 if (leafcount && !all) {
616 if (nb==0 && strchr(bname,
'*')==0) {
637 char *subbranch = (
char*)strstr(bname,fe->
GetName());
638 if (subbranch!=bname) subbranch = 0;
640 subbranch += strlen(fe->
GetName());
641 if ( *subbranch !=
'.' ) subbranch = 0;
653 if (!nb && !foundInFriend) {
654 if (
gDebug > 0) printf(
"DropBranch: unknown branch -> %s \n", bname);
655 Error(
"DropBranch",
"unknown branch -> %s", bname);
722 Int_t *lbaskets =
b.GetBasketBytes();
729 Int_t blistsize =
b.GetWriteBasket();
738 if (basketOffset < 0) {
744 if ((basketOffset < blistsize) &&
b.GetListOfBaskets()->UncheckedAt(basketOffset)) {
750 Long64_t pos =
b.GetBasketSeek(basketOffset);
751 Int_t len = lbaskets[basketOffset];
792 TBranch *resultBranch =
nullptr;
795 std::vector<std::pair<size_t, Int_t>> basketsInfo;
799 for (
int i = 0; i < count; i++) {
804 if (iopos.fLen == 0) {
807 if (iopos.fPos == pos && iopos.fLen == len) {
808 found_request =
kTRUE;
813 fMissCache->fEntries.emplace_back(std::move(iopos));
816 Int_t blistsize =
b->GetWriteBasket();
817 Int_t basketNumber = -1;
818 for (
Int_t bn = 0; bn < blistsize; ++bn) {
819 if (iopos.fPos ==
b->GetBasketSeek(bn)) {
824 if (basketNumber >= 0)
825 basketsInfo.emplace_back((
size_t)i, basketNumber);
834 for (
auto &info : basketsInfo) {
835 perfStats->SetLoadedMiss(info.first, info.second);
886 std::vector<Long64_t> positions;
887 positions.reserve(
fMissCache->fEntries.size());
888 std::vector<Int_t> lengths;
892 positions.push_back(mcentry.fIO.fPos);
893 lengths.push_back(mcentry.fIO.fLen);
894 mcentry.fIndex = cumulative;
895 cumulative += mcentry.fIO.fLen;
927 auto iter = std::lower_bound(
fMissCache->fEntries.begin(),
fMissCache->fEntries.end(), mcentry);
930 if (len > iter->fIO.fLen) {
934 auto offset = iter->fIndex;
935 memcpy(buf, &(
fMissCache->fData[offset]), len);
955 auto offset = iter->fIndex;
957 memcpy(buf, &(
fMissCache->fData[offset]), len);
978 Range() : fMin(-1), fMax(-1) {}
982 if (fMin == -1 || min < fMin)
988 if (fMax == -1 || fMax < max)
992 Bool_t Contains(
Long64_t entry) {
return (fMin <= entry && entry <= fMax); }
995 std::vector<Range> fRanges;
996 std::map<Long64_t,size_t> fMinimums;
997 std::map<Long64_t,size_t> fMaximums;
999 BasketRanges(
size_t nBranches) { fRanges.resize(nBranches); }
1003 Range &range = fRanges.at(branchNumber);
1006 range.UpdateMin(min);
1007 range.UpdateMax(max);
1009 if (old.fMax != range.fMax) {
1010 if (old.fMax != -1) {
1011 auto maxIter = fMaximums.find(old.fMax);
1012 if (maxIter != fMaximums.end()) {
1013 if (maxIter->second == 1) {
1014 fMaximums.erase(maxIter);
1016 --(maxIter->second);
1024 void Update(
size_t branchNumber,
size_t basketNumber,
Long64_t *entries,
size_t nb,
size_t max)
1026 Update(branchNumber, entries[basketNumber],
1027 (basketNumber < (nb - 1)) ? (entries[basketNumber + 1] - 1) : max - 1);
1031 bool CheckAllIncludeRange()
1034 for (
const auto &
r : fRanges) {
1035 if (result.fMin == -1 || result.fMin <
r.fMin) {
1037 result.fMin =
r.fMin;
1039 if (result.fMax == -1 ||
r.fMax < result.fMax) {
1041 result.fMax =
r.fMax;
1048 Range allIncludedRange(AllIncludedRange());
1050 return (result.fMin == allIncludedRange.fMin && result.fMax == allIncludedRange.fMax);
1060 Range AllIncludedRange()
1063 if (!fMinimums.empty())
1064 result.fMin = fMinimums.rbegin()->first;
1065 if (!fMaximums.empty())
1066 result.fMax = fMaximums.begin()->first;
1071 UInt_t BranchesRegistered()
1074 for (
const auto &
r : fRanges) {
1075 if (
r.fMin != -1 &&
r.fMax != -1)
1085 for (
const auto &
r : fRanges) {
1086 if (
r.fMin != -1 &&
r.fMax != -1)
1087 if (
r.fMin <= entry && entry <=
r.fMax)
1095 for (
size_t i = 0; i < fRanges.size(); ++i) {
1096 if (fRanges[i].fMin != -1 || fRanges[i].fMax != -1)
1097 Printf(
"Range #%zu : %lld to %lld", i, fRanges[i].fMin, fRanges[i].fMax);
1155 if (entry < 0) entry = 0;
1161 if (entry < 0)
return kFALSE;
1167 if (entry < 0 && fEntryNext > 0) {
1187 static constexpr bool showMore =
kFALSE;
1189 static const auto PrintAllCacheInfo = [](
TObjArray *branches) {
1190 for (
Int_t i = 0; i < branches->GetEntries(); i++) {
1192 b->PrintCacheInfo();
1196 if (showMore ||
gDebug > 6)
1197 Info(
"FillBuffer",
"***** Called for entry %lld", entry);
1205 if (!
b->fCacheInfo.AllUsed()) {
1212 if (showMore ||
gDebug > 5)
1213 Info(
"FillBuffer",
"All baskets used already, so refresh the cache early at entry %lld", entry);
1232 resetBranchInfo =
kTRUE;
1233 if (showMore ||
gDebug > 6)
1234 Info(
"FillBuffer",
"*** Will reset the branch information about baskets");
1235 }
else if (showMore ||
gDebug > 6) {
1236 Info(
"FillBuffer",
"*** Info we have on the set of baskets");
1243 auto entryCurrent = clusterIter();
1258 if (showMore ||
gDebug > 6)
1272 if (resetBranchInfo) {
1275 if (!(fEntryCurrent < fCurrentClusterStart || fEntryCurrent >=
fNextClusterStart)) {
1276 Error(
"FillBuffer",
"Inconsistency: fCurrentClusterStart=%lld fEntryCurrent=%lld fNextClusterStart=%lld "
1277 "but fEntryCurrent should not be in between the two",
1301 Int_t ntotCurrentBuf = 0;
1305 ntotCurrentBuf =
fNtot;
1314 ntotCurrentBuf =
fNtot;
1321 Int_t clusterIterations = 0;
1325 Int_t nReadPrefRequest = 0;
1328 prevNtot = ntotCurrentBuf;
1331 struct collectionInfo {
1332 Int_t fClusterStart{-1};
1336 void Rewind() { fCurrent = (fClusterStart >= 0) ? fClusterStart : 0; }
1338 std::vector<collectionInfo> cursor(
fNbranches);
1342 Int_t nDistinctLoad = 0;
1354 auto CollectBaskets = [
this, elist, chainOffset, entry, clusterIterations, resetBranchInfo, perfStats,
1355 &cursor, &lowestMaxEntry, &maxReadEntry, &minEntry,
1356 &reachedEnd, &skippedFirst, &oncePerBranch, &nDistinctLoad, &progress,
1357 &ranges, &memRanges, &reqRanges,
1358 &ntotCurrentBuf, &nReadPrefRequest](EPass pass, ENarrow narrow,
Long64_t maxCollectEntry) {
1362 Int_t nReachedEnd = 0;
1364 auto oldnReadPrefRequest = nReadPrefRequest;
1365 std::vector<Int_t> potentialVetoes;
1367 if (showMore ||
gDebug > 7)
1368 Info(
"CollectBaskets",
"Called with pass=%d narrow=%d maxCollectEntry=%lld", pass, narrow, maxCollectEntry);
1375 if (
b->GetDirectory()->GetFile() !=
fFile)
1377 potentialVetoes.clear();
1378 if (pass == kStart && !cursor[i].fLoadedOnce && resetBranchInfo) {
1382 b->fCacheInfo.GetUnused(potentialVetoes);
1383 if (showMore ||
gDebug > 7) {
1385 for(
auto v : potentialVetoes) {
1389 if (!potentialVetoes.empty())
1390 Info(
"FillBuffer",
"*** Potential Vetos for branch #%d: %s", i, vetolist.
Data());
1392 b->fCacheInfo.Reset();
1394 Int_t nb =
b->GetMaxBaskets();
1395 Int_t *lbaskets =
b->GetBasketBytes();
1396 Long64_t *entries =
b->GetBasketEntry();
1397 if (!lbaskets || !entries)
1401 Int_t blistsize =
b->GetListOfBaskets()->GetSize();
1403 auto maxOfBasket = [
this, nb, entries](
int j) {
1404 return ((j < (nb - 1)) ? (entries[j + 1] - 1) :
fEntryMax - 1);
1407 if (pass == kRewind)
1409 for (
auto &j = cursor[i].fCurrent; j < nb; j++) {
1412 if (j < blistsize && b->GetListOfBaskets()->UncheckedAt(j)) {
1414 if (showMore ||
gDebug > 6) {
1415 ranges.Update(i, entries[j], maxOfBasket(j));
1416 memRanges.Update(i, entries[j], maxOfBasket(j));
1418 if (entries[j] <= entry && entry <= maxOfBasket(j)) {
1419 b->fCacheInfo.SetIsInCache(j);
1420 b->fCacheInfo.SetUsed(j);
1434 if (entries[j] >= maxCollectEntry) {
1440 Int_t len = lbaskets[j];
1441 if (pos <= 0 || len <= 0)
1445 if ((showMore ||
gDebug > 7) &&
1446 (!(entries[j] < minEntry && (j < nb - 1 && entries[j + 1] <= minEntry))))
1447 Info(
"FillBuffer",
"Skipping branch %s basket %d is too large for the cache: %d > %d",
1452 if (nReadPrefRequest && entries[j] > (reqRanges.AllIncludedRange().fMax + 1)) {
1462 if (showMore ||
gDebug > 8)
1463 Info(
"FillBuffer",
"Skipping for now due to gap %d/%d with %lld > %lld", i, j, entries[j],
1464 (reqRanges.AllIncludedRange().fMax + 1));
1468 if (entries[j] < minEntry && (j<nb-1 && entries[j+1] <= minEntry))
1472 if (cursor[i].fClusterStart == -1)
1473 cursor[i].fClusterStart = j;
1478 emax = entries[j + 1] - 1;
1479 if (!elist->
ContainsRange(entries[j]+chainOffset,emax+chainOffset))
1483 if (
b->fCacheInfo.HasBeenUsed(j) ||
b->fCacheInfo.IsInCache(j) ||
b->fCacheInfo.IsVetoed(j)) {
1486 if (showMore ||
gDebug > 7)
1487 Info(
"FillBuffer",
"Skipping basket to avoid redo: %d/%d veto: %d", i, j,
b->fCacheInfo.IsVetoed(j));
1491 if (std::find(std::begin(potentialVetoes), std::end(potentialVetoes), j) != std::end(potentialVetoes)) {
1498 b->fCacheInfo.Veto(j);
1499 if (showMore ||
gDebug > 7)
1500 Info(
"FillBuffer",
"Veto-ing cluster %d [%lld,%lld[ in branch %s #%d", j, entries[j],
1501 maxOfBasket(j) + 1,
b->GetName(), i);
1506 if ((((entries[j] > entry)) || (j < nb - 1 && entries[j + 1] <= entry))) {
1508 if (j == cursor[i].fClusterStart && entry > entries[j])
1510 if (entries[j] > entry)
1519 if (clusterIterations > 0 && cursor[i].fLoadedOnce) {
1523 if (showMore ||
gDebug > 5) {
1526 "Breaking early because %d is greater than %d at cluster iteration %d will restart at %lld",
1527 (ntotCurrentBuf + len),
fBufferSizeMin, clusterIterations, minEntry);
1533 if (pass == kStart || !cursor[i].fLoadedOnce) {
1541 if (showMore ||
gDebug > 5) {
1542 Info(
"FillBuffer",
"Breaking early because %d is greater than 4*%d at cluster iteration "
1543 "%d pass %d will restart at %lld",
1555 if (showMore ||
gDebug > 5) {
1556 Info(
"FillBuffer",
"Breaking early because %d is greater than 2*%d at cluster iteration "
1557 "%d pass %d will restart at %lld",
1569 reqRanges.Update(i, j, entries, nb,
fEntryMax);
1570 if (showMore ||
gDebug > 6)
1571 ranges.Update(i, j, entries, nb,
fEntryMax);
1573 b->fCacheInfo.SetIsInCache(j);
1575 if (showMore ||
gDebug > 6)
1576 Info(
"FillBuffer",
"*** Registering branch %d basket %d %s", i, j,
b->GetName());
1578 if (!cursor[i].fLoadedOnce) {
1579 cursor[i].fLoadedOnce =
kTRUE;
1583 perfStats->SetLoaded(i, j);
1590 ntotCurrentBuf =
fNtot;
1599 ntotCurrentBuf =
fNtot;
1602 if ( ( j < (nb-1) ) && entries[j+1] > maxReadEntry ) {
1604 maxReadEntry = entries[j+1];
1608 Warning(
"FillBuffer",
"There is more data in this cluster (starting at entry %lld to %lld, "
1609 "current=%lld) than usual ... with %d %.3f%% of the branches we already have "
1610 "%d bytes (instead of %d)",
1614 if (pass == kStart) {
1616 auto high = maxOfBasket(j);
1617 if (high < lowestMaxEntry)
1618 lowestMaxEntry = high;
1622 }
else if ((j + 1) == nb || entries[j + 1] >= maxReadEntry || entries[j + 1] >= lowestMaxEntry) {
1624 auto high = maxOfBasket(j);
1625 if (high < lowestMaxEntry)
1626 lowestMaxEntry = high;
1633 if (cursor[i].fCurrent == nb) {
1638 Info(
"CollectBaskets",
1639 "Entry: %lld, registering baskets branch %s, fEntryNext=%lld, fNseek=%d, ntotCurrentBuf=%d",
1643 skippedFirst = (nSkipped > 0);
1644 oncePerBranch = (nDistinctLoad ==
fNbranches);
1645 progress = nReadPrefRequest - oldnReadPrefRequest;
1652 full = CollectBaskets(kStart, kNarrow,
fEntryNext);
1656 while (!full && !reachedEnd && progress) {
1657 full = CollectBaskets(kStart, kFull, std::min(maxReadEntry,
fEntryNext));
1660 resetBranchInfo =
kFALSE;
1665 full = CollectBaskets(kRegular, kFull,
fEntryNext);
1666 }
while (!full && !reachedEnd && progress);
1670 if (!full && skippedFirst) {
1671 full = CollectBaskets(kRewind, kFull,
fEntryNext);
1672 while (!full && !reachedEnd && progress) {
1673 full = CollectBaskets(kRegular, kFull,
fEntryNext);
1677 clusterIterations++;
1679 minEntry = clusterIter.
Next();
1697 (prevNtot < ntotCurrentBuf) && (minEntry <
fEntryMax))) {
1698 if (showMore ||
gDebug > 6)
1699 Info(
"FillBuffer",
"Breaking because %d <= %lld || (%d >= %d) || %lld >= %lld",
fBufferSizeMin,
1700 ((
Long64_t)ntotCurrentBuf * (clusterIterations + 1)) / clusterIterations, prevNtot, ntotCurrentBuf,
1709 if (minEntry >= fEntryCurrentMax && fEntryCurrentMax > 0)
1717 if (showMore ||
gDebug > 6) {
1718 Info(
"FillBuffer",
"Mem ranges");
1720 Info(
"FillBuffer",
"Combined ranges");
1722 Info(
"FillBuffer",
"Requested ranges");
1727 if (nReadPrefRequest == 0) {
1731 if (showMore ||
gDebug > 5) {
1732 Info(
"FillBuffer",
"For entry %lld, nothing was added to the cache.", entry);
1734 }
else if (
fEntryNext < firstClusterEnd && !reqRanges.Contains(entry)) {
1746 if (showMore ||
gDebug > 5) {
1747 Error(
"FillBuffer",
"Reset the next entry because the currently loaded range does not contains the request "
1748 "entry: %lld. fEntryNext updated from %lld to %lld. %d",
1749 entry,
fEntryNext, firstClusterEnd, nReadPrefRequest);
1755 if (showMore ||
gDebug > 5) {
1756 Info(
"FillBuffer",
"Complete adding %d baskets from %d branches taking in memory %d out of %d",
1757 nReadPrefRequest, reqRanges.BranchesRegistered(), ntotCurrentBuf,
fBufferSizeMin);
1786 if (!(stcp =
gSystem->
Getenv(
"ROOT_TTREECACHE_PREFILL")) || !*stcp) {
1884 printf(
"Number of branches in the cache ...: %d\n",
fNbranches);
1885 printf(
"Cache Efficiency ..................: %f\n",
GetEfficiency());
1890 if ( opt.
Contains(
"cachedbranches") ) {
1892 printf(
"Cached branches....................:\n");
1895 for (
Int_t i = 0; i < nbranches; ++i) {
1897 printf(
"Branch name........................: %s\n",branch->
GetName());
1916 ::Info(
"TTreeCache::ReadBufferNormal",
"Cache miss after an %s FillBuffer: pos=%lld",
1917 bufferFilled ?
"active" :
"inactive", basketpos);
1918 for (
Int_t i = 0; i < branches->GetEntries(); ++i) {
1920 Int_t blistsize =
b->GetListOfBaskets()->GetSize();
1921 for (
Int_t j = 0; j < blistsize; ++j) {
1922 if (basketpos ==
b->GetBasketSeek(j)) {
1924 ::Info(
"TTreeCache::ReadBufferNormal",
" Missing basket: %d for %s", j,
b->GetName());
1938 else if (res == 0) {
1942 recordMiss(perfStats,
fBranches, bufferFilled, pos);
1955 recordMiss(perfStats,
fBranches, bufferFilled, pos);
2025 if (
b->GetDirectory()->GetFile() !=
fFile)
2027 b->fCacheInfo.Reset();
2059 if (res == 0 && buffersize <= prevsize) {
2094 Info(
"SetEntryRange",
"fEntryMin=%lld, fEntryMax=%lld, fEntryNext=%lld",
2097 if (needLearningStart) {
2245 if (entry < fEntryMin || entry >
fEntryMax)
return;
#define R__unlikely(expr)
unsigned long long ULong64_t
void Printf(const char *fmt,...)
R__EXTERN TSystem * gSystem
A Branch for the case of an object.
A TTree is a list of TBranches.
A chain is a collection of files containing TTree objects.
virtual Int_t GetTreeNumber() const
Long64_t * GetTreeOffset() const
virtual Int_t GetEntries() const
virtual Int_t GetValue(const char *name, Int_t dflt) const
Returns the integer value for a resource.
A TEventList object is a list of selected events (entries) in a TTree.
virtual Bool_t ContainsRange(Long64_t entrymin, Long64_t entrymax)
Return TRUE if list contains entries from entrymin to entrymax included.
A cache when reading files over the network.
virtual Int_t SetBufferSize(Int_t buffersize)
Sets the buffer size.
virtual Int_t ReadBuffer(char *buf, Long64_t pos, Int_t len)
Read buffer at position pos.
virtual void SecondPrefetch(Long64_t, Int_t)
virtual void Print(Option_t *option="") const
Print cache statistics.
Bool_t fEnablePrefetching
reading by prefetching asynchronously
Int_t fNtot
Total size of prefetched blocks.
virtual void Prefetch(Long64_t pos, Int_t len)
Add block of length len at position pos in the list of blocks to be prefetched.
Int_t fBufferSizeMin
Original size of fBuffer.
Bool_t fIsTransferred
True when fBuffer contains something valid.
TFile * fFile
Pointer to file.
Int_t fNseek
Number of blocks to be prefetched.
virtual Int_t GetBufferSize() const
virtual void SetFile(TFile *file, TFile::ECacheAction action=TFile::kDisconnect)
Set the file using this cache and reset the current blocks (if any).
A ROOT file is a suite of consecutive data records (TKey instances) with a well defined format.
virtual Bool_t ReadBuffers(char *buf, Long64_t *pos, Int_t *len, Int_t nbuf)
Read the nbuf blocks described in arrays pos and len.
ECacheAction
TTreeCache flushing semantics.
virtual void SetCacheRead(TFileCacheRead *cache, TObject *tree=0, ECacheAction action=kDisconnect)
Set a pointer to the read cache.
A TFriendElement TF describes a TTree object TF in a file.
virtual TTree * GetTree()
Return pointer to friend TTree.
A TLeaf describes individual elements of a TBranch See TBranch structure in TTree.
virtual TLeaf * GetLeafCount() const
If this leaf stores a variable-sized array or a multi-dimensional array whose last dimension has vari...
TBranch * GetBranch() const
virtual void Add(TObject *obj)
virtual TObject * Remove(TObject *obj)
Remove object from the list.
virtual TObject * FindObject(const char *name) const
Find an object in this list using its name.
virtual void Delete(Option_t *option="")
Remove all objects from the list AND delete all heap based objects.
virtual const char * GetName() const
Returns name of object.
Int_t GetEntriesFast() const
virtual void AddAtAndExpand(TObject *obj, Int_t idx)
Add object at position idx.
TObject * UncheckedAt(Int_t i) const
virtual TObject * Remove(TObject *obj)
Remove object from array.
virtual void AddAt(TObject *obj, Int_t idx)
Add object at position ids.
Collectable string class.
const char * GetName() const
Returns name of object.
virtual void Warning(const char *method, const char *msgfmt,...) const
Issue warning message.
virtual void Error(const char *method, const char *msgfmt,...) const
Issue error message.
virtual void Info(const char *method, const char *msgfmt,...) const
Issue info message.
Regular expression class.
void ToLower()
Change string to lower-case.
Int_t Atoi() const
Return integer value of string.
const char * Data() const
TString & ReplaceAll(const TString &s1, const TString &s2)
TString & Append(const char *cs)
void Form(const char *fmt,...)
Formats a string using a printf style format descriptor.
Bool_t Contains(const char *pat, ECaseCompare cmp=kExact) const
virtual const char * Getenv(const char *env)
Get environment variable.
A cache to speed-up the reading of ROOT datasets.
virtual Int_t AddBranch(TBranch *b, Bool_t subgbranches=kFALSE)
Add a branch to the list of branches to be stored in the cache this function is called by the user vi...
virtual void SetLearnPrefill(EPrefillType type=kNoPrefill)
Set whether the learning period is started with a prefilling of the cache and which type of prefillin...
virtual void UpdateBranches(TTree *tree)
Update pointer to current Tree and recompute pointers to the branches in the cache.
void SetOptimizeMisses(Bool_t opt)
Start of methods for the miss cache.
Double_t GetEfficiencyRel() const
This will indicate a sort of relative efficiency... a ratio of the reads found in the cache to the nu...
Bool_t fReverseRead
! reading in reverse mode
Bool_t fLearnPrefilling
! true if we are in the process of executing LearnPrefill
Long64_t fLastMiss
! set to the event # of the last miss.
Int_t fNMissReadPref
Number of blocks read into the secondary ("miss") cache.
virtual Int_t SetBufferSize(Int_t buffersize)
Change the underlying buffer size of the cache.
Int_t fNMissReadOk
Number of blocks read, not found in the primary cache, and found in the secondary cache.
Bool_t fOneTime
! used in the learning phase
virtual void SetFile(TFile *file, TFile::ECacheAction action=TFile::kDisconnect)
Overload to make sure that the object specific.
Long64_t fEntryMin
! first entry in the cache
virtual Bool_t FillBuffer()
Fill the cache buffer with the branches in the cache.
Bool_t ProcessMiss(Long64_t pos, int len)
! Given a file read not in the miss cache, handle (possibly) loading the data.
static void SetLearnEntries(Int_t n=10)
Static function to set the number of entries to be used in learning mode The default value for n is 1...
Long64_t fEntryNext
! next entry number where cache must be filled
Int_t fNReadMiss
Number of blocks read and not found in the cache.
Double_t GetEfficiency() const
Give the total efficiency of the primary cache... defined as the ratio of blocks found in the cache v...
Bool_t fEnabled
! cache enabled for cached reading
Bool_t fIsLearning
! true if cache is in learning mode
Long64_t fNextClusterStart
! End+1 of the cluster(s) where the current content was picked out
const TObjArray * GetCachedBranches() const
virtual ~TTreeCache()
Destructor. (in general called by the TFile destructor)
Bool_t CheckMissCache(char *buf, Long64_t pos, int len)
Check the miss cache for a particular buffer, fetching if deemed necessary.
Int_t fNMissReadMiss
Number of blocks read and not found in either cache.
IOPos FindBranchBasketPos(TBranch &, Long64_t entry)
Given a branch and an entry, determine the file location (offset / size) of the corresponding basket.
virtual void SetEntryRange(Long64_t emin, Long64_t emax)
Set the minimum and maximum entry number to be processed this information helps to optimize the numbe...
TTreeCache()
Default Constructor.
std::unique_ptr< MissCache > fMissCache
! Cache contents for misses
Bool_t fFirstTime
! save the fact that we processes the first entry
void StartLearningPhase()
The name should be enough to explain the method.
virtual Int_t LearnBranch(TBranch *b, Bool_t subgbranches=kFALSE)
Add a branch discovered by actual usage to the list of branches to be stored in the cache this functi...
Bool_t fReadDirectionSet
! read direction established
TBranch * CalculateMissEntries(Long64_t, int, bool)
Given an file read, try to determine the corresponding branch.
Long64_t fCurrentClusterStart
! Start of the cluster(s) where the current content was picked out
Double_t GetMissEfficiency() const
The total efficiency of the 'miss cache' - defined as the ratio of blocks found in the cache versus t...
virtual Int_t ReadBufferNormal(char *buf, Long64_t pos, Int_t len)
Old method ReadBuffer before the addition of the prefetch mechanism.
virtual void ResetCache()
This will simply clear the cache.
Bool_t fIsManual
! true if cache is StopLearningPhase was used
EPrefillType fPrefillType
Whether a pre-filling is enabled (and if applicable which type)
virtual void LearnPrefill()
Perform an initial prefetch, attempting to read as much of the learning phase baskets for all branche...
virtual Int_t ReadBuffer(char *buf, Long64_t pos, Int_t len)
Read buffer at position pos if the request is in the list of prefetched blocks read from fBuffer.
Long64_t fEntryMax
! last entry in the cache
static Int_t fgLearnEntries
number of entries used for learning mode
virtual Int_t DropBranch(TBranch *b, Bool_t subbranches=kFALSE)
Remove a branch to the list of branches to be stored in the cache this function is called by TBranch:...
virtual Int_t ReadBufferPrefetch(char *buf, Long64_t pos, Int_t len)
Used to read a chunk from a block previously fetched.
Long64_t fEntryCurrent
! current lowest entry number in the cache
void ResetMissCache()
Reset all the miss cache training.
Long64_t fFirstMiss
! set to the event # of the first miss.
Double_t GetMissEfficiencyRel() const
Relative efficiency of the 'miss cache' - ratio of the reads found in cache to the number of reads so...
Long64_t fFirstEntry
! save the value of the first entry
Int_t fFillTimes
! how many times we can fill the current buffer
Int_t fNReadPref
Number of blocks that were prefetched.
TTree * fTree
! pointer to the current Tree
EPrefillType GetConfiguredPrefillType() const
Return the desired prefill type from the environment or resource variable.
Bool_t fFirstBuffer
! true if first buffer is used for prefetching
static Int_t GetLearnEntries()
Static function returning the number of entries used to train the cache see SetLearnEntries.
virtual void StopLearningPhase()
This is the counterpart of StartLearningPhase() and can be used to stop the learning phase.
Bool_t fOptimizeMisses
! true if we should optimize cache misses.
Int_t fNbranches
! Number of branches in the cache
Int_t fNReadOk
Number of blocks read and found in the cache.
virtual void Print(Option_t *option="") const
Print cache statistics.
TObjArray * fBranches
! List of branches to be stored in the cache
TList * fBrNames
! list of branch names in the cache
Helper class to iterate over cluster of baskets.
Long64_t Next()
Move on to the next cluster and return the starting entry of this next cluster.
A TTree represents a columnar dataset.
virtual TVirtualPerfStats * GetPerfStats() const
virtual TBranch * GetBranch(const char *name)
Return pointer to the branch with the given name in this tree or its friends.
virtual TObjArray * GetListOfLeaves()
virtual Long64_t GetEntries() const
virtual Long64_t GetReadEntry() const
virtual TTree * GetTree() const
TEventList * GetEventList() const
virtual TList * GetListOfFriends() const
Provides the interface for the PROOF internal performance measurement and event tracing.
virtual void SetMissed(TBranch *b, size_t basketNumber)=0
virtual void UpdateBranchIndices(TObjArray *branches)=0
void Print(std::ostream &os, const OptionType &opt)
static constexpr double s
Long64_t BinarySearch(Long64_t n, const T *array, T value)