TPacketizerDev

class TPacketizerDev : public TVirtualPacketizer

    private:

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

    public:

                            TPacketizerDev(TDSet* dset, TList* slaves, Long64_t first, Long64_t num, TList* input)
                    virtual ~TPacketizerDev()
             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

                                                                      
 TPacketizerDev                                                       
                                                                      
 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 form the list of actives

 Remove node form 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 to be processed

 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.