// @(#)root/proofplayer:$Id$
// Author: G. Ganis 2009

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TPacketizerFile                                                      //
//                                                                      //
// This packetizer generates packets which contain a single file path   //
// to be used in process. Used for tasks generating files, like in      //
// PROOF bench.                                                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "TPacketizerFile.h"

#include "Riostream.h"
#include "TDSet.h"
#include "TError.h"
#include "TEventList.h"
#include "TMap.h"
#include "TMessage.h"
#include "TMonitor.h"
#include "TNtupleD.h"
#include "TObject.h"
#include "TParameter.h"
#include "TPerfStats.h"
#include "TProofDebug.h"
#include "TProof.h"
#include "TProofPlayer.h"
#include "TProofServ.h"
#include "TSlave.h"
#include "TSocket.h"
#include "TStopwatch.h"
#include "TTimer.h"
#include "TUrl.h"
#include "TClass.h"
#include "TMath.h"
#include "TObjString.h"
#include "TFileInfo.h"
#include "TFileCollection.h"
#include "THashList.h"

//------------------------------------------------------------------------------

class TPacketizerFile::TSlaveStat : public TVirtualPacketizer::TVirtualSlaveStat {

friend class TPacketizerFile;

private:
   Long64_t  fLastProcessed; // number of processed entries of the last packet
   Double_t  fSpeed;         // estimated current average speed of the processing slave
   Double_t  fTimeInstant;   // stores the time instant when the current packet started
   TNtupleD *fCircNtp;       // Keeps circular info for speed calculations
   Long_t    fCircLvl;       // Circularity level

public:
   TSlaveStat(TSlave *sl, TList *input);
   ~TSlaveStat();

   void        GetCurrentTime();

   void        UpdatePerformance(Double_t time);
   TProofProgressStatus *AddProcessed(TProofProgressStatus *st);
};

// Iterator wrapper
class TPacketizerFile::TIterObj : public TObject {

private:
   TString   fName;          // Name of reference
   TIter    *fIter;          // Iterator

public:
   TIterObj(const char *n, TIter *iter) : fName(n), fIter(iter) { }
   virtual ~TIterObj() { if (fIter) delete fIter; }

   const char *GetName() const {return fName;}
   TIter      *GetIter() const {return fIter;}
   void        Print(Option_t* option = "") const;
};

ClassImp(TPacketizerFile)

//______________________________________________________________________________
TPacketizerFile::TPacketizerFile(TList *workers, Long64_t, TList *input,
                                 TProofProgressStatus *st)
                : TVirtualPacketizer(input, st)
{
   // Constructor

   PDB(kPacketizer,1) Info("TPacketizerFile", "enter");
   ResetBit(TObject::kInvalidObject);
   fValid = kFALSE;
   fAssigned = 0;
   fProcNotAssigned = kTRUE;
   fAddFileInfo = kFALSE;

   if (!input || (input && input->GetSize() <= 0)) {
      Error("TPacketizerFile", "input file is undefined or empty!");
      SetBit(TObject::kInvalidObject);
      return;
   }

   // Check if the files not explicitly assigned have to be processed
   Int_t procnotass = 1;
   if (TProof::GetParameter(input, "PROOF_ProcessNotAssigned", procnotass) == 0) {
      if (procnotass == 0) {
         Info("TPacketizerFile", "files not assigned to workers will not be processed");
         fProcNotAssigned = kFALSE;
      }
   }

   // Check if the TFileInfo object has to be added to the packet
   Int_t addfileinfo = 0;
   if (TProof::GetParameter(input, "PROOF_IncludeFileInfoInPacket", addfileinfo) == 0) {
      if (addfileinfo == 1) {
         Info("TPacketizerFile",
              "TFileInfo object will be included in the packet as associated object");
         fAddFileInfo = kTRUE;
      }
   }

   // These are the file to be created/processed per node; the information
   if (!(fFiles = dynamic_cast<TMap *>(input->FindObject("PROOF_FilesToProcess")))) {
      Error("TPacketizerFile", "map of files to be processed/created not found");
      SetBit(TObject::kInvalidObject);
      return;
   }

   // The worker stats
   fSlaveStats = new TMap;
   fSlaveStats->SetOwner(kFALSE);

   TList nodes;
   nodes.SetOwner(kTRUE);
   TSlave *wrk;
   TIter si(workers);
   while ((wrk = (TSlave *) si.Next())) {
      fSlaveStats->Add(wrk, new TSlaveStat(wrk, input));
      TString wrkname = TUrl(wrk->GetName()).GetHostFQDN();
      Info("TPacketizerFile", "worker: %s", wrkname.Data());
      if (!nodes.FindObject(wrkname)) nodes.Add(new TObjString(wrkname));
   }

   // The list of iterators
   fIters = new TList;
   fIters->SetOwner(kTRUE);

   // There must be something in
   fTotalEntries = 0;
   fNotAssigned = new TList;
   fNotAssigned->SetName("*");
   TIter nxl(fFiles);
   TObject *key, *o = 0;
   while ((key = nxl()) != 0) {
      THashList *wrklist = dynamic_cast<THashList *>(fFiles->GetValue(key));
      if (!wrklist) {
         TFileCollection *fc = dynamic_cast<TFileCollection *>(fFiles->GetValue(key));
         if (fc) wrklist = fc->GetList();
      }
      if (wrklist) {
         TString hname = TUrl(key->GetName()).GetHostFQDN();
         if ((o = nodes.FindObject(hname))) {
            fTotalEntries += wrklist->GetSize();
            fIters->Add(new TIterObj(hname, new TIter(wrklist)));
            // Notify
            PDB(kPacketizer,2)
               Info("TPacketizerFile", "%d files of '%s' (fqdn: '%s') assigned to '%s'",
                                       wrklist->GetSize(), key->GetName(), hname.Data(), o->GetName());
         } else {
            // We add all to the not assigned list so that they will be distributed
            // according to the load
            TIter nxf(wrklist);
            while ((o = nxf()))
               fNotAssigned->Add(o);
            // Notify
            PDB(kPacketizer,2)
               Info("TPacketizerFile", "%d files of '%s' (fqdn: '%s') not assigned",
                                       wrklist->GetSize(), key->GetName(), hname.Data());
         }
      }
   }
   if (fNotAssigned && fNotAssigned->GetSize() > 0) {
      fTotalEntries += fNotAssigned->GetSize();
      fIters->Add(new TIterObj("*", new TIter(fNotAssigned)));
      Info("TPacketizerFile", "non-assigned files: %d", fNotAssigned->GetSize());
      fNotAssigned->Print();
   }
   if (fTotalEntries <= 0) {
      Error("TPacketizerFile", "no file path in the map!");
      SetBit(TObject::kInvalidObject);
      SafeDelete(fIters);
      return;
   } else {
      Info("TPacketizerFile", "processing %lld files", fTotalEntries);
      fIters->Print();
   }

   fStopwatch = new TStopwatch();
   fStopwatch->Start();
   fValid = kTRUE;
   PDB(kPacketizer,1) Info("TPacketizerFile", "return");

   // Done
   return;
}

//______________________________________________________________________________
TPacketizerFile::~TPacketizerFile()
{
   // Destructor.

   if (fNotAssigned) fNotAssigned->SetOwner(kFALSE);
   SafeDelete(fNotAssigned);
   if (fIters) fIters->SetOwner(kTRUE);
   SafeDelete(fIters);
   SafeDelete(fStopwatch);
}

//______________________________________________________________________________
Double_t TPacketizerFile::GetCurrentTime()
{
   // Get current time

   Double_t retValue = fStopwatch->RealTime();
   fStopwatch->Continue();
   return retValue;
}

//______________________________________________________________________________
Float_t TPacketizerFile::GetCurrentRate(Bool_t &all)
{
   // Get Estimation of the current rate; just summing the current rates of
   // the active workers

   all = kTRUE;
   // Loop over the workers
   Float_t currate = 0.;
   if (fSlaveStats && fSlaveStats->GetSize() > 0) {
      TIter nxw(fSlaveStats);
      TObject *key;
      while ((key = nxw()) != 0) {
         TSlaveStat *wrkstat = (TSlaveStat *) fSlaveStats->GetValue(key);
         if (wrkstat && wrkstat->GetProgressStatus() && wrkstat->GetEntriesProcessed() > 0) {
            // Sum-up the current rates
            currate += wrkstat->GetProgressStatus()->GetCurrentRate();
         } else {
            all = kFALSE;
         }
      }
   }
   // Done
   return currate;
}

