GMPBase.py

Go to the documentation of this file.

from Gaudi.Configuration import *
from GaudiPython import AppMgr, gbl, setOwnership, PyAlgorithm, SUCCESS,FAILURE
from ROOT import TBufferFile, TBuffer
from multiprocessing import Process, Queue, JoinableQueue, Event
from multiprocessing import cpu_count, current_process
from multiprocessing.queues import Empty
from pTools import *
import time, sys, os

# This script contains the bases for the Gaudi MultiProcessing (GMP)
# classes

# There are three classes :
#   Reader
#   Worker
#   Writer

# Each class needs to perform communication with the others
# For this, we need a means of communication, which will be based on
# the python multiprocessing package
# This is provided in SPI pytools package
# cmt line : use pytools v1.1 LCG_Interfaces
# The PYTHONPATH env variable may need to be modified, as this might
# still point to 1.0_python2.5

# Each class will need Queues, and a defined method for using these
# queues.
# For example, as long as there is something in the Queue, both ends
# of the queue must be open
# Also, there needs to be proper Termination flags and criteria
# The System should be error proof.


# Constants -------------------------------------------------------------------
NAP = 0.001
MB  = 1024.0*1024.0
# waits to guard against hanging, in seconds
WAIT_INITIALISE   = 60*5
WAIT_FIRST_EVENT  = 60*3
WAIT_SINGLE_EVENT = 60*3
WAIT_FINALISE     = 60*2
STEP_INITIALISE   = 10
STEP_EVENT        = 2
STEP_FINALISE     = 5

# My switch for direct switching on/off Smaps Algorithm in GaudiPython AppMgr
SMAPS = False

# -----------------------------------------------------------------------------

# definitions
# ----------
# used to convert stored histos (in AIDA format) to ROOT format
aida2root = gbl.Gaudi.Utils.Aida2ROOT.aida2root

# used to check which type of histo we are dealing with
# i.e. if currentHisto in aidatypes : pass
aidatypes = ( gbl.AIDA.IHistogram,
              gbl.AIDA.IHistogram1D,
              gbl.AIDA.IHistogram2D,
              gbl.AIDA.IHistogram3D,
              gbl.AIDA.IProfile1D,
              gbl.AIDA.IProfile2D,
              gbl.AIDA.IBaseHistogram  )  # extra?

# similar to aidatypes
thtypes   = ( gbl.TH1D, gbl.TH2D, gbl.TH3D, gbl.TProfile, gbl.TProfile2D )

# Types of OutputStream in Gaudi
WRITERTYPES  = {  'EvtCollectionStream'    : "tuples",
                  'InputCopyStream'        : "events",
                  'OutputStream'           : "events",
                  'RecordStream'           : "records",
                  'RunRecordStream'        : "records",
                  'SequentialOutputStream' : "events",
                  'TagCollectionStream'    : "tuples"   }

# =============================================================================

class MiniWriter( object ) :
    '''
    A class to represent a writer in the GaudiPython configuration
    It can be non-trivial to access the name of the output file; it may be
    specified in the DataSvc, or just on the writer, may be a list, or string
    Also, there are three different types of writer (events, records, tuples)
    so this bootstrap class provides easy access to this info while configuring
    '''
    def __init__( self, writer, wType, config ) :
        self.w     = writer
        self.wType = wType
        # set parameters for directly accessing the correct
        #   part of the configuration, so that later, we can do
        #   config[ key ].Output = modified(output)
        self.key          = None
        self.output       = None
        self.ItemList     = None
        self.OptItemList  = None
        #
        self.wName = writer.getName()
        # Now process the Writer, find where the output is named
        self.woutput     = None
        self.datasvcName = None
        self.svcOutput   = None
        if hasattr( self.w, "Output" ) :
            self.woutput = self.w.Output
            self.getItemLists( config )
            self.set( self.wName, self.w.Output )
            return
        else :
            # if there is no output file, get it via the datasvc
            # (every writer always has a datasvc property)
            self.datasvcName = self.w.EvtDataSvc
            datasvc = config[ self.datasvcName ]
            if hasattr( datasvc, "Output" ) :
                self.getItemLists( config )
                self.set( self.datasvcName, datasvc.Output )
                return

    def getNewName( self, replaceThis, withThis, extra='' ) :
        # replace one pattern in the output name string
        #  with another, and return the Output name
        # It *might* be in a list, so check for this
        #
        # @param extra : might need to add ROOT flags
        #                i.e.: OPT='RECREATE', or such
        assert replaceThis.__class__.__name__ == 'str'
        assert    withThis.__class__.__name__ == 'str'
        old = self.output
        lst = False
        if old.__class__.__name__ == 'list' :
            old = self.output[0]
            lst = True
        new = old.replace( replaceThis, withThis )
        new += extra
        if lst :
            return [ new ]
        else :
            return new

    def getItemLists( self, config ) :
        # the item list
        if hasattr( self.w, "ItemList" ) :
            self.ItemList = self.w.ItemList
        else :
            datasvc = config[ self.w.EvtDataSvc ]
            if hasattr( datasvc, "ItemList" ) :
                self.ItemList = datasvc.ItemList
        # The option item list; possibly not a valid variable
        if hasattr( self.w, "OptItemList" ) :
            self.OptItemList = self.w.OptItemList
        else :
            datasvc = config[ self.w.EvtDataSvc ]
            if hasattr( datasvc, "OptItemList" ) :
                self.OptItemList = datasvc.OptItemList
        return

    def set( self, key, output ) :
        self.key         = key
        self.output      = output
        return

    def __repr__( self ) :
        s  = ""
        line = '-'*80
        s += (line+'\n')
        s += "Writer         : %s\n"%( self.wName  )
        s += "Writer Type    : %s\n"%( self.wType  )
        s += "Writer Output  : %s\n"%( self.output )
        s += "DataSvc        : %s\n"%( self.datasvcName )
        s += "DataSvc Output : %s\n"%( self.svcOutput   )
        s += '\n'
        s += "Key for config : %s\n"%( self.key    )
        s += "Output File    : %s\n"%( self.output )
        s += "ItemList       : %s\n"%( self.ItemList )
        s += "OptItemList    : %s\n"%( self.OptItemList )
        s += (line+'\n')
        return s

