TPacketizerProgressive

class TPacketizerProgressive : public TVirtualPacketizer

    private:

                                         TPacketizerProgressive()
                                         TPacketizerProgressive(const TPacketizerProgressive&)
                           TDSetElement* BuildPacket(TPacketizerProgressive::TSlaveStat* stat, Long64_t num)
      TPacketizerProgressive::TFileStat* GetNextActive(TPacketizerProgressive::TSlaveStat* stat)
      TPacketizerProgressive::TFileStat* GetNextUnAlloc(TPacketizerProgressive::TSlaveStat* stat)
                          virtual Bool_t HandleTimer(TTimer* timer)
                                    void Init()
                                    void RecalculatePacketSize(Long64_t newCount)

    public:

                             TPacketizerProgressive(TDSet* dset, TList* slaves, Long64_t first, Long64_t num, TList* input)
                     virtual ~TPacketizerProgressive()
              static TClass* Class()
            virtual Long64_t GetEntriesProcessed() const
            virtual Long64_t GetEntriesProcessed(TSlave* s) const
       virtual TDSetElement* GetNextPacket(TSlave* s, TMessage* r)
             virtual TClass* IsA() const
                virtual void ShowMembers(TMemberInspector& insp, char* parent)
                virtual void Streamer(TBuffer& b)
                        void StreamerNVirtual(TBuffer& b)

Data Members

    private:

           TDSet* fDset              
           TList* fSlaves            
           TList* fSlavesRemaining   slaves stilll working
         Long64_t fFirstEvent        
         Long64_t fTotalEvents       
         Long64_t fEntriesSeen       number of entries found so far
         Long64_t fFilesOpened       total number of files with their entries recorded
         Long64_t fEstTotalEntries   estimated total number of entries
         Long64_t fEntriesProcessed  total number of entries processed
            TMap* fSlaveStats        map of slave addresses to its TSlaveStat object
      THashTable* fNewFileSlaves     slaves that have just opened a new file and need to
           TList* fUnAllocSlaves     slave hosts that have unallocated files
           TList* fUnAllocNonSlaves  non-slave hosts that have unallocated files
           TList* fActiveSlaves      slave hosts that have active files
           TList* fActiveNonSlaves   non-slave hosts that have active files
           TList* fLastEntrySizes    list of the last kEntryListSize TDSetElement sizes (in entries)
         Long64_t fPacketSize        current packet size based on estimate of total number of entries
          TTimer* fProgress          progress bar timer

    public:

      static const enum TPacketizerProgressive:: kSlaveHostConnLim     
      static const enum TPacketizerProgressive:: kNonSlaveHostConnLim  
      static const enum TPacketizerProgressive:: kEntryListSize        

                                                                      
 TPacketizerProgressive                                               
                                                                      
 This class generates packets to be processed on PROOF slave servers. 
 A packet is an event range (begin entry and number of entries) or    
 object range (first object and number of objects) in a TTree         
 (entries) or a directory (objects) in a file.                        
 Packets are generated taking into account the performance of the     
 remote machine, the time it took to process a previous packet on     
 the remote machine, the locality of the database files, etc.         
 This packetizer does not pre-open the files to calculate the total   
 number of events, it just walks sequentially through the list of     
 files.                                                               
                                                                      

: fDset(dset), fSlaves(slaves), fSlavesRemaining(0), fFirstEvent(first),
fTotalEvents(num), fEntriesSeen(0), fFilesOpened(0),
fEstTotalEntries(0), fEntriesProcessed(0)
{
 Constructor

 Destructor

 Build slave -> slave stats map, available slave host list,
 and hash table of slave names.

 Get entries to be processed

 Build a packet

 Shrink fLastEntrySizes to (kEntryListSize - 1).

 Get next packet

 Send progress message to client.