//______________________________________________________________________________
TDSetElement *TPacketizerFile::GetNextPacket(TSlave *wrk, TMessage *r)
{
   // Get next packet

   TDSetElement *elem = 0;
   if (!fValid)  return elem;

   // Find slave
   TSlaveStat *wrkstat = (TSlaveStat *) fSlaveStats->GetValue(wrk);
   if (!wrkstat) {
      Error("GetNextPacket", "could not find stat object for worker '%s'!", wrk->GetName());
      return elem;
   }

   PDB(kPacketizer,2)
      Info("GetNextPacket","worker-%s: fAssigned %lld / %lld", wrk->GetOrdinal(), fAssigned, fTotalEntries);

   // Update stats & free old element
   Double_t latency = 0., proctime = 0., proccpu = 0.;
   Long64_t bytesRead = -1;
   Long64_t totalEntries = -1; // used only to read an old message type
   Long64_t totev = 0;
   Long64_t numev = -1;

   TProofProgressStatus *status = 0;
   if (wrk->GetProtocol() > 18) {
      (*r) >> latency;
      (*r) >> status;

      // Calculate the progress made in the last packet
      TProofProgressStatus *progress = 0;
      if (status) {
         // upadte the worker status
         numev = status->GetEntries() - wrkstat->GetEntriesProcessed();
         progress = wrkstat->AddProcessed(status);
         if (progress) {
            // (*fProgressStatus) += *progress;
            proctime = progress->GetProcTime();
            proccpu  = progress->GetCPUTime();
            totev  = status->GetEntries(); // for backward compatibility
            bytesRead  = progress->GetBytesRead();
            delete progress;
         }
         delete status;
      } else
          Error("GetNextPacket", "no status came in the kPROOF_GETPACKET message");
   } else {

      (*r) >> latency >> proctime >> proccpu;

      // only read new info if available
      if (r->BufferSize() > r->Length()) (*r) >> bytesRead;
      if (r->BufferSize() > r->Length()) (*r) >> totalEntries;
      if (r->BufferSize() > r->Length()) (*r) >> totev;

      numev = totev - wrkstat->GetEntriesProcessed();
      wrkstat->GetProgressStatus()->IncEntries(numev);
      wrkstat->GetProgressStatus()->SetLastUpdate();
   }

   fProgressStatus->IncEntries(numev);
   fProgressStatus->SetLastUpdate();

   PDB(kPacketizer,2)
      Info("GetNextPacket","worker-%s (%s): %lld %7.3lf %7.3lf %7.3lf %lld",
                           wrk->GetOrdinal(), wrk->GetName(),
                           numev, latency, proctime, proccpu, bytesRead);

   if (gPerfStats != 0) {
      gPerfStats->PacketEvent(wrk->GetOrdinal(), wrk->GetName(), "", numev,
                              latency, proctime, proccpu, bytesRead);
   }

   if (fAssigned == fTotalEntries) {
      // Send last timer message
      HandleTimer(0);
      return 0;
   }

   if (fStop) {
      // Send last timer message
      HandleTimer(0);
      return 0;
   }

   PDB(kPacketizer,2)
      Info("GetNextPacket", "worker-%s (%s): getting next files ... ", wrk->GetOrdinal(),
                            wrk->GetName());

   // Get next file now
   TObject *nextfile = 0;

   // Find iterator associated to the worker
   TString wrkname = TUrl(wrk->GetName()).GetHostFQDN();
   TIterObj *io = dynamic_cast<TIterObj *>(fIters->FindObject(wrkname));
   if (io) {
      // Get next file to process in the list of the worker
      if (io->GetIter())
         nextfile = io->GetIter()->Next();
   }

   // If not found or all files already processed, check if a generic iterator
   // has still some files to process
   if (!nextfile && fProcNotAssigned) {
      if ((io = dynamic_cast<TIterObj *>(fIters->FindObject("*")))) {
         // Get next file to process in the list of the worker
         if (io->GetIter())
            nextfile = io->GetIter()->Next();
      }
   }

   // Return if nothing to process
   if (!nextfile) return elem;

   // The file name: we support TObjString or TFileInfo
   TString filename;
   TObjString *os = 0;
   TFileInfo *fi = 0;
   if ((os = dynamic_cast<TObjString *>(nextfile))) {
      filename = os->GetName();
   } else {
      if ((fi = dynamic_cast<TFileInfo *>(nextfile)))
         filename = fi->GetCurrentUrl()->GetUrl();
   }
   // Nothing to process
   if (filename.IsNull()) {
      Warning("GetNextPacket", "found unsupported object of type '%s' in list: it must"
                               " be 'TObjString' or 'TFileInfo'", nextfile->ClassName());
      return elem;
   }
   // Prepare the packet
   PDB(kPacketizer,2)
      Info("GetNextPacket", "worker-%s: assigning: '%s' (remaining %lld files)",
                            wrk->GetOrdinal(), filename.Data(), (fTotalEntries - fAssigned));
   elem = new TDSetElement(filename, "", "", 0, 1);
   elem->SetBit(TDSetElement::kEmpty);

   // Add the element, if required
   if (fAddFileInfo && fi) {
      elem->AddAssocObj(fi);
      PDB(kPacketizer,2) fi->Print("L");
   }

   // Update the total counter
   fAssigned += 1;

   return elem;
}

//------------------------------------------------------------------------------

//______________________________________________________________________________
TPacketizerFile::TSlaveStat::TSlaveStat(TSlave *slave, TList *input)
                            : fLastProcessed(0),
                              fSpeed(0), fTimeInstant(0), fCircLvl(5)
{
   // Main constructor

   // Initialize the circularity ntple for speed calculations
   fCircNtp = new TNtupleD("Speed Circ Ntp", "Circular process info","tm:ev");
   TProof::GetParameter(input, "PROOF_TPacketizerFileCircularity", fCircLvl);
   fCircLvl = (fCircLvl > 0) ? fCircLvl : 5;
   fCircNtp->SetCircular(fCircLvl);
   fSlave = slave;
   fStatus = new TProofProgressStatus();
}

//______________________________________________________________________________
TPacketizerFile::TSlaveStat::~TSlaveStat()
{
   // Destructor

   SafeDelete(fCircNtp);
}

//______________________________________________________________________________
void TPacketizerFile::TSlaveStat::UpdatePerformance(Double_t time)
{
   // Update the circular ntple

   Double_t ttot = time;
   Double_t *ar = fCircNtp->GetArgs();
   Int_t ne = fCircNtp->GetEntries();
   if (ne <= 0) {
      // First call: just fill one ref entry and return
      fCircNtp->Fill(0., 0);
      fSpeed = 0.;
      return;
   }
   // Fill the entry
   fCircNtp->GetEntry(ne-1);
   ttot = ar[0] + time;
   fCircNtp->Fill(ttot, GetEntriesProcessed());

   // Calculate the speed
   fCircNtp->GetEntry(0);
   Double_t dtime = (ttot > ar[0]) ? ttot - ar[0] : ne+1 ;
   Long64_t nevts = GetEntriesProcessed() - (Long64_t)ar[1];
   fSpeed = nevts / dtime;
   PDB(kPacketizer,2)
      Info("UpdatePerformance", "time:%f, dtime:%f, nevts:%lld, speed: %f",
                                time, dtime, nevts, fSpeed);

}

//______________________________________________________________________________
TProofProgressStatus *TPacketizerFile::TSlaveStat::AddProcessed(TProofProgressStatus *st)
{
   // Update the status info to the 'st'.
   // return the difference (*st - *fStatus)

   if (st) {
      // The entriesis not correct in 'st'
      Long64_t lastEntries = st->GetEntries() - fStatus->GetEntries();
      // The last proc time should not be added
      fStatus->SetLastProcTime(0.);
      // Get the diff
      TProofProgressStatus *diff = new TProofProgressStatus(*st - *fStatus);
      *fStatus += *diff;
      // Set the correct value
      fStatus->SetLastEntries(lastEntries);
      return diff;
   } else {
      Error("AddProcessed", "status arg undefined");
      return 0;
   }
}