# =============================================================================

class CollectHistograms( PyAlgorithm ) :
    '''
    GaudiPython algorithm used to clean up histos on the Reader and Workers
    Only has a finalize method()
    This retrieves a dictionary of path:histo objects and sends it to the
    writer.  It then waits for a None flag : THIS IS IMPORTANT, as if
    the algorithm returns before ALL histos have been COMPLETELY RECEIVED
    at the writer end, there will be an error.
    '''
    def __init__( self, gmpcomponent ) :
        PyAlgorithm.__init__( self )
        self._gmpc = gmpcomponent
        self.log = self._gmpc.log
        return None
    def execute( self ) :
        return SUCCESS
    def finalize( self ) :
        self.log.info('CollectHistograms Finalise (%s)'%(self._gmpc.nodeType))
        self._gmpc.hDict = self._gmpc.dumpHistograms( )
        ks = self._gmpc.hDict.keys()
        self.log.info('%i Objects in Histogram Store'%(len(ks)))
        # crashes occurred due to Memory Error during the sending of hundreds
        # histos on slc5 machines, so instead, break into chunks
        # send 100 at a time
        chunk = 100
        reps = len(ks)/chunk + 1
        for i in xrange(reps) :
            someKeys = ks[i*chunk : (i+1)*chunk]
            smalld = dict( [(key, self._gmpc.hDict[key]) for key in someKeys] )
            self._gmpc.hq.put( (self._gmpc.nodeID, smalld) )
        # "finished" Notification
        self.log.debug('Signalling end of histos to Writer')
        self._gmpc.hq.put( 'HISTOS_SENT' )
        self.log.debug( 'Waiting on Sync Event' )
        self._gmpc.sEvent.wait()
        self.log.debug( 'Histo Sync Event set, clearing and returning' )
        self._gmpc.hvt.clearStore()
        root = gbl.DataObject()
        setOwnership(root, False)
        self._gmpc.hvt.setRoot( '/stat', root )
        return SUCCESS

# =============================================================================

class EventCommunicator( object ) :
    # This class is responsible for communicating Gaudi Events via Queues
    # Events are communicated as TBufferFiles, filled either by the
    # TESSerializer, or the GaudiSvc, "IPCSvc"
    def __init__( self, GMPComponent, qin, qout ) :
        self._gmpc = GMPComponent
        self.log   = self._gmpc.log
        # maximum capacity of Queues
        self.maxsize = 50
        # central variables : Queues
        self.qin  = qin
        self.qout = qout

        # flags
        self.allsent = False
        self.allrecv = False

        # statistics storage
        self.nSent    = 0    # counter : items sent
        self.nRecv    = 0    # counter : items received
        self.sizeSent = 0    # measure : size of events sent ( tbuf.Length() )
        self.sizeRecv = 0    # measure : size of events in   ( tbuf.Length() )
        self.qinTime  = 0    # time    : receiving from self.qin
        self.qoutTime = 0    # time    : sending on qout

    def send( self, item ) :
        # This class manages the sending of a TBufferFile Event to a Queue
        # The actual item to be sent is a tuple : ( evtNumber, TBufferFile )
        assert item.__class__.__name__ == 'tuple'
        startTransmission = time.time()
        self.qout.put( item )
        # allow the background thread to feed the Queue; not 100% guaranteed to
        # finish before next line
        while self.qout._buffer : time.sleep( NAP )
        self.qoutTime += time.time()-startTransmission
        self.sizeSent += item[1].Length()
        self.nSent += 1
        return SUCCESS

    def receive( self, timeout=None ) :
        # Receive items from self.qin
        startWait = time.time()
        try :
            itemIn = self.qin.get( timeout=timeout )
        except Empty :
            return None
        self.qinTime += time.time()-startWait
        self.nRecv += 1
        if itemIn.__class__.__name__ == 'tuple' :
            self.sizeRecv += itemIn[1].Length()
        else :
            self.nRecv -= 1
        try :
            self.qin.task_done()
        except :
            self._gmpc.log.warning('TASK_DONE called too often by : %s'\
                                    %(self._gmpc.nodeType))
        return itemIn

    def finalize( self ) :
        self.log.info('Finalize Event Communicator : %s'%(self._gmpc.nodeType))
        # Reader sends one flag for each worker
        # Workers send one flag each
        # Writer sends nothing (it's at the end of the chain)
        if   self._gmpc.nodeType == 'Reader' : downstream = self._gmpc.nWorkers
        elif self._gmpc.nodeType == 'Writer' : downstream = 0
        elif self._gmpc.nodeType == 'Worker' : downstream = 1
        for i in xrange(downstream) :
            self.qout.put( 'FINISHED' )
        if self._gmpc.nodeType != 'Writer' :
            self.qout.join()
        # Now some reporting...
        self.statistics( )

    def statistics( self ) :
        self.log.name = '%s-%i Audit '%(self._gmpc.nodeType,self._gmpc.nodeID)
        self.log.info ( 'Items Sent     : %i'%(self.nSent) )
        self.log.info ( 'Items Received : %i'%(self.nRecv) )
        self.log.info ( 'Data  Sent     : %i'%(self.sizeSent) )
        self.log.info ( 'Data  Received : %i'%(self.sizeRecv) )
        self.log.info ( 'Q-out Time     : %5.2f'%(self.qoutTime) )
        self.log.info ( 'Q-in  Time     : %5.2f'%(self.qinTime ) )

