ROOT logo
// @(#)root/io:$Id: TFileCacheRead.cxx 31457 2009-11-30 13:36:37Z brun $
// Author: Rene Brun   18/05/2006

/*************************************************************************
 * Copyright (C) 1995-2000, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TFileCacheRead : a cache when reading files over the network         //
//                                                                      //
// A caching system to speed up network I/O, i.e. when there is         //
// no operating system caching support (like the buffer cache for       //
// local disk I/O). The cache makes sure that every I/O is done with    //
// a (large) fixed length buffer thereby avoiding many small I/O's.     //
// Currently the read cache system is used by the classes TNetFile,     //
// TXNetFile and TWebFile (via TFile::ReadBuffers()).                   //
//                                                                      //
// When processing TTree, TChain, a specialized class TTreeCache that   //
// derives from this class is automatically created.                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TEnv.h"
#include "TFile.h"
#include "TFileCacheRead.h"
#include "TFileCacheWrite.h"
#include "TMath.h"

ClassImp(TFileCacheRead)

//______________________________________________________________________________
TFileCacheRead::TFileCacheRead() : TObject()
{
   // Default Constructor.

   fBufferSizeMin = 0;
   fBufferSize  = 0;
   fBufferLen   = 0;
   fNseek       = 0;
   fNtot        = 0;
   fNb          = 0;
   fSeekSize    = 0;
   fSeek        = 0;
   fSeekIndex   = 0;
   fSeekSort    = 0;
   fPos         = 0;
   fSeekLen     = 0;
   fSeekSortLen = 0;
   fSeekPos     = 0;
   fLen         = 0;
   fFile        = 0;
   fBuffer      = 0;
   fIsSorted    = kFALSE;
   fIsTransferred = kFALSE;

   fAsyncReading = kFALSE;
}

//_____________________________________________________________________________
TFileCacheRead::TFileCacheRead(TFile *file, Int_t buffersize)
           : TObject()
{
   // Creates a TFileCacheRead data structure.

   if (buffersize <=10000) fBufferSize = 100000;
   else fBufferSize = buffersize;

   fBufferSizeMin = fBufferSize;
   fBufferLen   = 0;
   fNseek       = 0;
   fNtot        = 0;
   fNb          = 0;
   fSeekSize    = 10000;
   fSeek        = new Long64_t[fSeekSize];
   fSeekIndex   = new Int_t[fSeekSize];
   fSeekSort    = new Long64_t[fSeekSize];
   fPos         = new Long64_t[fSeekSize];
   fSeekLen     = new Int_t[fSeekSize];
   fSeekSortLen = new Int_t[fSeekSize];
   fSeekPos     = new Int_t[fSeekSize];
   fLen         = new Int_t[fSeekSize];
   fFile        = file;

   fBuffer = 0;

   fAsyncReading = gEnv->GetValue("TFile.AsyncReading", 1);
   if (fAsyncReading) {
      // Check if asynchronous reading is supported by this TFile specialization
      fAsyncReading = kFALSE;
      if (file && !(file->ReadBufferAsync(0, 0)))
         fAsyncReading = kTRUE;
   }
   if (!fAsyncReading) {
      // we use sync primitives, hence we need the local buffer
      fBuffer = new char[fBufferSize];
   }

   fIsSorted    = kFALSE;
   fIsTransferred = kFALSE;
   if (file) file->SetCacheRead(this);
}

//_____________________________________________________________________________
TFileCacheRead::~TFileCacheRead()
{
   // Destructor.

   delete [] fSeek;
   delete [] fSeekIndex;
   delete [] fSeekSort;
   delete [] fPos;
   delete [] fSeekLen;
   delete [] fSeekSortLen;
   delete [] fSeekPos;
   delete [] fLen;
   delete [] fBuffer;
}

//_____________________________________________________________________________
void TFileCacheRead::Prefetch(Long64_t pos, Int_t len)
{
   // Add block of length len at position pos in the list of blocks to
   // be prefetched. If pos <= 0 the current blocks (if any) are reset.

   fIsSorted = kFALSE;
   fIsTransferred = kFALSE;
   if (pos <= 0) {
      fNseek = 0;
      fNtot  = 0;
      return;
   }
   if (fNseek >= fSeekSize) {
      //reallocate buffers
      fSeekSize *= 2;
      Long64_t *aSeek        = new Long64_t[fSeekSize];
      Int_t    *aSeekIndex   = new Int_t[fSeekSize];
      Long64_t *aSeekSort    = new Long64_t[fSeekSize];
      Long64_t *aPos         = new Long64_t[fSeekSize];
      Int_t    *aSeekLen     = new Int_t[fSeekSize];
      Int_t    *aSeekSortLen = new Int_t[fSeekSize];
      Int_t    *aSeekPos     = new Int_t[fSeekSize];
      Int_t    *aLen         = new Int_t[fSeekSize];
      for (Int_t i=0;i<fNseek;i++) {
         aSeek[i]        = fSeek[i];
         aSeekIndex[i]   = fSeekIndex[i];
         aSeekSort[i]    = fSeekSort[i];
         aPos[i]         = fPos[i];
         aSeekLen[i]     = fSeekLen[i];
         aSeekSortLen[i] = fSeekSortLen[i];
         aSeekPos[i]     = fSeekPos[i];
         aLen[i]         = fLen[i];
      }
      delete [] fSeek;
      delete [] fSeekIndex;
      delete [] fSeekSort;
      delete [] fPos;
      delete [] fSeekLen;
      delete [] fSeekSortLen;
      delete [] fSeekPos;
      delete [] fLen;
      fSeek        = aSeek;
      fSeekIndex   = aSeekIndex;
      fSeekSort    = aSeekSort;
      fPos         = aPos;
      fSeekLen     = aSeekLen;
      fSeekSortLen = aSeekSortLen;
      fSeekPos     = aSeekPos;
      fLen         = aLen;
   }

   fSeek[fNseek] = pos;
   fSeekLen[fNseek] = len;
   fNseek++;
   fNtot += len;
}

//_____________________________________________________________________________
void TFileCacheRead::Print(Option_t *option) const
{
   // Print cache statistics, like
   //   ******TreeCache statistics for file: cms2.root ******
   //   Reading 73921562 bytes in 716 transactions
   //   Average transaction = 103.242405 Kbytes
   //   Number of blocks in current cache: 202, total size : 6001193
   //
   // if option = "a" the list of blocks in the cache is printed
   
   TString opt = option;
   opt.ToLower();
   printf("******TreeCache statistics for file: %s ******\n",fFile->GetName());
   printf("Reading %lld bytes in %d transactions\n",fFile->GetBytesRead(),  fFile->GetReadCalls());
   printf("Readahead = %d bytes with overhead = %lld bytes\n",TFile::GetReadaheadSize(),fFile->GetBytesReadExtra());
   printf("Average transaction = %f Kbytes\n",0.001*Double_t(fFile->GetBytesRead())/Double_t(fFile->GetReadCalls()));
   printf("Number of blocks in current cache: %d, total size : %d\n",fNseek,fNtot);
   if (!opt.Contains("a")) return;
   for (Int_t i=0;i<fNseek;i++) {
      if (fIsSorted && !opt.Contains("s")) {
         printf("block: %5d, from: %lld to %lld, len=%d bytes\n",i,fSeekSort[i],fSeekSort[i]+fSeekSortLen[i],fSeekSortLen[i]);
      } else {
         printf("block: %5d, from: %lld to %lld, len=%d bytes\n",i,fSeek[i],fSeek[i]+fSeekLen[i],fSeekLen[i]);
      }
   }
   printf ("Number of long buffers = %d\n",fNb);
   for (Int_t j=0;j<fNb;j++) {
      printf("fPos[%d]=%lld, fLen=%d\n",j,fPos[j],fLen[j]);
   }
}

//_____________________________________________________________________________
Int_t TFileCacheRead::ReadBuffer(char *buf, Long64_t pos, Int_t len)
{
   // Read buffer at position pos.
   // If pos is in the list of prefetched blocks read from fBuffer,
   // otherwise need to make a normal read from file. Returns -1 in case of
   // read error, 0 in case not in cache, 1 in case read from cache.

   Int_t loc = -1;
   return ReadBufferExt(buf, pos, len, loc);
}

//_____________________________________________________________________________
Int_t TFileCacheRead::ReadBufferExt(char *buf, Long64_t pos, Int_t len, Int_t &loc)
{
   // Base function for ReadBuffer. Also gives out the position
   // of the block in the internal buffer. This helps TTreeCacheUnzip to avoid
   // doing twice the binary search

   if (fNseek > 0 && !fIsSorted) {
      Sort();
      loc = -1;

      // If ReadBufferAsync is not supported by this implementation...
      if (!fAsyncReading) {
         // Then we use the vectored read to read everything now
         if (fFile->ReadBuffers(fBuffer,fPos,fLen,fNb)) {
            return -1;
         }
         fIsTransferred = kTRUE;
      } else {
         // In any case, we'll start to request the chunks.
         // This implementation simply reads all the chunks in advance
         // in the async way.


         // Use the async readv instead of single reads
         fFile->ReadBuffers(0, 0, 0, 0); //Clear the XrdClient cache
         if (fFile->ReadBuffers(0,fPos,fLen,fNb)) {
            return -1;
         }
         fIsTransferred = kTRUE;

      }
   }

   // in case we are writing and reading to/from this file, we much check
   // if this buffer is in the write cache (not yet written to the file)
   if (TFileCacheWrite *cachew = fFile->GetCacheWrite()) {
      if (cachew->ReadBuffer(buf,pos,len) == 0) {
         fFile->Seek(pos+len);
         return 1;
      }
   }

   // If asynchronous reading is supported by this implementation...
   if (fAsyncReading) {

         // Now we dont have to look for it in the local buffer
         // if it's async, we expect that the communication library
         // will handle it more efficiently than we can do here

      Int_t retval;
      if (loc < 0)
         loc = (Int_t)TMath::BinarySearch(fNseek,fSeekSort,pos);
      
      // We use the internal list just to notify if the list is to be reconstructed
      if (loc >= 0 && loc < fNseek && pos == fSeekSort[loc]) {
         // Block found, the caller will get it
         
         if (buf) {
            fFile->Seek(pos);               
            if (fFile->ReadBuffer(buf, len)) {
               return -1;
            }
            fFile->Seek(pos+len);
         }
         
         retval = 1;
      } else {
         // Block not found in the list, we report it as a miss
         retval = 0;
      }
      
      
      
      
      
      
      if (gDebug > 0)
         Info("ReadBuffer","pos=%lld, len=%d, retval=%d, loc=%d, fseekSort[loc]=%d, fSeekLen[loc]=%d", pos, len, retval, loc, fSeekSort[loc], fSeekLen[loc]);
      
      return retval;
   } else {

      if (loc < 0)
         loc = (Int_t)TMath::BinarySearch(fNseek,fSeekSort,pos);

      if (loc >= 0 && loc <fNseek && pos == fSeekSort[loc]) {
         if (buf) {
            memcpy(buf,&fBuffer[fSeekPos[loc]],len);
            fFile->Seek(pos+len);
         }
         return 1;
      }
   }

   return 0;
}

//_____________________________________________________________________________
void TFileCacheRead::SetFile(TFile *file)
{
   // Set the file using this cache and reset the current blocks (if any).

   fFile = file;

   if (fAsyncReading) {
      // If asynchronous reading is not supported by this TFile specialization
      // we use sync primitives, hence we need the local buffer
      if (file && file->ReadBufferAsync(0, 0)) {
         fAsyncReading = kFALSE;
         fBuffer    = new char[fBufferSize];

      }
   }

   Prefetch(0,0);
}

//_____________________________________________________________________________
void TFileCacheRead::Sort()
{
   // Sort buffers to be prefetched in increasing order of positions.
   // Merge consecutive blocks if necessary.

   if (!fNseek) return;
   TMath::Sort(fNseek,fSeek,fSeekIndex,kFALSE);
   Int_t i;
   Int_t nb = 0;
   for (i=0;i<fNseek;i++) {
      Int_t ind = fSeekIndex[i];
      fSeekSort[i] = fSeek[ind];
      fSeekSortLen[i] = fSeekLen[ind];
   }
   if (fNtot > fBufferSizeMin) {
      fBufferSize = fNtot + 100;
      delete [] fBuffer;
      fBuffer = 0;
      // If ReadBufferAsync is not supported by this implementation
      // it means that we are using sync primitives, hence we need the local buffer
      if (!fAsyncReading)
         fBuffer = new char[fBufferSize];
   }
   fPos[0]  = fSeekSort[0];
   fLen[0]  = fSeekSortLen[0];
   fSeekPos[0] = 0;
   for (i=1;i<fNseek;i++) {
      fSeekPos[i] = fSeekPos[i-1] + fSeekSortLen[i-1];
      if ((fSeekSort[i] != fSeekSort[i-1]+fSeekSortLen[i-1]) ||
          (fLen[nb] > 2000000)) {
         nb++;
         fPos[nb] = fSeekSort[i];
         fLen[nb] = fSeekSortLen[i];
      } else {
         fLen[nb] += fSeekSortLen[i];
      }
   }
   fNb = nb+1;
   fIsSorted = kTRUE;
}
 TFileCacheRead.cxx:1
 TFileCacheRead.cxx:2
 TFileCacheRead.cxx:3
 TFileCacheRead.cxx:4
 TFileCacheRead.cxx:5
 TFileCacheRead.cxx:6
 TFileCacheRead.cxx:7
 TFileCacheRead.cxx:8
 TFileCacheRead.cxx:9
 TFileCacheRead.cxx:10
 TFileCacheRead.cxx:11
 TFileCacheRead.cxx:12
 TFileCacheRead.cxx:13
 TFileCacheRead.cxx:14
 TFileCacheRead.cxx:15
 TFileCacheRead.cxx:16
 TFileCacheRead.cxx:17
 TFileCacheRead.cxx:18
 TFileCacheRead.cxx:19
 TFileCacheRead.cxx:20
 TFileCacheRead.cxx:21
 TFileCacheRead.cxx:22
 TFileCacheRead.cxx:23
 TFileCacheRead.cxx:24
 TFileCacheRead.cxx:25
 TFileCacheRead.cxx:26
 TFileCacheRead.cxx:27
 TFileCacheRead.cxx:28
 TFileCacheRead.cxx:29
 TFileCacheRead.cxx:30
 TFileCacheRead.cxx:31
 TFileCacheRead.cxx:32
 TFileCacheRead.cxx:33
 TFileCacheRead.cxx:34
 TFileCacheRead.cxx:35
 TFileCacheRead.cxx:36
 TFileCacheRead.cxx:37
 TFileCacheRead.cxx:38
 TFileCacheRead.cxx:39
 TFileCacheRead.cxx:40
 TFileCacheRead.cxx:41
 TFileCacheRead.cxx:42
 TFileCacheRead.cxx:43
 TFileCacheRead.cxx:44
 TFileCacheRead.cxx:45
 TFileCacheRead.cxx:46
 TFileCacheRead.cxx:47
 TFileCacheRead.cxx:48
 TFileCacheRead.cxx:49
 TFileCacheRead.cxx:50
 TFileCacheRead.cxx:51
 TFileCacheRead.cxx:52
 TFileCacheRead.cxx:53
 TFileCacheRead.cxx:54
 TFileCacheRead.cxx:55
 TFileCacheRead.cxx:56
 TFileCacheRead.cxx:57
 TFileCacheRead.cxx:58
 TFileCacheRead.cxx:59
 TFileCacheRead.cxx:60
 TFileCacheRead.cxx:61
 TFileCacheRead.cxx:62
 TFileCacheRead.cxx:63
 TFileCacheRead.cxx:64
 TFileCacheRead.cxx:65
 TFileCacheRead.cxx:66
 TFileCacheRead.cxx:67
 TFileCacheRead.cxx:68
 TFileCacheRead.cxx:69
 TFileCacheRead.cxx:70
 TFileCacheRead.cxx:71
 TFileCacheRead.cxx:72
 TFileCacheRead.cxx:73
 TFileCacheRead.cxx:74
 TFileCacheRead.cxx:75
 TFileCacheRead.cxx:76
 TFileCacheRead.cxx:77
 TFileCacheRead.cxx:78
 TFileCacheRead.cxx:79
 TFileCacheRead.cxx:80
 TFileCacheRead.cxx:81
 TFileCacheRead.cxx:82
 TFileCacheRead.cxx:83
 TFileCacheRead.cxx:84
 TFileCacheRead.cxx:85
 TFileCacheRead.cxx:86
 TFileCacheRead.cxx:87
 TFileCacheRead.cxx:88
 TFileCacheRead.cxx:89
 TFileCacheRead.cxx:90
 TFileCacheRead.cxx:91
 TFileCacheRead.cxx:92
 TFileCacheRead.cxx:93
 TFileCacheRead.cxx:94
 TFileCacheRead.cxx:95
 TFileCacheRead.cxx:96
 TFileCacheRead.cxx:97
 TFileCacheRead.cxx:98
 TFileCacheRead.cxx:99
 TFileCacheRead.cxx:100
 TFileCacheRead.cxx:101
 TFileCacheRead.cxx:102
 TFileCacheRead.cxx:103
 TFileCacheRead.cxx:104
 TFileCacheRead.cxx:105
 TFileCacheRead.cxx:106
 TFileCacheRead.cxx:107
 TFileCacheRead.cxx:108
 TFileCacheRead.cxx:109
 TFileCacheRead.cxx:110
 TFileCacheRead.cxx:111
 TFileCacheRead.cxx:112
 TFileCacheRead.cxx:113
 TFileCacheRead.cxx:114
 TFileCacheRead.cxx:115
 TFileCacheRead.cxx:116
 TFileCacheRead.cxx:117
 TFileCacheRead.cxx:118
 TFileCacheRead.cxx:119
 TFileCacheRead.cxx:120
 TFileCacheRead.cxx:121
 TFileCacheRead.cxx:122
 TFileCacheRead.cxx:123
 TFileCacheRead.cxx:124
 TFileCacheRead.cxx:125
 TFileCacheRead.cxx:126
 TFileCacheRead.cxx:127
 TFileCacheRead.cxx:128
 TFileCacheRead.cxx:129
 TFileCacheRead.cxx:130
 TFileCacheRead.cxx:131
 TFileCacheRead.cxx:132
 TFileCacheRead.cxx:133
 TFileCacheRead.cxx:134
 TFileCacheRead.cxx:135
 TFileCacheRead.cxx:136
 TFileCacheRead.cxx:137
 TFileCacheRead.cxx:138
 TFileCacheRead.cxx:139
 TFileCacheRead.cxx:140
 TFileCacheRead.cxx:141
 TFileCacheRead.cxx:142
 TFileCacheRead.cxx:143
 TFileCacheRead.cxx:144
 TFileCacheRead.cxx:145
 TFileCacheRead.cxx:146
 TFileCacheRead.cxx:147
 TFileCacheRead.cxx:148
 TFileCacheRead.cxx:149
 TFileCacheRead.cxx:150
 TFileCacheRead.cxx:151
 TFileCacheRead.cxx:152
 TFileCacheRead.cxx:153
 TFileCacheRead.cxx:154
 TFileCacheRead.cxx:155
 TFileCacheRead.cxx:156
 TFileCacheRead.cxx:157
 TFileCacheRead.cxx:158
 TFileCacheRead.cxx:159
 TFileCacheRead.cxx:160
 TFileCacheRead.cxx:161
 TFileCacheRead.cxx:162
 TFileCacheRead.cxx:163
 TFileCacheRead.cxx:164
 TFileCacheRead.cxx:165
 TFileCacheRead.cxx:166
 TFileCacheRead.cxx:167
 TFileCacheRead.cxx:168
 TFileCacheRead.cxx:169
 TFileCacheRead.cxx:170
 TFileCacheRead.cxx:171
 TFileCacheRead.cxx:172
 TFileCacheRead.cxx:173
 TFileCacheRead.cxx:174
 TFileCacheRead.cxx:175
 TFileCacheRead.cxx:176
 TFileCacheRead.cxx:177
 TFileCacheRead.cxx:178
 TFileCacheRead.cxx:179
 TFileCacheRead.cxx:180
 TFileCacheRead.cxx:181
 TFileCacheRead.cxx:182
 TFileCacheRead.cxx:183
 TFileCacheRead.cxx:184
 TFileCacheRead.cxx:185
 TFileCacheRead.cxx:186
 TFileCacheRead.cxx:187
 TFileCacheRead.cxx:188
 TFileCacheRead.cxx:189
 TFileCacheRead.cxx:190
 TFileCacheRead.cxx:191
 TFileCacheRead.cxx:192
 TFileCacheRead.cxx:193
 TFileCacheRead.cxx:194
 TFileCacheRead.cxx:195
 TFileCacheRead.cxx:196
 TFileCacheRead.cxx:197
 TFileCacheRead.cxx:198
 TFileCacheRead.cxx:199
 TFileCacheRead.cxx:200
 TFileCacheRead.cxx:201
 TFileCacheRead.cxx:202
 TFileCacheRead.cxx:203
 TFileCacheRead.cxx:204
 TFileCacheRead.cxx:205
 TFileCacheRead.cxx:206
 TFileCacheRead.cxx:207
 TFileCacheRead.cxx:208
 TFileCacheRead.cxx:209
 TFileCacheRead.cxx:210
 TFileCacheRead.cxx:211
 TFileCacheRead.cxx:212
 TFileCacheRead.cxx:213
 TFileCacheRead.cxx:214
 TFileCacheRead.cxx:215
 TFileCacheRead.cxx:216
 TFileCacheRead.cxx:217
 TFileCacheRead.cxx:218
 TFileCacheRead.cxx:219
 TFileCacheRead.cxx:220
 TFileCacheRead.cxx:221
 TFileCacheRead.cxx:222
 TFileCacheRead.cxx:223
 TFileCacheRead.cxx:224
 TFileCacheRead.cxx:225
 TFileCacheRead.cxx:226
 TFileCacheRead.cxx:227
 TFileCacheRead.cxx:228
 TFileCacheRead.cxx:229
 TFileCacheRead.cxx:230
 TFileCacheRead.cxx:231
 TFileCacheRead.cxx:232
 TFileCacheRead.cxx:233
 TFileCacheRead.cxx:234
 TFileCacheRead.cxx:235
 TFileCacheRead.cxx:236
 TFileCacheRead.cxx:237
 TFileCacheRead.cxx:238
 TFileCacheRead.cxx:239
 TFileCacheRead.cxx:240
 TFileCacheRead.cxx:241
 TFileCacheRead.cxx:242
 TFileCacheRead.cxx:243
 TFileCacheRead.cxx:244
 TFileCacheRead.cxx:245
 TFileCacheRead.cxx:246
 TFileCacheRead.cxx:247
 TFileCacheRead.cxx:248
 TFileCacheRead.cxx:249
 TFileCacheRead.cxx:250
 TFileCacheRead.cxx:251
 TFileCacheRead.cxx:252
 TFileCacheRead.cxx:253
 TFileCacheRead.cxx:254
 TFileCacheRead.cxx:255
 TFileCacheRead.cxx:256
 TFileCacheRead.cxx:257
 TFileCacheRead.cxx:258
 TFileCacheRead.cxx:259
 TFileCacheRead.cxx:260
 TFileCacheRead.cxx:261
 TFileCacheRead.cxx:262
 TFileCacheRead.cxx:263
 TFileCacheRead.cxx:264
 TFileCacheRead.cxx:265
 TFileCacheRead.cxx:266
 TFileCacheRead.cxx:267
 TFileCacheRead.cxx:268
 TFileCacheRead.cxx:269
 TFileCacheRead.cxx:270
 TFileCacheRead.cxx:271
 TFileCacheRead.cxx:272
 TFileCacheRead.cxx:273
 TFileCacheRead.cxx:274
 TFileCacheRead.cxx:275
 TFileCacheRead.cxx:276
 TFileCacheRead.cxx:277
 TFileCacheRead.cxx:278
 TFileCacheRead.cxx:279
 TFileCacheRead.cxx:280
 TFileCacheRead.cxx:281
 TFileCacheRead.cxx:282
 TFileCacheRead.cxx:283
 TFileCacheRead.cxx:284
 TFileCacheRead.cxx:285
 TFileCacheRead.cxx:286
 TFileCacheRead.cxx:287
 TFileCacheRead.cxx:288
 TFileCacheRead.cxx:289
 TFileCacheRead.cxx:290
 TFileCacheRead.cxx:291
 TFileCacheRead.cxx:292
 TFileCacheRead.cxx:293
 TFileCacheRead.cxx:294
 TFileCacheRead.cxx:295
 TFileCacheRead.cxx:296
 TFileCacheRead.cxx:297
 TFileCacheRead.cxx:298
 TFileCacheRead.cxx:299
 TFileCacheRead.cxx:300
 TFileCacheRead.cxx:301
 TFileCacheRead.cxx:302
 TFileCacheRead.cxx:303
 TFileCacheRead.cxx:304
 TFileCacheRead.cxx:305
 TFileCacheRead.cxx:306
 TFileCacheRead.cxx:307
 TFileCacheRead.cxx:308
 TFileCacheRead.cxx:309
 TFileCacheRead.cxx:310
 TFileCacheRead.cxx:311
 TFileCacheRead.cxx:312
 TFileCacheRead.cxx:313
 TFileCacheRead.cxx:314
 TFileCacheRead.cxx:315
 TFileCacheRead.cxx:316
 TFileCacheRead.cxx:317
 TFileCacheRead.cxx:318
 TFileCacheRead.cxx:319
 TFileCacheRead.cxx:320
 TFileCacheRead.cxx:321
 TFileCacheRead.cxx:322
 TFileCacheRead.cxx:323
 TFileCacheRead.cxx:324
 TFileCacheRead.cxx:325
 TFileCacheRead.cxx:326
 TFileCacheRead.cxx:327
 TFileCacheRead.cxx:328
 TFileCacheRead.cxx:329
 TFileCacheRead.cxx:330
 TFileCacheRead.cxx:331
 TFileCacheRead.cxx:332
 TFileCacheRead.cxx:333
 TFileCacheRead.cxx:334
 TFileCacheRead.cxx:335
 TFileCacheRead.cxx:336
 TFileCacheRead.cxx:337
 TFileCacheRead.cxx:338
 TFileCacheRead.cxx:339
 TFileCacheRead.cxx:340
 TFileCacheRead.cxx:341
 TFileCacheRead.cxx:342
 TFileCacheRead.cxx:343
 TFileCacheRead.cxx:344
 TFileCacheRead.cxx:345
 TFileCacheRead.cxx:346
 TFileCacheRead.cxx:347
 TFileCacheRead.cxx:348
 TFileCacheRead.cxx:349
 TFileCacheRead.cxx:350
 TFileCacheRead.cxx:351
 TFileCacheRead.cxx:352
 TFileCacheRead.cxx:353
 TFileCacheRead.cxx:354
 TFileCacheRead.cxx:355
 TFileCacheRead.cxx:356
 TFileCacheRead.cxx:357
 TFileCacheRead.cxx:358
 TFileCacheRead.cxx:359
 TFileCacheRead.cxx:360
 TFileCacheRead.cxx:361
 TFileCacheRead.cxx:362
 TFileCacheRead.cxx:363
 TFileCacheRead.cxx:364
 TFileCacheRead.cxx:365
 TFileCacheRead.cxx:366
 TFileCacheRead.cxx:367
 TFileCacheRead.cxx:368
 TFileCacheRead.cxx:369
 TFileCacheRead.cxx:370
 TFileCacheRead.cxx:371
 TFileCacheRead.cxx:372
 TFileCacheRead.cxx:373
 TFileCacheRead.cxx:374
 TFileCacheRead.cxx:375
 TFileCacheRead.cxx:376
 TFileCacheRead.cxx:377
 TFileCacheRead.cxx:378
 TFileCacheRead.cxx:379
 TFileCacheRead.cxx:380
 TFileCacheRead.cxx:381
 TFileCacheRead.cxx:382
 TFileCacheRead.cxx:383
 TFileCacheRead.cxx:384