//______________________________________________________________________________
void TPacketizerFile::TIterObj::Print(Option_t *) const
{
   // Printf info

   Printf("Iterator '%s' controls %d units", GetName(),
          ((GetIter() && GetIter()->GetCollection()) ? GetIter()->GetCollection()->GetSize()
                                                     : -1));
}
 TPacketizerFile.cxx:1
 TPacketizerFile.cxx:2
 TPacketizerFile.cxx:3
 TPacketizerFile.cxx:4
 TPacketizerFile.cxx:5
 TPacketizerFile.cxx:6
 TPacketizerFile.cxx:7
 TPacketizerFile.cxx:8
 TPacketizerFile.cxx:9
 TPacketizerFile.cxx:10
 TPacketizerFile.cxx:11
 TPacketizerFile.cxx:12
 TPacketizerFile.cxx:13
 TPacketizerFile.cxx:14
 TPacketizerFile.cxx:15
 TPacketizerFile.cxx:16
 TPacketizerFile.cxx:17
 TPacketizerFile.cxx:18
 TPacketizerFile.cxx:19
 TPacketizerFile.cxx:20
 TPacketizerFile.cxx:21
 TPacketizerFile.cxx:22
 TPacketizerFile.cxx:23
 TPacketizerFile.cxx:24
 TPacketizerFile.cxx:25
 TPacketizerFile.cxx:26
 TPacketizerFile.cxx:27
 TPacketizerFile.cxx:28
 TPacketizerFile.cxx:29
 TPacketizerFile.cxx:30
 TPacketizerFile.cxx:31
 TPacketizerFile.cxx:32
 TPacketizerFile.cxx:33
 TPacketizerFile.cxx:34
 TPacketizerFile.cxx:35
 TPacketizerFile.cxx:36
 TPacketizerFile.cxx:37
 TPacketizerFile.cxx:38
 TPacketizerFile.cxx:39
 TPacketizerFile.cxx:40
 TPacketizerFile.cxx:41
 TPacketizerFile.cxx:42
 TPacketizerFile.cxx:43
 TPacketizerFile.cxx:44
 TPacketizerFile.cxx:45
 TPacketizerFile.cxx:46
 TPacketizerFile.cxx:47
 TPacketizerFile.cxx:48
 TPacketizerFile.cxx:49
 TPacketizerFile.cxx:50
 TPacketizerFile.cxx:51
 TPacketizerFile.cxx:52
 TPacketizerFile.cxx:53
 TPacketizerFile.cxx:54
 TPacketizerFile.cxx:55
 TPacketizerFile.cxx:56
 TPacketizerFile.cxx:57
 TPacketizerFile.cxx:58
 TPacketizerFile.cxx:59
 TPacketizerFile.cxx:60
 TPacketizerFile.cxx:61
 TPacketizerFile.cxx:62
 TPacketizerFile.cxx:63
 TPacketizerFile.cxx:64
 TPacketizerFile.cxx:65
 TPacketizerFile.cxx:66
 TPacketizerFile.cxx:67
 TPacketizerFile.cxx:68
 TPacketizerFile.cxx:69
 TPacketizerFile.cxx:70
 TPacketizerFile.cxx:71
 TPacketizerFile.cxx:72
 TPacketizerFile.cxx:73
 TPacketizerFile.cxx:74
 TPacketizerFile.cxx:75
 TPacketizerFile.cxx:76
 TPacketizerFile.cxx:77
 TPacketizerFile.cxx:78
 TPacketizerFile.cxx:79
 TPacketizerFile.cxx:80
 TPacketizerFile.cxx:81
 TPacketizerFile.cxx:82
 TPacketizerFile.cxx:83
 TPacketizerFile.cxx:84
 TPacketizerFile.cxx:85
 TPacketizerFile.cxx:86
 TPacketizerFile.cxx:87
 TPacketizerFile.cxx:88
 TPacketizerFile.cxx:89
 TPacketizerFile.cxx:90
 TPacketizerFile.cxx:91
 TPacketizerFile.cxx:92
 TPacketizerFile.cxx:93
 TPacketizerFile.cxx:94
 TPacketizerFile.cxx:95
 TPacketizerFile.cxx:96
 TPacketizerFile.cxx:97
 TPacketizerFile.cxx:98
 TPacketizerFile.cxx:99
 TPacketizerFile.cxx:100
 TPacketizerFile.cxx:101
 TPacketizerFile.cxx:102
 TPacketizerFile.cxx:103
 TPacketizerFile.cxx:104
 TPacketizerFile.cxx:105
 TPacketizerFile.cxx:106
 TPacketizerFile.cxx:107
 TPacketizerFile.cxx:108
 TPacketizerFile.cxx:109
 TPacketizerFile.cxx:110
 TPacketizerFile.cxx:111
 TPacketizerFile.cxx:112
 TPacketizerFile.cxx:113
 TPacketizerFile.cxx:114
 TPacketizerFile.cxx:115
 TPacketizerFile.cxx:116
 TPacketizerFile.cxx:117
 TPacketizerFile.cxx:118
 TPacketizerFile.cxx:119
 TPacketizerFile.cxx:120
 TPacketizerFile.cxx:121
 TPacketizerFile.cxx:122
 TPacketizerFile.cxx:123
 TPacketizerFile.cxx:124
 TPacketizerFile.cxx:125
 TPacketizerFile.cxx:126
 TPacketizerFile.cxx:127
 TPacketizerFile.cxx:128
 TPacketizerFile.cxx:129
 TPacketizerFile.cxx:130
 TPacketizerFile.cxx:131
 TPacketizerFile.cxx:132
 TPacketizerFile.cxx:133
 TPacketizerFile.cxx:134
 TPacketizerFile.cxx:135
 TPacketizerFile.cxx:136
 TPacketizerFile.cxx:137
 TPacketizerFile.cxx:138
 TPacketizerFile.cxx:139
 TPacketizerFile.cxx:140
 TPacketizerFile.cxx:141
 TPacketizerFile.cxx:142
 TPacketizerFile.cxx:143
 TPacketizerFile.cxx:144
 TPacketizerFile.cxx:145
 TPacketizerFile.cxx:146
 TPacketizerFile.cxx:147
 TPacketizerFile.cxx:148
 TPacketizerFile.cxx:149
 TPacketizerFile.cxx:150
 TPacketizerFile.cxx:151
 TPacketizerFile.cxx:152
 TPacketizerFile.cxx:153
 TPacketizerFile.cxx:154
 TPacketizerFile.cxx:155
 TPacketizerFile.cxx:156
 TPacketizerFile.cxx:157
 TPacketizerFile.cxx:158
 TPacketizerFile.cxx:159
 TPacketizerFile.cxx:160
 TPacketizerFile.cxx:161
 TPacketizerFile.cxx:162
 TPacketizerFile.cxx:163
 TPacketizerFile.cxx:164
 TPacketizerFile.cxx:165
 TPacketizerFile.cxx:166
 TPacketizerFile.cxx:167
 TPacketizerFile.cxx:168
 TPacketizerFile.cxx:169
 TPacketizerFile.cxx:170
 TPacketizerFile.cxx:171
 TPacketizerFile.cxx:172
 TPacketizerFile.cxx:173
 TPacketizerFile.cxx:174
 TPacketizerFile.cxx:175
 TPacketizerFile.cxx:176
 TPacketizerFile.cxx:177
 TPacketizerFile.cxx:178
 TPacketizerFile.cxx:179
 TPacketizerFile.cxx:180
 TPacketizerFile.cxx:181
 TPacketizerFile.cxx:182
 TPacketizerFile.cxx:183
 TPacketizerFile.cxx:184
 TPacketizerFile.cxx:185
 TPacketizerFile.cxx:186
 TPacketizerFile.cxx:187
 TPacketizerFile.cxx:188
 TPacketizerFile.cxx:189
 TPacketizerFile.cxx:190
 TPacketizerFile.cxx:191
 TPacketizerFile.cxx:192
 TPacketizerFile.cxx:193
 TPacketizerFile.cxx:194
 TPacketizerFile.cxx:195
 TPacketizerFile.cxx:196
 TPacketizerFile.cxx:197
 TPacketizerFile.cxx:198
 TPacketizerFile.cxx:199
 TPacketizerFile.cxx:200
 TPacketizerFile.cxx:201
 TPacketizerFile.cxx:202
 TPacketizerFile.cxx:203
 TPacketizerFile.cxx:204
 TPacketizerFile.cxx:205
 TPacketizerFile.cxx:206
 TPacketizerFile.cxx:207
 TPacketizerFile.cxx:208
 TPacketizerFile.cxx:209
 TPacketizerFile.cxx:210
 TPacketizerFile.cxx:211
 TPacketizerFile.cxx:212
 TPacketizerFile.cxx:213
 TPacketizerFile.cxx:214
 TPacketizerFile.cxx:215
 TPacketizerFile.cxx:216
 TPacketizerFile.cxx:217
 TPacketizerFile.cxx:218
 TPacketizerFile.cxx:219
 TPacketizerFile.cxx:220
 TPacketizerFile.cxx:221
 TPacketizerFile.cxx:222
 TPacketizerFile.cxx:223
 TPacketizerFile.cxx:224
 TPacketizerFile.cxx:225
 TPacketizerFile.cxx:226
 TPacketizerFile.cxx:227
 TPacketizerFile.cxx:228
 TPacketizerFile.cxx:229
 TPacketizerFile.cxx:230
 TPacketizerFile.cxx:231
 TPacketizerFile.cxx:232
 TPacketizerFile.cxx:233
 TPacketizerFile.cxx:234
 TPacketizerFile.cxx:235
 TPacketizerFile.cxx:236
 TPacketizerFile.cxx:237
 TPacketizerFile.cxx:238
 TPacketizerFile.cxx:239
 TPacketizerFile.cxx:240
 TPacketizerFile.cxx:241
 TPacketizerFile.cxx:242
 TPacketizerFile.cxx:243
 TPacketizerFile.cxx:244
 TPacketizerFile.cxx:245
 TPacketizerFile.cxx:246
 TPacketizerFile.cxx:247
 TPacketizerFile.cxx:248
 TPacketizerFile.cxx:249
 TPacketizerFile.cxx:250
 TPacketizerFile.cxx:251
 TPacketizerFile.cxx:252
 TPacketizerFile.cxx:253
 TPacketizerFile.cxx:254
 TPacketizerFile.cxx:255
 TPacketizerFile.cxx:256
 TPacketizerFile.cxx:257
 TPacketizerFile.cxx:258
 TPacketizerFile.cxx:259
 TPacketizerFile.cxx:260
 TPacketizerFile.cxx:261
 TPacketizerFile.cxx:262
 TPacketizerFile.cxx:263
 TPacketizerFile.cxx:264
 TPacketizerFile.cxx:265
 TPacketizerFile.cxx:266
 TPacketizerFile.cxx:267
 TPacketizerFile.cxx:268
 TPacketizerFile.cxx:269
 TPacketizerFile.cxx:270
 TPacketizerFile.cxx:271
 TPacketizerFile.cxx:272
 TPacketizerFile.cxx:273
 TPacketizerFile.cxx:274
 TPacketizerFile.cxx:275
 TPacketizerFile.cxx:276
 TPacketizerFile.cxx:277
 TPacketizerFile.cxx:278
 TPacketizerFile.cxx:279
 TPacketizerFile.cxx:280
 TPacketizerFile.cxx:281
 TPacketizerFile.cxx:282
 TPacketizerFile.cxx:283
 TPacketizerFile.cxx:284
 TPacketizerFile.cxx:285
 TPacketizerFile.cxx:286
 TPacketizerFile.cxx:287
 TPacketizerFile.cxx:288
 TPacketizerFile.cxx:289
 TPacketizerFile.cxx:290
 TPacketizerFile.cxx:291
 TPacketizerFile.cxx:292
 TPacketizerFile.cxx:293
 TPacketizerFile.cxx:294
 TPacketizerFile.cxx:295
 TPacketizerFile.cxx:296
 TPacketizerFile.cxx:297
 TPacketizerFile.cxx:298
 TPacketizerFile.cxx:299
 TPacketizerFile.cxx:300
 TPacketizerFile.cxx:301
 TPacketizerFile.cxx:302
 TPacketizerFile.cxx:303
 TPacketizerFile.cxx:304
 TPacketizerFile.cxx:305
 TPacketizerFile.cxx:306
 TPacketizerFile.cxx:307
 TPacketizerFile.cxx:308
 TPacketizerFile.cxx:309
 TPacketizerFile.cxx:310
 TPacketizerFile.cxx:311
 TPacketizerFile.cxx:312
 TPacketizerFile.cxx:313
 TPacketizerFile.cxx:314
 TPacketizerFile.cxx:315
 TPacketizerFile.cxx:316
 TPacketizerFile.cxx:317
 TPacketizerFile.cxx:318
 TPacketizerFile.cxx:319
 TPacketizerFile.cxx:320
 TPacketizerFile.cxx:321
 TPacketizerFile.cxx:322
 TPacketizerFile.cxx:323
 TPacketizerFile.cxx:324
 TPacketizerFile.cxx:325
 TPacketizerFile.cxx:326
 TPacketizerFile.cxx:327
 TPacketizerFile.cxx:328
 TPacketizerFile.cxx:329
 TPacketizerFile.cxx:330
 TPacketizerFile.cxx:331
 TPacketizerFile.cxx:332
 TPacketizerFile.cxx:333
 TPacketizerFile.cxx:334
 TPacketizerFile.cxx:335
 TPacketizerFile.cxx:336
 TPacketizerFile.cxx:337
 TPacketizerFile.cxx:338
 TPacketizerFile.cxx:339
 TPacketizerFile.cxx:340
 TPacketizerFile.cxx:341
 TPacketizerFile.cxx:342
 TPacketizerFile.cxx:343
 TPacketizerFile.cxx:344
 TPacketizerFile.cxx:345
 TPacketizerFile.cxx:346
 TPacketizerFile.cxx:347
 TPacketizerFile.cxx:348
 TPacketizerFile.cxx:349
 TPacketizerFile.cxx:350
 TPacketizerFile.cxx:351
 TPacketizerFile.cxx:352
 TPacketizerFile.cxx:353
 TPacketizerFile.cxx:354
 TPacketizerFile.cxx:355
 TPacketizerFile.cxx:356
 TPacketizerFile.cxx:357
 TPacketizerFile.cxx:358
 TPacketizerFile.cxx:359
 TPacketizerFile.cxx:360
 TPacketizerFile.cxx:361
 TPacketizerFile.cxx:362
 TPacketizerFile.cxx:363
 TPacketizerFile.cxx:364
 TPacketizerFile.cxx:365
 TPacketizerFile.cxx:366
 TPacketizerFile.cxx:367
 TPacketizerFile.cxx:368
 TPacketizerFile.cxx:369
 TPacketizerFile.cxx:370
 TPacketizerFile.cxx:371
 TPacketizerFile.cxx:372
 TPacketizerFile.cxx:373
 TPacketizerFile.cxx:374
 TPacketizerFile.cxx:375
 TPacketizerFile.cxx:376
 TPacketizerFile.cxx:377
 TPacketizerFile.cxx:378
 TPacketizerFile.cxx:379
 TPacketizerFile.cxx:380
 TPacketizerFile.cxx:381
 TPacketizerFile.cxx:382
 TPacketizerFile.cxx:383
 TPacketizerFile.cxx:384
 TPacketizerFile.cxx:385
 TPacketizerFile.cxx:386
 TPacketizerFile.cxx:387
 TPacketizerFile.cxx:388
 TPacketizerFile.cxx:389
 TPacketizerFile.cxx:390
 TPacketizerFile.cxx:391
 TPacketizerFile.cxx:392
 TPacketizerFile.cxx:393
 TPacketizerFile.cxx:394
 TPacketizerFile.cxx:395
 TPacketizerFile.cxx:396
 TPacketizerFile.cxx:397
 TPacketizerFile.cxx:398
 TPacketizerFile.cxx:399
 TPacketizerFile.cxx:400
 TPacketizerFile.cxx:401
 TPacketizerFile.cxx:402
 TPacketizerFile.cxx:403
 TPacketizerFile.cxx:404
 TPacketizerFile.cxx:405
 TPacketizerFile.cxx:406
 TPacketizerFile.cxx:407
 TPacketizerFile.cxx:408
 TPacketizerFile.cxx:409
 TPacketizerFile.cxx:410
 TPacketizerFile.cxx:411
 TPacketizerFile.cxx:412
 TPacketizerFile.cxx:413
 TPacketizerFile.cxx:414
 TPacketizerFile.cxx:415
 TPacketizerFile.cxx:416
 TPacketizerFile.cxx:417
 TPacketizerFile.cxx:418
 TPacketizerFile.cxx:419
 TPacketizerFile.cxx:420
 TPacketizerFile.cxx:421
 TPacketizerFile.cxx:422
 TPacketizerFile.cxx:423
 TPacketizerFile.cxx:424
 TPacketizerFile.cxx:425
 TPacketizerFile.cxx:426
 TPacketizerFile.cxx:427
 TPacketizerFile.cxx:428
 TPacketizerFile.cxx:429
 TPacketizerFile.cxx:430
 TPacketizerFile.cxx:431
 TPacketizerFile.cxx:432
 TPacketizerFile.cxx:433
 TPacketizerFile.cxx:434
 TPacketizerFile.cxx:435
 TPacketizerFile.cxx:436
 TPacketizerFile.cxx:437
 TPacketizerFile.cxx:438
 TPacketizerFile.cxx:439
 TPacketizerFile.cxx:440
 TPacketizerFile.cxx:441
 TPacketizerFile.cxx:442
 TPacketizerFile.cxx:443
 TPacketizerFile.cxx:444
 TPacketizerFile.cxx:445
 TPacketizerFile.cxx:446
 TPacketizerFile.cxx:447
 TPacketizerFile.cxx:448
 TPacketizerFile.cxx:449
 TPacketizerFile.cxx:450
 TPacketizerFile.cxx:451
 TPacketizerFile.cxx:452
 TPacketizerFile.cxx:453
 TPacketizerFile.cxx:454
 TPacketizerFile.cxx:455
 TPacketizerFile.cxx:456
 TPacketizerFile.cxx:457
 TPacketizerFile.cxx:458
 TPacketizerFile.cxx:459
 TPacketizerFile.cxx:460
 TPacketizerFile.cxx:461
 TPacketizerFile.cxx:462
 TPacketizerFile.cxx:463
 TPacketizerFile.cxx:464
 TPacketizerFile.cxx:465
 TPacketizerFile.cxx:466
 TPacketizerFile.cxx:467
 TPacketizerFile.cxx:468
 TPacketizerFile.cxx:469
 TPacketizerFile.cxx:470
 TPacketizerFile.cxx:471
 TPacketizerFile.cxx:472
 TPacketizerFile.cxx:473
 TPacketizerFile.cxx:474
 TPacketizerFile.cxx:475
 TPacketizerFile.cxx:476
 TPacketizerFile.cxx:477
 TPacketizerFile.cxx:478
 TPacketizerFile.cxx:479
 TPacketizerFile.cxx:480
 TPacketizerFile.cxx:481
 TPacketizerFile.cxx:482
 TPacketizerFile.cxx:483
 TPacketizerFile.cxx:484
 TPacketizerFile.cxx:485
 TPacketizerFile.cxx:486
 TPacketizerFile.cxx:487
 TPacketizerFile.cxx:488
 TPacketizerFile.cxx:489
 TPacketizerFile.cxx:490
 TPacketizerFile.cxx:491
 TPacketizerFile.cxx:492
 TPacketizerFile.cxx:493
 TPacketizerFile.cxx:494
 TPacketizerFile.cxx:495
 TPacketizerFile.cxx:496
 TPacketizerFile.cxx:497
 TPacketizerFile.cxx:498
 TPacketizerFile.cxx:499
 TPacketizerFile.cxx:500
 TPacketizerFile.cxx:501