# =============================================================================

class TESSerializer( object ) :
    def __init__( self, gaudiTESSerializer, evtDataSvc,
                        nodeType, nodeID, log ) :
        self.T   = gaudiTESSerializer
        self.evt = evtDataSvc
        self.buffersIn  = []
        self.buffersOut = []
        self.nIn     = 0
        self.nOut    = 0
        self.tDump   = 0.0
        self.tLoad   = 0.0
        # logging
        self.nodeType = nodeType
        self.nodeID   = nodeID
        self.log      = log
    def Load( self, tbuf ) :
        root = gbl.DataObject()
        setOwnership( root, False )
        self.evt.setRoot( '/Event', root )
        t = time.time()
        self.T.loadBuffer( tbuf )
        self.tLoad   += (time.time() - t)
        self.nIn     += 1
        self.buffersIn.append( tbuf.Length() )
    def Dump( self ) :
        t = time.time()
        tb = TBufferFile( TBuffer.kWrite )
        self.T.dumpBuffer(tb)
        self.tDump += ( time.time()-t )
        self.nOut  += 1
        self.buffersOut.append( tb.Length() )
        return tb
    def Report( self ) :
        evIn       = "Events Loaded    : %i"%( self.nIn  )
        evOut      = "Events Dumped    : %i"%( self.nOut )
        din = sum( self.buffersIn )
        dataIn     = "Data Loaded      : %i"%(din)
        dataInMb   = "Data Loaded (MB) : %5.2f Mb"%(din/MB)
        if self.nIn :
            avgIn      = "Avg Buf Loaded   : %5.2f Mb"\
                          %( din/(self.nIn*MB) )
            maxIn      = "Max Buf Loaded   : %5.2f Mb"\
                          %( max(self.buffersIn)/MB )
        else :
            avgIn      = "Avg Buf Loaded   : N/A"
            maxIn      = "Max Buf Loaded   : N/A"
        dout = sum( self.buffersOut )
        dataOut    = "Data Dumped      : %i"%(dout)
        dataOutMb  = "Data Dumped (MB) : %5.2f Mb"%(dout/MB)
        if self.nOut :
            avgOut     = "Avg Buf Dumped   : %5.2f Mb"\
                          %( din/(self.nOut*MB) )
            maxOut     = "Max Buf Dumped   : %5.2f Mb"\
                          %( max(self.buffersOut)/MB )
        else :
            avgOut     = "Avg Buf Dumped   : N/A"
            maxOut     = "Max Buf Dumped   : N/A"
        dumpTime   = "Total Dump Time  : %5.2f"%( self.tDump )
        loadTime   = "Total Load Time  : %5.2f"%( self.tLoad )

        lines =  evIn     ,\
                 evOut    ,\
                 dataIn   ,\
                 dataInMb ,\
                 avgIn    ,\
                 maxIn    ,\
                 dataOut  ,\
                 dataOutMb,\
                 avgOut   ,\
                 maxOut   ,\
                 dumpTime ,\
                 loadTime
        self.log.name = "%s-%i TESSerializer"%(self.nodeType, self.nodeID)
        for line in lines :
            self.log.info( line )
        self.log.name = "%s-%i"%(self.nodeType, self.nodeID)

# =============================================================================

class GMPComponent( object ) :
    # This class will be the template for Reader, Worker and Writer
    # containing all common components
    # nodeId will be a numerical identifier for the node
    # -1 for reader
    # -2 for writer
    # 0,...,nWorkers-1 for the Workers
    def __init__( self, nodeType, nodeID, queues, events, params  ) :
        # declare a Gaudi MultiProcessing Node
        # the nodeType is going to be one of Reader, Worker, Writer
        # qPair is going to be a tuple of ( qin, qout )
        # for sending and receiving
        # if nodeType is "Writer", it will be a list of qPairs,
        # as there's one queue-in from each Worker
        #
        # params is a tuple of (nWorkers, config, log)

        self.nodeType = nodeType
        current_process().name = nodeType

        # Synchronisation Event() objects for keeping track of the system
        self.initEvent, eventLoopSyncer, self.finalEvent = events
        self.eventLoopSyncer, self.lastEvent = eventLoopSyncer   # unpack tuple

        # necessary for knowledge of the system
        self.nWorkers, self.sEvent, self.config, self.log = params
        self.nodeID   = nodeID

        # describe the state of the node by the current Event Number
        self.currentEvent = None

        # Unpack the Queues : (events, histos, filerecords)
        qPair, histq, fq = queues

        # Set up the Queue Mechanisms ( Event Communicators )
        if self.nodeType == 'Reader' or self.nodeType == 'Worker' :
            # Reader or Worker Node
            qin, qout = qPair
            self.evcom = EventCommunicator( self, qin, qout )
        else :
            # Writer : many queues in, no queue out
            assert self.nodeType == 'Writer'
            self.evcoms = []
            qsin = qPair[0]
            for q in qsin :
                ec = EventCommunicator( self, q, None )
                self.evcoms.append( ec )
        # Histogram Queue
        self.hq = histq
        # FileRecords Queue
        self.fq = fq

        # Universal Counters (available to all nodes)
        # Use sensibly!!!
        self.nIn  = 0
        self.nOut = 0

        # Status Flag (possibly remove later)
        self.stat = SUCCESS

        # Set logger name
        self.log.name = '%s-%i'%(self.nodeType, self.nodeID)

        # Heuristic variables
        # time for init, run, final, firstEventTime, totalTime
        self.iTime       = 0.0
        self.rTime       = 0.0
        self.fTime       = 0.0
        self.firstEvTime = 0.0
        self.tTime       = 0.0

        # define the separate process
        self.proc = Process( target=self.Engine )

    def Start( self ) :
        # Fork and start the separate process
        self.proc.start()

    def Engine( self ) :
        # This will be the method carried out by the Node
        # Different for all
        pass

    def processConfiguration( self ) :
        # Different for all ; customize Configuration for multicore
        pass

    def SetupGaudiPython( self ) :
        # This method will initialize the GaudiPython Tools
        # such as the AppMgr and so on
        self.a   = AppMgr()
        if SMAPS :
            from AlgSmapShot import SmapShot
            smapsLog = self.nodeType+'-'+str(self.nodeID)+'.smp'
            ss = SmapShot( logname=smapsLog )
            self.a.addAlgorithm( ss )
        self.evt = self.a.evtsvc()
        self.hvt = self.a.histsvc()
        self.fsr = self.a.filerecordsvc()
        self.inc = self.a.service('IncidentSvc','IIncidentSvc')
        self.pers = self.a.service( 'EventPersistencySvc', 'IAddressCreator' )
        self.ts  = gbl.GaudiMP.TESSerializer( self.evt._idp, self.pers )
        self.TS  = TESSerializer( self.ts, self.evt,
                                  self.nodeType, self.nodeID, self.log )
        return SUCCESS

    def StartGaudiPython( self ) :
        self.a.initialize()
        self.a.start()
        return SUCCESS

    def LoadTES( self, tbufferfile ) :
        root = gbl.DataObject()
        setOwnership(root, False)
        self.evt.setRoot( '/Event', root )
        self.ts.loadBuffer(tbufferfile)

    def getEventNumber( self ) :
        # Using getList or getHistoNames can result in the EventSelector
        # re-initialising connection to RootDBase, which costs a lot of
        # time... try to build a set of Header paths??

        # First Attempt : Unpacked Event Data
        lst = [ '/Event/Gen/Header',
                '/Event/Rec/Header' ]
        for l in lst :
            path = l
            try :
                n = self.evt[path].evtNumber()
                return n
            except :
                # No evt number at this path
                continue

        # second attepmt : try DAQ/RawEvent data
        # The Evt Number is in bank type 16, bank 0, data pt 4
        try :
            n = self.evt['/Event/DAQ/RawEvent'].banks(16)[0].data()[4]
            return n
        except :
            pass

        # Default Action
        if self.nIn > 0 or self.nOut > 0 :
            pass
        else :
            self.log.warning('Could not determine Event Number')
        return -1

    def IdentifyWriters( self ) :
        #
        # Identify Writers in the Configuration
        #
        d = {}
        keys = [ "events", "records", "tuples", "histos" ]
        for k in keys :
            d[k] = []

        # Identify Writers and Classify
        wkeys = WRITERTYPES.keys()
        for v in self.config.values() :
            if v.__class__.__name__ in wkeys :
                writerType = WRITERTYPES[ v.__class__.__name__ ]
                d[writerType].append( MiniWriter(v, writerType, self.config) )
                if self.nodeID == 0 :
                    self.log.info('Writer Found : %s'%(v.name()))

        # Now Check for the Histogram Service
        if 'HistogramPersistencySvc' in  self.config.keys() :
            hfile =self.config['HistogramPersistencySvc'].getProp('OutputFile')
            d[ "histos" ].append( hfile )
        return d

    def dumpHistograms( self ) :
        '''
        Method used by the GaudiPython algorithm CollectHistos
        to obtain a dictionary of form { path : object }
        representing the Histogram Store
        '''
        nlist = self.hvt.getHistoNames( )
        histDict = {}
        objects = 0 ; histos = 0
        if nlist :
            for n in nlist :
                o = self.hvt[ n ]
                if type(o) in aidatypes :
                    o = aida2root(o)
                    histos  += 1
                else :
                    objects += 1
                histDict[ n ] = o
        else :
            print 'WARNING : no histograms to recover?'
        return histDict

    def Initialize( self ) :
        start = time.time()
        self.processConfiguration( )
        self.SetupGaudiPython( )
        # Set the initialisation flag!
        self.initEvent.set()
        self.StartGaudiPython( )
        self.iTime = time.time() - start

    def Finalize( self ) :
        start = time.time()
        self.a.stop()
        self.a.finalize()
        self.log.info( '%s-%i Finalized'%(self.nodeType, self.nodeID) )
        self.finalEvent.set()
        self.fTime = time.time() - start

    def Report( self ) :
        self.log.name = "%s-%i Audit"%(self.nodeType, self.nodeID)
        allTime  = "Alive Time     : %5.2f"%(self.tTime)
        initTime = "Init Time      : %5.2f"%(self.iTime)
        frstTime = "1st Event Time : %5.2f"%(self.firstEvTime)
        runTime  = "Run Time       : %5.2f"%(self.rTime)
        finTime  = "Finalise Time  : %5.2f"%(self.fTime)
        tup = ( allTime, initTime, frstTime, runTime, finTime )
        for t in tup :
            self.log.info( t )
        self.log.name = "%s-%i"%(self.nodeType, self.nodeID)
        # and report from the TESSerializer
        self.TS.Report()

