GaudiMP.pTools.Syncer Class Reference

Inheritance diagram for GaudiMP.pTools.Syncer:

Collaboration diagram for GaudiMP.pTools.Syncer:

Public Member Functions
def	__init__

def	syncAll

def	syncAllRolling

def	processHang

def	checkAll

def	checkLastEvents

Public Attributes
	limit

	step

	d

	manyEvents

	limitFirst

	keys

	nWorkers

	log

Detailed Description

Definition at line 567 of file pTools.py.

Constructor & Destructor Documentation

def GaudiMP.pTools.Syncer.__init__	(	self,
		nWorkers,
		log,
		manyEvents = `False`,
		limit = `None`,
		step = `None`,
		firstEvent = `None`
	)

Definition at line 569 of file pTools.py.

 
                   limit=None, step=None, firstEvent=None ) :
         # Class to help synchronise the sub-processes
         self.limit  = limit
         self.step   = step
         self.d = {}
         self.manyEvents = manyEvents
 
         for i in xrange(-2, nWorkers) :
             self.d[ i ] = SyncMini( Event(), lastEvent=Event() )
             if self.manyEvents :
                 self.limitFirst = firstEvent
 
         self.keys       = self.d.keys()
         self.nWorkers   = nWorkers
         self.log        = log

Member Function Documentation

def GaudiMP.pTools.Syncer.checkAll ( self )

Definition at line 674 of file pTools.py.

 
     def checkAll( self ) :
         # Check the status of each Sync object
         # return True or False
         currentStatus = [ mini.check() for mini in self.d.values() ]
         return all( currentStatus )

def GaudiMP.pTools.Syncer.checkLastEvents ( self )

Definition at line 680 of file pTools.py.

 
     def checkLastEvents( self ) :
        # check if all of the lastEvents are set to true in self.d[k][1]
        stat    = [ sMini.checkLast() for sMini in self.d.values() ]
        return all(stat)
 
 # =========================== Methods =========================================

def GaudiMP.pTools.Syncer.processHang ( self )

Definition at line 668 of file pTools.py.

 
     def processHang( self ) :
         self.log.critical('Some proc is hanging during Event processing!')
         for k in self.keys :
             self.log.critical( "Proc/Stat : %i / %s"%(k,self.d[k].check()) )
         return

def GaudiMP.pTools.Syncer.syncAll	(	self,
		step = `"Not specified"`
	)

Definition at line 585 of file pTools.py.

 
     def syncAll( self, step="Not specified" ) :
         # is it this method, or is it the rolling version needed?
         # if so, drop through...
 
         if self.manyEvents :
             sc = self.syncAllRolling( )
             return sc
 
         # Regular version ----------------------------
         for i in xrange( 0, self.limit, self.step ) :
             if self.checkAll( ) :
                 self.log.info('%s : All procs done @ %i s'%(step,i))
                 break
             else :
                 time.sleep(self.step)
 
         # Now the time limit is up... check the status one final time
         if self.checkAll() :
             self.log.info("All processes : %s ok."%(step))
             return SUCCESS
         else :
             self.log.critical('Some process is hanging on : %s'%(step))
             for k in self.keys :
                 hangString= "%s : Proc/Stat : %i/%s"%(step,k,self.d[k].check())
                 self.log.critical( hangString )
             return FAILURE

def GaudiMP.pTools.Syncer.syncAllRolling ( self )

Definition at line 612 of file pTools.py.

 
     def syncAllRolling( self ) :
         # Keep track of the progress of Event processing
         # Each process syncs after each event, so keep clearing
         #  the sync Event, and re-checking
         # Note the time between True checks too, if the time
         #  between events exceeds singleEvent, this is considered a hang
 
         # set the initial time
         begin   = time.time()
         firstEv = {}
         timers  = {}
         for k in self.keys :
             self.d[k].reset()
             firstEv[k] = False
             timers[k]  = 0.0
 
         active = self.keys
         while True :
             # check the status of each sync object
             for k in active :
                 sMini = self.d[k]
 
                 if sMini.check() or sMini.checkLast():
                     if sMini.checkLast() and sMini.check() :
                         # if last Event set,then event loop finished
                         active.remove( k )
                         alive = time.time()-begin
                         self.log.info( "Audit : Node %i alive for %5.2f"\
                                        %(k,alive) )
                     else :
                         sMini.reset()
                 else :
                     # the event still has not been checked, how long is that?
                     # is it the first Event?
                     wait = time.time()-sMini.getTime()
                     cond = wait > self.limit
                     if not firstEv[k] :
                         cond       = wait > self.limitFirst
                         firstEv[k] = True
                     if cond :
                         # It is hanging!
                         self.log.critical('Single event wait : %5.2f'%(wait))
                         self.processHang()
                         return FAILURE
 
             # Termination Criteria : if all procs have been removed, we're done
             if self.checkLastEvents() :
                 self.log.info('TC met for event loop')
                 break
             else :
                 # sleep, loop again
                 time.sleep(self.step)
 
         self.log.info("All processes Completed all Events ok")
         return SUCCESS

Gaudi Framework, version v25r2

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation