TPacketizer

class TPacketizer : public TVirtualPacketizer

    private:

                              TPacketizer()
                              TPacketizer(const TPacketizer&)
                TDSetElement* CreateNewPacket(TDSetElement* base, Long64_t first, Long64_t num)
      TPacketizer::TFileStat* GetNextActive()
      TPacketizer::TFileStat* GetNextUnAlloc(TPacketizer::TFileNode* node = 0)
               virtual Bool_t HandleTimer(TTimer* timer)
      TPacketizer::TFileNode* NextActiveNode()
      TPacketizer::TFileNode* NextUnAllocNode()
                         void operator=(const TPacketizer&)
                         void RemoveActive(TPacketizer::TFileStat* file)
                         void RemoveActiveNode(TPacketizer::TFileNode*)
                         void RemoveUnAllocNode(TPacketizer::TFileNode*)
                         void Reset()
                         void SplitEventList(TDSet* dset)
                         void ValidateFiles(TDSet* dset, TList* slaves)

    public:

                            TPacketizer(TDSet* dset, TList* slaves, Long64_t first, Long64_t num, TList* input)
                    virtual ~TPacketizer()
             static TClass* Class()
           virtual Long64_t GetEntriesProcessed() const
           virtual Long64_t GetEntriesProcessed(TSlave* sl) const
      virtual TDSetElement* GetNextPacket(TSlave* sl, 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:

      Long64_t fProcessed     number of entries processed
        TList* fPackets       all processed packets
      Long64_t fTotalEntries  total number of entries to be distributed
        TList* fFileNodes     nodes with files
        TList* fUnAllocated   nodes with unallocated files
        TList* fActive        nodes with unfinished files
         TMap* fSlaveStats    slave status, keyed by correspondig TSlave
       TTimer* fProgress      progress updates timer
      Long64_t fPacketSize    global base packet size
         Int_t fMaxPerfIdx    maximum of our slaves' performance index
         Int_t fMaxSlaveCnt   maximum number of slaves per filenode

                                                                      
 TPacketizer                                                          
                                                                      
 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.         
                                                                      

 Constructor

 Destructor.

 Remove unallocated node.

 Remove file from the list of actives.

 Remove node from the list of actives.

 Reset the internal datastructure for packet distribution.

 Check existence of file/dir/tree an get number of entries.
 Assumes the files have been setup.

 Splits the eventlist into parts for each file.
 Each part is assigned to the apropriate TDSetElement.

 Get entries processed by the specified slave.

 Creates a new TDSetElement from from base packet starting from first entry with num entries.
 The function returns a new created objects which have to be deleted.

 Get next packet

 Send progress message to client.