# =============================================================================

class Reader( GMPComponent )  :
    def __init__( self, queues, events, params ) :
        GMPComponent.__init__(self, 'Reader', -1, queues, events, params )

    def processConfiguration( self ) :
        # Reader :
        #   No algorithms
        #   No output
        #   No histos
        self.config[ 'ApplicationMgr' ].TopAlg    = []
        self.config[ 'ApplicationMgr' ].OutStream = []
        if "HistogramPersistencySvc" in self.config.keys() :
            self.config[ 'HistogramPersistencySvc' ].OutputFile = ''
        self.config['MessageSvc'].Format    = '[Reader]% F%18W%S%7W%R%T %0W%M'
        self.evtMax = self.config[ 'ApplicationMgr' ].EvtMax

    def DumpEvent( self ) :
        tb = TBufferFile( TBuffer.kWrite )
        # print '----Reader dumping Buffer!!!'
        self.ts.dumpBuffer( tb )
        # print '\tBuffer Dumped, size : %i'%( tb.Length() )
        return tb

    def DoFirstEvent( self ) :
        # Do First Event ------------------------------------------------------
        # Check Termination Criteria
        startFirst = time.time()
        self.log.info('Reader : First Event')
        if self.nOut == self.evtMax :
            self.log.info('evtMax( %i ) reached'%(self.evtMax))
            self.lastEvent.set()
            return SUCCESS
        else :
            # Continue to read, dump and send event
            self.a.run(1)
            if not bool(self.evt['/Event']) :
                self.log.warning('No More Events! (So Far : %i)'%(self.nOut))
                self.lastEvent.set()
                return SUCCESS
            else :
                # Popluate TESSerializer list and send Event
                try :
                    lst = self.evt.getList()
                except :
                    self.log.critical('Reader could not acquire TES List!')
                    self.lastEvent.set()
                    return FAILURE
                self.log.info('Reader : TES List : %i items'%(len(lst)))
                for l in lst :
                    self.ts.addItem(l)
                self.currentEvent = self.getEventNumber( )
                tb = self.TS.Dump( )
                self.log.info('First Event Sent')
                self.evcom.send( (self.currentEvent, tb) )
                self.nOut += 1
                self.eventLoopSyncer.set()
                self.evt.clearStore( )
                self.firstEvTime = time.time()-startFirst
                return SUCCESS

    def Engine( self ) :

        startEngine = time.time()
        self.log.name = 'Reader'
        self.log.info('Reader Process starting')

        self.Initialize()

        # add the Histogram Collection Algorithm
        self.a.addAlgorithm( CollectHistograms(self) )

        self.log.info('Reader Beginning Distribution')
        sc = self.DoFirstEvent( )
        if sc.isSuccess() :
            self.log.info('Reader First Event OK')
        else :
            self.log.critical('Reader Failed on First Event')
            self.stat = FAILURE

        # Do All Others -------------------------------------------------------
        while True :
            # Check Termination Criteria
            if self.nOut == self.evtMax :
                self.log.info('evtMax( %i ) reached'%(self.evtMax))
                break
            # Check Health
            if not self.stat.isSuccess() :
                self.log.critical( 'Reader is Damaged!' )
                break
            # Continue to read, dump and send event
            t = time.time()
            self.a.run(1)
            self.rTime += (time.time()-t)
            if not bool(self.evt['/Event']) :
                self.log.warning('No More Events! (So Far : %i)'%(self.nOut))
                break
            self.currentEvent = self.getEventNumber( )
            tb = self.TS.Dump( )
            self.evcom.send( (self.currentEvent, tb) )
            # clean up
            self.nOut += 1
            self.eventLoopSyncer.set()
            self.evt.clearStore( )
        self.log.info('Setting <Last> Event')
        self.lastEvent.set()

        # Finalize
        self.log.info( 'Reader : Event Distribution complete.' )
        self.evcom.finalize()
        self.Finalize()
        self.tTime = time.time() - startEngine
        self.Report()

# =============================================================================

class Worker( GMPComponent ) :
    def __init__( self, workerID, queues, events, params ) :
        GMPComponent.__init__(self,'Worker', workerID, queues, events, params)
        # Identify the writer streams
        self.writerDict = self.IdentifyWriters( )
        # Identify the accept/veto checks for each event
        self.acceptAlgs, self.requireAlgs, self.vetoAlgs = self.getCheckAlgs()
        self.log.debug("Worker-%i Created OK"%(self.nodeID))
        self.eventOutput = True

    def processConfiguration( self ) :
        # Worker :
        #   No input
        #   No output
        #   No Histos
        self.config[ 'EventSelector'  ].Input     = []
        self.config[ 'ApplicationMgr' ].OutStream = []
        if "HistogramPersistencySvc" in self.config.keys() :
            self.config[ 'HistogramPersistencySvc' ].OutputFile = ''
        formatHead = '[Worker-%i] '%(self.nodeID)
        self.config['MessageSvc'].Format = formatHead+'% F%18W%S%7W%R%T %0W%M'

        for key, lst in self.writerDict.iteritems() :
            self.log.info( 'Writer Type : %s\t : %i'%(key, len(lst)) )

        for m in self.writerDict[ "tuples" ] :
            # rename Tuple output file with an appendix
            # based on worker id, for merging later
            newName = m.getNewName( '.', '.w%i.'%(self.nodeID) )
            self.config[ m.key ].Output = newName

        # Suppress INFO Output for all but Worker-0
        if self.nodeID == 0 :
            pass
        else                :
            self.config[ 'MessageSvc' ].OutputLevel = ERROR

    def Engine( self ) :
        startEngine = time.time()
        self.log.name = "Worker-%i"%(self.nodeID)
        self.log.info("Worker %i starting Engine"%(self.nodeID))
        self.Initialize()
        self.filerecordsAgent = FileRecordsAgent(self)

        # populate the TESSerializer itemlist
        self.log.info('EVT WRITERS ON WORKER : %i'\
                       %( len(self.writerDict['events'])))

        nEventWriters = len( self.writerDict[ "events" ] )
        if nEventWriters :
            for m in self.writerDict[ "events" ] :
                for item in m.ItemList :
                    self.log.debug(' adding ItemList Item to ts : %s'%(item))
                    self.ts.addItem( item )
                for item in m.OptItemList :
                    self.log.debug(' adding Optional Item to ts : %s'%(item))
                    self.ts.addOptItem( item )
        else :
            self.log.info( 'There is no Event Output for this app' )
            self.eventOutput = False

        # add the Histogram Collection Algorithm
        self.a.addAlgorithm( CollectHistograms(self) )

        # Begin processing
        self.log.name = "Worker-%i"%(self.nodeID)
        Go = True
        while Go :
            packet = self.evcom.receive( )
            if packet : pass
            else      : continue
            if packet == 'FINISHED' : break
            evtNumber, tbin = packet    # unpack
            self.nIn += 1
            self.TS.Load( tbin )
            # print 'Worker-%i : Event %i'%(self.nodeID, evtNumber)
            t = time.time()
            sc = self.a.executeEvent()
            if self.nIn == 1 :
                self.firstEvTime = time.time()-t
            else :
                self.rTime += (time.time()-t)
            if sc.isSuccess() :
                pass
            else :
                self.log.warning('Did not Execute Event')
                self.evt.clearStore()
                continue
            if self.isEventPassed() :
                pass
            else :
                self.log.warning( 'Event did not pass : %i'%(evtNumber) )
                self.evt.clearStore()
                continue
            if self.eventOutput :
                # It may be the case of generating Event Tags; hence
                #   no event output
                self.currentEvent = self.getEventNumber( )
                tb = self.TS.Dump( )
                self.evcom.send( (self.currentEvent, tb) )
                self.nOut += 1
            self.inc.fireIncident(gbl.Incident('Worker','EndEvent'))
            self.eventLoopSyncer.set()
            self.evt.clearStore( )
        self.log.info('Setting <Last> Event')
        self.lastEvent.set()

        self.evcom.finalize()
        self.log.info( 'Worker-%i Finished Processing Events'%(self.nodeID) )
        # Now send the FileRecords and stop/finalize the appMgr
        self.filerecordsAgent.SendFileRecords()
        self.Finalize()
        self.tTime = time.time()-startEngine
        self.Report()

    def getCheckAlgs( self ) :
        '''
        For some output writers, a check is performed to see if the event has
        executed certain algorithms.
        These reside in the AcceptAlgs property for those writers
        '''
        acc = []
        req = []
        vet = []
        for m in self.writerDict[ "events" ] :
            if hasattr(m.w, 'AcceptAlgs')  : acc += m.w.AcceptAlgs
            if hasattr(m.w, 'RequireAlgs') : req += m.w.RequireAlgs
            if hasattr(m.w, 'VetoAlgs')    : vet += m.w.VetoAlgs
        return (acc, req, vet)


    def checkExecutedPassed( self, algName ) :
        if  self.a.algorithm( algName )._ialg.isExecuted()\
        and self.a.algorithm( algName )._ialg.filterPassed() :
            return True
        else :
            return False

    def isEventPassed( self ) :
        '''
        Check the algorithm status for an event.
        Depending on output writer settings, the event
          may be declined based on various criteria.
        This is a transcript of the check that occurs in GaudiSvc::OutputStream
        '''
        passed = False

        self.log.debug('self.acceptAlgs is %s'%(str(self.acceptAlgs)))
        if self.acceptAlgs :
            for name in self.acceptAlgs :
                if self.checkExecutedPassed( name ) :
                    passed = True
                    break
        else :
            passed = True

        self.log.debug('self.requireAlgs is %s'%(str(self.requireAlgs)))
        for name in self.requireAlgs :
            if self.checkExecutedPassed( name ) :
                pass
            else :
                self.log.info('Evt declined (requireAlgs) : %s'%(name) )
                passed = False

        self.log.debug('self.vetoAlgs is %s'%(str(self.vetoAlgs)))
        for name in self.vetoAlgs :
            if self.checkExecutedPassed( name ) :
                pass
            else :
                self.log.info( 'Evt declined : (vetoAlgs) : %s'%(name) )
                passed = False
        return passed

# =============================================================================

class Writer( GMPComponent ) :
    def __init__( self, queues, events, params ) :
        GMPComponent.__init__(self,'Writer', -2, queues, events, params)
        # Identify the writer streams
        self.writerDict = self.IdentifyWriters( )
        # This keeps track of workers as they finish
        self.status = [False]*self.nWorkers
        self.log.name = "Writer--2"

    def processConfiguration( self ) :
        # Writer :
        #   No input
        #   No Algs
        self.config[ 'ApplicationMgr' ].TopAlg = []
        self.config[ 'EventSelector'  ].Input  = []

        self.config['MessageSvc'].Format = '[Writer] % F%18W%S%7W%R%T %0W%M'

        # Now process the output writers
        for key, lst in self.writerDict.iteritems() :
            self.log.info( 'Writer Type : %s\t : %i'%(key, len(lst)) )

        # Modify the name of the output file to reflect that it came
        #  from a parallel processing
        #
        # Event Writers
        for m in self.writerDict[ "events" ] :
            self.log.debug( 'Processing Event Writer : %s'%(m) )
            newName = m.getNewName( '.', '.p%i.'%self.nWorkers )
            self.config[ m.key ].Output = newName

        # Now, if there are no event writers, the FileRecords file
        #   will fail to open, as it only opens an UPDATE version
        #   of the existing Event Output File
        # So, if there are no event writers, edit the string of the
        #   FileRecord Writer

        # FileRecords Writers
        for m in self.writerDict[ "records" ] :
            self.log.debug( 'Processing FileRecords Writer: %s'%(m) )
            newName = m.getNewName( '.', '.p%i.'%self.nWorkers,
                                       extra=" OPT='RECREATE'" )
            self.config[ m.key ].Output = newName

        # same for histos
        hs = "HistogramPersistencySvc"
        n = None
        if hs in self.config.keys() :
            n = self.config[ hs ].OutputFile
        if n :
            newName=self.config[hs].OutputFile.replace('.',\
                                                       '.p%i.'%(self.nWorkers))
            self.config[ hs ].OutputFile = newName

    def Engine( self ) :
        startEngine = time.time()
        self.Initialize()
        self.histoAgent = HistoAgent( self )
        self.filerecordsAgent = FileRecordsAgent( self )

        # Begin processing
        Go      = True
        current = -1
        stopCriteria = self.nWorkers
        while Go :
            current = (current+1)%self.nWorkers
            packet = self.evcoms[current].receive( timeout=0.01 )
            if packet == None :
                continue
            if packet == 'FINISHED' :
                self.log.info('Writer got FINISHED flag : Worker %i'%(current))
                self.status[current] = True
                if all(self.status) :
                    self.log.info('FINISHED recd from all workers, break loop')
                    break
                continue
            # otherwise, continue as normal
            self.nIn += 1    # update central count (maybe needed by FSR store)
            evtNumber, tbin = packet    # unpack
            self.TS.Load( tbin )
            t  = time.time()
            self.a.executeEvent()
            self.rTime += ( time.time()-t )
            self.currentEvent = self.getEventNumber( )
            self.evt.clearStore( )
            self.eventLoopSyncer.set()
        self.log.name = "Writer--2"
        self.log.info('Setting <Last> Event')
        self.lastEvent.set()

        # finalisation steps
        [ e.finalize() for e in self.evcoms ]
        # Now do Histograms
        sc = self.histoAgent.Receive()
        sc = self.histoAgent.RebuildHistoStore()
        if sc.isSuccess() : self.log.info( 'Histo Store rebuilt ok' )
        else              : self.log.warning( 'Histo Store Error in Rebuild' )

        # Now do FileRecords
        sc = self.filerecordsAgent.Receive()
        self.filerecordsAgent.Rebuild()
        self.Finalize()
        self.rTime = time.time()-startEngine
        self.Report()

# =============================================================================



# =============================================================================

class Coord( object ) :
    def __init__( self, nWorkers, config, log ) :

        self.log = log
        self.config = config
        # set up Logging
        self.log.name = 'GaudiPython-Parallel-Logger'
        self.log.info( 'GaudiPython Parallel Process Co-ordinator beginning' )

        if nWorkers == -1 :
            # The user has requested all available cpus in the machine
            self.nWorkers = cpu_count()
        else :
            self.nWorkers = nWorkers


        self.qs = self.SetupQueues( )    # a dictionary of queues (for Events)
        self.hq = JoinableQueue( )       # for Histogram data
        self.fq = JoinableQueue( )       # for FileRecords data

        # Make a Syncer for Initalise, Run, and Finalise
        self.sInit = Syncer( self.nWorkers, self.log,
                             limit=WAIT_INITIALISE,
                             step=STEP_INITIALISE    )
        self.sRun  = Syncer( self.nWorkers, self.log,
                             manyEvents=True,
                             limit=WAIT_SINGLE_EVENT,
                             step=STEP_EVENT,
                             firstEvent=WAIT_FIRST_EVENT )
        self.sFin  = Syncer( self.nWorkers, self.log,
                             limit=WAIT_FINALISE,
                             step=STEP_FINALISE )
        # and one final one for Histogram Transfer
        self.histSyncEvent = Event()

        # params are common to al subprocesses
        params = (self.nWorkers, self.histSyncEvent, self.config, self.log)

        # Declare SubProcesses!
        self.reader= Reader(self.getQueues(-1), self.getSyncEvents(-1), params)
        self.workers = []
        for i in xrange( self.nWorkers ) :
            wk = Worker( i, self.getQueues(i), self.getSyncEvents(i), params )
            self.workers.append( wk )
        self.writer= Writer(self.getQueues(-2), self.getSyncEvents(-2), params)

        self.system = []
        self.system.append(self.writer)
        [ self.system.append(w) for w in self.workers ]
        self.system.append(self.reader)

    def getSyncEvents( self, nodeID ) :
        init = self.sInit.d[nodeID].event
        run  = ( self.sRun.d[nodeID].event, self.sRun.d[nodeID].lastEvent )
        fin  = self.sFin.d[nodeID].event
        return ( init, run, fin )

    def getQueues( self, nodeID ) :
        eventQ = self.qs[ nodeID ]
        histQ  = self.hq
        fsrQ   = self.fq
        return ( eventQ, histQ, fsrQ )

    def Go( self ) :

        # Initialise
        self.log.name = 'GaudiPython-Parallel-Logger'
        self.log.info( 'INITIALISING SYSTEM' )
        for p in self.system :
            p.Start()
        sc = self.sInit.syncAll(step="Initialise")
        if sc : pass
        else  : self.Terminate() ; return FAILURE

        # Run
        self.log.name = 'GaudiPython-Parallel-Logger'
        self.log.info( 'RUNNING SYSTEM' )
        sc = self.sRun.syncAll(step="Run")
        if sc : pass
        else  : self.Terminate() ; return FAILURE

        # Finalise
        self.log.name = 'GaudiPython-Parallel-Logger'
        self.log.info( 'FINALISING SYSTEM' )
        sc = self.sFin.syncAll(step="Finalise")
        if sc : pass
        else  : self.Terminate() ; return FAILURE

        # if we've got this far, finally report SUCCESS
        self.log.info( "Cleanly join all Processes" )
        self.Stop()
        self.log.info( "Report Total Success to Main.py" )
        return SUCCESS

    def Terminate( self ) :
        # Brutally kill sub-processes
        self.writer.proc.terminate()
        [ w.proc.terminate() for w in self.workers]
        self.reader.proc.terminate()

    def Stop( self ) :
        # procs should be joined in reverse order to launch
        self.system.reverse()
        for s in self.system :
            s.proc.join()
        return SUCCESS

    def SetupQueues( self ) :
        # This method will set up the network of Queues needed
        # N Queues = nWorkers + 1
        # Each Worker has a Queue in, and a Queue out
        # Reader has Queue out only
        # Writer has nWorkers Queues in

        # one queue from Reader-Workers
        rwk = JoinableQueue()
        # one queue from each worker to writer
        workersWriter = [ JoinableQueue() for i in xrange(self.nWorkers) ]
        d = {}
        d[-1] = (None, rwk)              # Reader
        d[-2] = (workersWriter, None)    # Writer
        for i in xrange(self.nWorkers) : d[i] =  (rwk, workersWriter[i])
        return d

# ============================= EOF ===========================================