Calorimeter/CaloCalibHitRec/python/CaloCalibHitDecoratorCfg.py

 # Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
 
 from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.ComponentFactory import CompFactory
 
 def CaloCalibHitDecoratorCfg():
     result=ComponentAccumulator()
 
-    from CaloCalibHitRec.CaloCalibHitRecConf import CaloCalibClusterTruthMapMakerAlgorithm
-    CaloCalibClusterTruthMapMakerAlgorithm = CaloCalibClusterTruthMapMakerAlgorithm()
-    result.addEventAlgo(CaloCalibClusterTruthMapMakerAlgorithm)
+    result.addEventAlgo(CompFactory.CaloCalibClusterTruthMapMakerAlgorithm())
 
-    from CaloCalibHitRec.CaloCalibHitRecConf import CaloCalibClusterDecoratorAlgorithm
-    CaloCalibClusterDecoratorAlgorithm = CaloCalibClusterDecoratorAlgorithm()
+    CaloCalibClusterDecoratorAlgorithm = CompFactory.CaloCalibClusterDecoratorAlgorithm()
 
-    from CaloCalibHitRec.CaloCalibHitRecConf import CaloCalibClusterTruthAttributerTool as CalibClusterTruthAttributerTool
-    CaloCalibClusterTruthAttributerTool = CalibClusterTruthAttributerTool()
-    CaloCalibClusterDecoratorAlgorithm.TruthAttributerTool = CaloCalibClusterTruthAttributerTool
+    CaloCalibClusterDecoratorAlgorithm.TruthAttributerTool = CompFactory.CaloCalibClusterTruthAttributerTool()
     result.addEventAlgo(CaloCalibClusterDecoratorAlgorithm)
 
     return result
\ No newline at end of file

Calorimeter/CaloCalibHitRec/src/CaloCalibClusterTruthAttributerTool.cxx

@@ -11,17 +11,19 @@ CaloCalibClusterTruthAttributerTool::~CaloCalibClusterTruthAttributerTool(){}
 
 StatusCode CaloCalibClusterTruthAttributerTool::calculateTruthEnergies(const xAOD::CaloCluster& theCaloCluster, unsigned int numTruthParticles, const std::map<Identifier,std::vector<const CaloCalibrationHit*> >& identifierToCaloHitMap, const std::map<unsigned int,const xAOD::TruthParticle*>& truthBarcodeToTruthParticleMap, std::vector<std::pair<unsigned int, double > >& barcodeTrueCalHitEnergy) const{
 
+  ATH_MSG_DEBUG("In calculateTruthEnergies");
+
   const CaloClusterCellLink* theCellLinks = theCaloCluster.getCellLinks();
 
   if (!theCellLinks) {
     ATH_MSG_ERROR("A CaloCluster has no CaloClusterCellLinks");
     return StatusCode::FAILURE;
-  }
-    
+  }  
+
   //loop once over the cells to find the barcodes and pt of truth particles in this cluster
   std::map<unsigned int, double> barcodeTruePtMap;
   
-  for (auto thisCaloCell : *theCellLinks){
+  for (auto thisCaloCell : *theCellLinks){   
 
     if (!thisCaloCell){
       ATH_MSG_WARNING("Have invalid pointer to CaloCell");
@@ -47,6 +49,8 @@ StatusCode CaloCalibClusterTruthAttributerTool::calculateTruthEnergies(const xAO
     
   }//first loop on calorimeter cells to find leading three truth particles with calibration hits
 
+  ATH_MSG_DEBUG("Have finished first cell loop");
+
   std::vector<std::pair<unsigned int, double > > barcodeTruePtPairs;
 
   for (const auto& thisEntry : barcodeTruePtMap) barcodeTruePtPairs.emplace_back(thisEntry);

Calorimeter/CaloRec/python/CaloTowerCmbGetter.py

@@ -2,7 +2,6 @@
 
 # specifies CaloCell-> CaloTower combined 
 from AthenaCommon.Logging import logging
-from AthenaCommon.JobProperties import jobproperties as jp
 from AthenaCommon.SystemOfUnits import MeV
 import traceback
 
@@ -22,8 +21,8 @@ class CaloTowerCmbGetter ( Configured )  :
         # handle tile
 
         # handle LAr
-        theCaloCellGetter = self.getInputGetter\
-                            (jp.CaloRecFlags.clusterCellGetterName())
+        #theCaloCellGetter = self.getInputGetter\
+        #                    (jp.CaloRecFlags.clusterCellGetterName())
                 
 
         # now configure the algorithm, part of this could be done in a separate class
@@ -71,13 +70,13 @@ class CaloTowerCmbGetter ( Configured )  :
         theCaloTowerAlgorithm.EtaMin=-5.0
         theCaloTowerAlgorithm.EtaMax=5.0
 
-        theLArTowerBuilderTool.CellContainerName=theCaloCellGetter.outputKey()
+        theLArTowerBuilderTool.CellContainerName="AllCalo"
         theLArTowerBuilderTool.IncludedCalos = [ "LAREM","LARHEC" ]
 
-        theLArFCalTowerBuilderTool.CellContainerName=theCaloCellGetter.outputKey()        
+        theLArFCalTowerBuilderTool.CellContainerName="AllCalo"
         theLArFCalTowerBuilderTool.MinimumEt = 0 * MeV
         
-        theTileTowerBuilderTool.CellContainerName=theCaloCellGetter.outputKey()        
+        theTileTowerBuilderTool.CellContainerName="AllCalo"
 
 
         # add tool to alg . From now on theCaloClusterBuilderSW will point

Calorimeter/CaloTrackUtils/src/CaloClusterVertexFractionMaker.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 // in contrary to CaloClusterVertexFractionMakerAthAlg this is a CaloClusterCollectionProcessor and not an Athena Algorithm
@@ -88,7 +88,7 @@ StatusCode CaloClusterVertexFractionMaker::initialize()
 }
 
 StatusCode
-CaloClusterVertexFractionMaker::execute(const EventContext& /*ctx*/,
+CaloClusterVertexFractionMaker::execute(const EventContext& ctx,
                                         xAOD::CaloClusterContainer* caloClusterContainer) const
 {
   const VxContainer* primcontainer(nullptr);
@@ -128,20 +128,42 @@ CaloClusterVertexFractionMaker::execute(const EventContext& /*ctx*/,
           else lastTrackParametersInID = trackParametersVector.at(0); // the perigee
 
           // very simplified way for now to decide to extrapolate a track to barrel or endcap
-          if (theTrackParticle->eta() > 1.35) // track most likely in endcap A, extrapolate track to a disc at ID exist in positive z direction
+          if (theTrackParticle->eta() >
+              1.35) // track most likely in endcap A, extrapolate track to a
+                    // disc at ID exist in positive z direction
           {
-            trackParameters_atCaloEntrance = dynamic_cast<const Trk::AtaDisc*>(m_extrapolator->extrapolate(*lastTrackParametersInID, *m_discSurface_atCaloEntrance_positiveZ, Trk::alongMomentum, true, Trk::pion));
-//             std::cout << "CaloClusterVertexFractionMaker " << theTrackParticle->eta() << " extrapolate to endcap A " << trackParameters_atCaloEntrance << std::endl;
-          } else if (theTrackParticle->eta() < -1.35) // track most likely in endcap C, extrapolate track to a disc at ID exist in negative z direction
+            trackParameters_atCaloEntrance =
+              dynamic_cast<const Trk::AtaDisc*>(m_extrapolator->extrapolate(
+                ctx,
+                *lastTrackParametersInID,
+                *m_discSurface_atCaloEntrance_positiveZ,
+                Trk::alongMomentum,
+                true,
+                Trk::pion));
+          } else if (theTrackParticle->eta() <
+                     -1.35) // track most likely in endcap C, extrapolate track
+                            // to a disc at ID exist in negative z direction
           {
-            trackParameters_atCaloEntrance = dynamic_cast<const Trk::AtaDisc*>(m_extrapolator->extrapolate(*lastTrackParametersInID, *m_discSurface_atCaloEntrance_negativeZ, Trk::alongMomentum, true, Trk::pion));
-//             std::cout << "CaloClusterVertexFractionMaker " << theTrackParticle->eta() << " extrapolate to endcap C " << trackParameters_atCaloEntrance << std::endl;
+            trackParameters_atCaloEntrance =
+              dynamic_cast<const Trk::AtaDisc*>(m_extrapolator->extrapolate(
+                ctx,
+                *lastTrackParametersInID,
+                *m_discSurface_atCaloEntrance_negativeZ,
+                Trk::alongMomentum,
+                true,
+                Trk::pion));
           } else // track is in barrel, extrapolate to cylinder at ID exit
           {
-            trackParameters_atCaloEntrance = dynamic_cast<const Trk::AtaCylinder*>(m_extrapolator->extrapolate(*lastTrackParametersInID, *m_cylinderSurface_atCaloEntrance, Trk::alongMomentum, true, Trk::pion));
-//             std::cout << "CaloClusterVertexFractionMaker " << theTrackParticle->eta() << " extrapolate to barrel " << trackParameters_atCaloEntrance << std::endl;
+            trackParameters_atCaloEntrance =
+              dynamic_cast<const Trk::AtaCylinder*>(
+                m_extrapolator->extrapolate(ctx,
+                                            *lastTrackParametersInID,
+                                            *m_cylinderSurface_atCaloEntrance,
+                                            Trk::alongMomentum,
+                                            true,
+                                            Trk::pion));
           }
-          if (trackParameters_atCaloEntrance!=nullptr) {
+          if (trackParameters_atCaloEntrance != nullptr) {
             m_trkParticleEta_atCaloEntrance->push_back(trackParameters_atCaloEntrance->position().eta());
             m_trkParticlePhi_atCaloEntrance->push_back(trackParameters_atCaloEntrance->position().phi());
             ATH_MSG_DEBUG( "At calo entrance R(1150mm) " << *trackParameters_atCaloEntrance  );

Control/AthToolSupport/AsgTools/AsgTools/AnaToolHandle.icc

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef ASGTOOLS_ANATOOLHANDLE_ICC
@@ -198,7 +198,6 @@ namespace asg
     if (!(x)) { std::cerr << __FILE__ << ":" << __LINE__ << ": invariant violated: " << #x << std::endl; std::abort(); }
 
     // General requirements
-    CHECK_INVARIANT (&*this != nullptr);
     CHECK_INVARIANT (m_handleUser != nullptr);
     CHECK_INVARIANT (m_name == m_config.name());
 

Control/AthenaConfiguration/python/AllConfigFlags.py

@@ -67,6 +67,7 @@ def _createCfgFlags():
     acf.addFlag('Concurrency.NumProcs', 0)
     acf.addFlag('Concurrency.NumThreads', 0 )
     acf.addFlag('Concurrency.NumConcurrentEvents', lambda prevFlags : prevFlags.Concurrency.NumThreads)
+    acf.addFlag('Concurrency.DebugWorkers', False )
 
     acf.addFlag('Scheduler.CheckDependencies', True)
     acf.addFlag('Scheduler.ShowDataDeps', True)
@@ -74,6 +75,28 @@ def _createCfgFlags():
     acf.addFlag('Scheduler.ShowControlFlow', True)
     acf.addFlag('Scheduler.EnableVerboseViews', True)
 
+    acf.addFlag('MP.WorkerTopDir', 'athenaMP_workers')
+    acf.addFlag('MP.OutputReportFile', 'AthenaMPOutputs')
+    acf.addFlag('MP.Strategy', 'SharedQueue')
+    acf.addFlag('MP.CollectSubprocessLogs', False)
+    acf.addFlag('MP.PollingInterval', 100)
+    acf.addFlag('MP.EventsBeforeFork', 0)
+    acf.addFlag('MP.EventRangeChannel', 'EventService_EventRanges')
+    acf.addFlag('MP.EvtRangeScattererCaching', False)
+    acf.addFlag('MP.MemSamplingInterval', 0)
+    """ Size of event chunks in the shared queue
+        if chunk_size==-1, chunk size is set to auto_flush for files compressed with LZMA
+        if chunk_size==-2, chunk size is set to auto_flush for files compressed with LZMA or ZLIB
+        if chunk_size==-3, chunk size is set to auto_flush for files compressed with LZMA, ZLIB, or LZ4
+        if chunk_size<=-4, chunk size is set to auto_flush
+    """
+    acf.addFlag('MP.ChunkSize', -1)
+    acf.addFlag('MP.ReadEventOrders', False)
+    acf.addFlag('MP.EventOrdersFile', 'athenamp_eventorders.txt')
+    acf.addFlag('MP.UseSharedReader', False)
+    acf.addFlag('MP.UseSharedWriter', False)
+    acf.addFlag('MP.UseParallelCompression', True)
+
     acf.addFlag('Common.MsgSourceLength',50) #Length of the source-field in the format str of MessageSvc
     acf.addFlag('Common.isOnline', False ) #  Job runs in an online environment (access only to resources available at P1) # former global.isOnline
     acf.addFlag('Common.useOnlineLumi', lambda prevFlags : prevFlags.Common.isOnline ) #  Use online version of luminosity. ??? Should just use isOnline?
@@ -170,6 +193,9 @@ def _createCfgFlags():
     acf.addFlag("IOVDb.RunToTimestampDict", lambda prevFlags: getRunToTimestampDict())
     acf.addFlag("IOVDb.DBConnection", lambda prevFlags : "sqlite://;schema=mycool.db;dbname=" + prevFlags.IOVDb.DatabaseInstance)
 
+#PoolSvc Flags:
+    acf.addFlag("PoolSvc.MaxFilesOpen", lambda prevFlags : 2 if prevFlags.MP.UseSharedReader else 0)
+
 
     def __bfield():
         from MagFieldConfig.BFieldConfigFlags import createBFieldConfigFlags

Control/AthenaConfiguration/python/AthConfigFlags.py

@@ -404,6 +404,7 @@ class AthConfigFlags(object):
         parser.add_argument("-l", "--loglevel", default=None, help="logging level (ALL, VERBOSE, DEBUG,INFO, WARNING, ERROR, or FATAL")
         parser.add_argument("--configOnly", type=str, default=None, help="Stop after configuration phase (may not be respected by all diver scripts)")
         parser.add_argument("--threads", type=int, default=0, help="Run with given number of threads")
+        parser.add_argument("--nprocs", type=int, default=0, help="Run AthenaMP with given number of worker processes")
 
         return parser
 
@@ -447,6 +448,9 @@ class AthConfigFlags(object):
         if args.threads:
             self.Concurrency.NumThreads = args.threads
 
+        if args.nprocs:
+            self.Concurrency.NumProcs = args.nprocs
+
         #All remaining arguments are assumed to be key=value pairs to set arbitrary flags:
 
 

Control/AthenaConfiguration/python/MainServicesConfig.py

@@ -29,6 +29,9 @@ def MainServicesCfg(cfgFlags, LoopMgr='AthenaEventLoopMgr'):
             raise Exception("Requested Concurrency.NumThreads>0 and Concurrency.NumConcurrentEvents==0, which will not process events!")
         LoopMgr = "AthenaHiveEventLoopMgr"
 
+    if cfgFlags.Concurrency.NumProcs>0:
+        LoopMgr = "AthMpEvtLoopMgr"
+
     ########################################################################
     # Core components needed for serial and threaded jobs
     cfg=MainServicesMiniCfg(loopMgr=LoopMgr, masterSequence='AthMasterSeq')
@@ -93,6 +96,10 @@ def MainServicesCfg(cfgFlags, LoopMgr='AthenaEventLoopMgr'):
     if cfgFlags.Exec.DebugStage != "":
         cfg.setDebugStage(cfgFlags.Exec.DebugStage)
 
+    if cfgFlags.Concurrency.NumProcs>0:
+        from AthenaMP.AthenaMPConfig import AthenaMPCfg
+        mploop = AthenaMPCfg(cfgFlags)
+        cfg.merge(mploop)
 
     ########################################################################
     # Additional components needed for threaded jobs only

Control/AthenaConfiguration/python/OldFlags2NewFlags.py

@@ -77,7 +77,7 @@ def getNewConfigFlags():
 
     # miscellaneous settings
     from InDetRecExample.InDetJobProperties import InDetFlags
-    ConfigFlags.InDet.doTIDE_Ambi = InDetFlags.doTIDE_Ambi()
+    ConfigFlags.InDet.Tracking.doTIDE_Ambi = InDetFlags.doTIDE_Ambi()
     ConfigFlags.InDet.useDCS = InDetFlags.useDCS()
 
     from LArConditionsCommon.LArCondFlags import larCondFlags 

Control/AthenaMP/python/AthenaMPConfig.py

+# Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+
+from AthenaConfiguration.ComponentFactory import CompFactory
+from AthenaConfiguration.ComponentAccumulator import ComponentAccumulator
+from AthenaConfiguration.MainServicesConfig import MainServicesCfg
+from AthenaConfiguration.AllConfigFlags import ConfigFlags, GetFileMD
+from AthenaConfiguration.Enums import ProductionStep
+
+from AthenaCommon.Logging import log as msg
+
+import os, shutil
+
+def AthenaMPCfg(configFlags):
+
+    os.putenv('XRD_ENABLEFORKHANDLERS','1')
+    os.putenv('XRD_RUNFORKHANDLER','1')
+
+    result=ComponentAccumulator()
+
+    # Configure MP Event Loop Manager
+    AthMpEvtLoopMgr=CompFactory.AthMpEvtLoopMgr
+    mpevtloop = AthMpEvtLoopMgr()
+
+    mpevtloop.NWorkers=configFlags.Concurrency.NumProcs
+    mpevtloop.Strategy=configFlags.MP.Strategy
+    mpevtloop.WorkerTopDir = configFlags.MP.WorkerTopDir
+    mpevtloop.OutputReportFile = configFlags.MP.OutputReportFile
+    mpevtloop.CollectSubprocessLogs = configFlags.MP.CollectSubprocessLogs
+    mpevtloop.PollingInterval = configFlags.MP.PollingInterval
+    mpevtloop.MemSamplingInterval = configFlags.MP.MemSamplingInterval
+    mpevtloop.IsPileup = True if configFlags.Common.ProductionStep in [ProductionStep.PileUpPresampling, ProductionStep.Overlay] else False
+    mpevtloop.EventsBeforeFork = 0 if configFlags.MP.Strategy == 'EventService' else configFlags.MP.EventsBeforeFork
+
+    # Configure Gaudi File Manager
+    filemgr = CompFactory.FileMgr(LogFile="FileManagerLog")
+    result.addService(filemgr)
+
+    # Save PoolFileCatalog.xml if exists in the run directory
+    # The saved file will be copied over to workers' run directories just after forking
+    if os.path.isfile('PoolFileCatalog.xml'):
+        shutil.copyfile('PoolFileCatalog.xml','PoolFileCatalog.xml.AthenaMP-saved')
+
+    # Compute event chunk size
+    chunk_size = getChunkSize(configFlags)
+
+    # Configure Strategy
+    debug_worker = configFlags.Concurrency.DebugWorkers
+    event_range_channel = configFlags.MP.EventRangeChannel
+    use_shared_reader = configFlags.MP.UseSharedReader
+    use_shared_writer = configFlags.MP.UseSharedWriter
+    use_parallel_compression = configFlags.MP.UseParallelCompression
+
+    if configFlags.MP.Strategy=='SharedQueue' or configFlags.MP.Strategy=='RoundRobin':
+        if use_shared_reader:
+            AthenaSharedMemoryTool = CompFactory.AthenaSharedMemoryTool
+
+            if configFlags.Input.Format == 'BS':
+                evSel=CompFactory.EventSelectorByteStream("EventSelector")
+
+                from ByteStreamCnvSvc.ByteStreamConfig import ByteStreamReadCfg
+                bscfg = ByteStreamReadCfg(configFlags)
+                result.merge(bscfg)
+            else:
+                evSel=CompFactory.EventSelectorAthenaPool("EventSelector")
+
+                # AthenaPoolCnvSvc
+                apcs=CompFactory.AthenaPoolCnvSvc()
+                apcs.InputStreamingTool = AthenaSharedMemoryTool("InputStreamingTool",
+                                                                 SharedMemoryName="InputStream"+str(os.getpid()),
+                                                                 UseMultipleSegments=True)
+                result.addService(apcs)
+
+                from AthenaPoolCnvSvc.PoolReadConfig import PoolReadCfg
+                poolcfg = PoolReadCfg(configFlags)
+
+                result.merge(poolcfg)
+
+            evSel.SharedMemoryTool = AthenaSharedMemoryTool("EventStreamingTool",
+                                                            SharedMemoryName="EventStream"+str(os.getpid()))
+            result.addService(evSel)
+
+        if use_shared_writer:
+            if any((configFlags.Output.doWriteESD,
+                    configFlags.Output.doWriteAOD,
+                    configFlags.Output.doWriteRDO)) or configFlags.Output.HITSFileName!='':
+                AthenaSharedMemoryTool = CompFactory.AthenaSharedMemoryTool
+
+                apcs=CompFactory.AthenaPoolCnvSvc()
+                apcs.OutputStreamingTool += [ AthenaSharedMemoryTool("OutputStreamingTool_0",
+                                                                     SharedMemoryName="OutputStream"+str(os.getpid())) ]
+                apcs.ParallelCompression = use_parallel_compression
+                result.addService(apcs)
+
+                from AthenaPoolCnvSvc.PoolWriteConfig import PoolWriteCfg
+                poolcfg = PoolWriteCfg(configFlags)
+
+                result.merge(poolcfg)
+
+        queue_provider = CompFactory.SharedEvtQueueProvider(UseSharedReader=use_shared_reader,
+                                                            IsPileup=mpevtloop.IsPileup,
+                                                            EventsBeforeFork=mpevtloop.EventsBeforeFork,
+                                                            ChunkSize=chunk_size)
+        if configFlags.Concurrency.NumThreads > 0:
+            if mpevtloop.IsPileup:
+                raise Exception('Running pileup digitization in mixed MP+MT currently not supported')
+            queue_consumer = CompFactory.SharedEvtQueueConsumer(UseSharedWriter=use_shared_writer,
+                                                                EventsBeforeFork=mpevtloop.EventsBeforeFork,
+                                                                Debug=debug_worker)
+        else:
+            queue_consumer = CompFactory.SharedEvtQueueConsumer(UseSharedReader=use_shared_reader,
+                                                                UseSharedWriter=use_shared_writer,
+                                                                IsPileup=mpevtloop.IsPileup,
+                                                                IsRoundRobin=(configFlags.MP.Strategy=='RoundRobin'),
+                                                                EventsBeforeFork=mpevtloop.EventsBeforeFork,
+                                                                ReadEventOrders=configFlags.MP.ReadEventOrders,
+                                                                EventOrdersFile=configFlags.MP.EventOrdersFile,
+                                                                Debug=debug_worker)
+        mpevtloop.Tools += [ queue_provider, queue_consumer ]
+
+        if use_shared_writer:
+            shared_writer = CompFactory.SharedWriterTool(MotherProcess=(mpevtloop.EventsBeforeFork>0))
+            mpevtloop.Tools += [ shared_writer ]
+
+    elif configFlags.MP.Strategy=='FileScheduling':
+        mpevtloop.Tools += [ CompFactory.FileSchedulingTool(IsPileup=mpevtloop.IsPileup,
+                                                            Debug=debug_worker) ]
+
+    elif configFlags.MP.Strategy=='EventService':
+        channelScatterer2Processor = "AthenaMP_Scatterer2Processor"
+        channelProcessor2EvtSel = "AthenaMP_Processor2EvtSel"
+
+        mpevtloop.Tools += [ CompFactory.EvtRangeScatterer(ProcessorChannel = channelScatterer2Processor,
+                                                           EventRangeChannel = event_range_channel,
+                                                           DoCaching=configFlags.MP.EvtRangeScattererCaching) ]
+        mpevtloop.Tools += [ CompFactory.vtRangeProcessor(IsPileup=mpevtloop.IsPileup,
+                                                          Channel2Scatterer = channelScatterer2Processor,
+                                                          Channel2EvtSel = channelProcessor2EvtSel,
+                                                          Debug=debug_worker) ]
+
+    else:
+        msg.warning("Unknown strategy %s. No MP tools will be configured", configFlags.MP.Strategy)
+
+    result.addService(mpevtloop, primary=True)
+
+    return result
+
+def getChunkSize(configFlags) -> int:
+    chunk_size = 1
+    if configFlags.MP.ChunkSize > 0:
+        chunk_size = configFlags.MP.ChunkSize
+        msg.info('Chunk size set to %i', chunk_size)
+    elif configFlags.Input.Files != ["_ATHENA_GENERIC_INPUTFILE_NAME_"]:
+        md = GetFileMD(configFlags.Input.Files)
+        #Don't use auto flush for shared reader
+        if configFlags.MP.UseSharedReader:
+            msg.info('Shared Reader in use, chunk_size set to default (%i)', chunk_size)
+        #Use auto flush only if file is compressed with LZMA, else use default chunk_size
+        elif configFlags.MP.ChunkSize == -1:
+            if md.get('file_comp_alg',-1) == 2:
+                chunk_size = md.get('auto_flush',-1)
+                msg.info('Chunk size set to auto flush (%i)', chunk_size)
+            else:
+                msg.info('LZMA algorithm not in use, chunk_size set to default (%i)', chunk_size)
+        #Use auto flush only if file is compressed with LZMA or ZLIB, else use default chunk_size
+        elif configFlags.MP.ChunkSize == -2:
+            if md.get('file_comp_alg',-1) in [1,2]:
+                chunk_size = md.get('auto_flush',-1)
+                msg.info('Chunk size set to auto flush (%i)', chunk_size)
+            else:
+                msg.info('LZMA nor ZLIB in use, chunk_size set to default (%i)', chunk_size)
+                #Use auto flush only if file is compressed with LZMA, ZLIB or LZ4, else use default chunk_size
+        elif configFlags.MP.ChunkSize == -3:
+            if md.get('file_comp_alg',-1) in [1,2,4]:
+                chunk_size = md.get('auto_flush',-1)
+                msg.info('Chunk size set to auto flush (%i)', chunk_size)
+            else:
+                msg.info('LZMA, ZLIB nor LZ4 in use, chunk_size set to (%i)', chunk_size)
+        #Use auto flush value for chunk_size, regarldess of compression algorithm
+        elif configFlags.MPChunkSize <= -4:
+            chunk_size = md.get('auto_flush',-1)
+            msg.info('Chunk size set to auto flush (%i)', chunk_size)
+        else:
+            msg.warning('Invalid ChunkSize, Chunk Size set to default (%i)', chunk_size)
+
+    return chunk_size
+
+
+if __name__=="__main__":
+
+    # -----------------  Hello World Example ------------------
+    # ConfigFlags.Exec.MaxEvents=10
+    # ConfigFlags.Concurrency.NumProcs=2
+
+    # cfg=MainServicesCfg(ConfigFlags)
+
+    # from AthExHelloWorld.HelloWorldConfig import HelloWorldCfg
+    # cfg.merge(HelloWorldCfg())
+
+    # cfg.run()
+    # -----------------  Hello World Example ------------------
+
+    # -----------------  Example with input file --------------
+    from AthenaConfiguration.TestDefaults import defaultTestFiles
+    ConfigFlags.Input.Files = defaultTestFiles.ESD
+    ConfigFlags.Exec.MaxEvents=10
+    ConfigFlags.Concurrency.NumProcs=2
+
+    from AthenaCommon.Configurable import Configurable
+    Configurable.configurableRun3Behavior=1
+
+    cfg=MainServicesCfg(ConfigFlags)
+    from AthenaPoolCnvSvc.PoolReadConfig import EventSelectorAthenaPoolCfg
+    cfg.merge(EventSelectorAthenaPoolCfg(ConfigFlags))
+    cfg.run()
+    # -----------------  Example with input file --------------
+
+    msg.info('All OK!')

Control/PileUpTools/CMakeLists.txt

@@ -12,7 +12,7 @@ atlas_add_library( PileUpToolsLib
                    LINK_LIBRARIES AthenaBaseComps AthenaKernel
                    AthLinks SGTools
                    EventInfo xAODEventInfo xAODCnvInterfaces
-                   GaudiKernel StoreGateLib )
+                   GaudiKernel StoreGateLib CxxUtils )
 
 atlas_add_component( PileUpTools
                      src/components/*.cxx

Control/PileUpTools/PileUpTools/ATLAS_CHECK_THREAD_SAFETY

+Control/PileUpTools

Control/PileUpTools/PileUpTools/PileUpMergeSvc.h

 /* -*- C++ -*- */
 
 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 /** @file PileUpMergeSvc.h
@@ -29,6 +29,7 @@
 #include "AthenaKernel/SlotSpecificObj.h"
 
 #include "PileUpTools/IPileUpXingFolder.h"
+#include "CxxUtils/checker_macros.h"
 
 #include <cassert>
 
@@ -127,7 +128,7 @@ private:
 
   // Protect against multiple threads trying to make EventInfo
   // for the same slot.
-  mutable SG::SlotSpecificObj<std::mutex> m_slotMutex;
+  mutable SG::SlotSpecificObj<std::mutex> m_slotMutex ATLAS_THREAD_SAFE;
 
   template <typename DATA, typename KEY>
   bool isLive(const KEY& key, int iXing);   ///< is iXing live for DATA/key?

Control/PileUpTools/PileUpTools/PileUpMergeSvc.icc

 /* -*- C++ -*- */
 
 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #include <algorithm>  /* make_pair */
@@ -169,7 +169,7 @@ PileUpMergeSvc::retrieveSubSetEvtData(const KEY& dataKey, //orig evt key
   typedef typename value_type::second_type DataLink_t;
 
   SubEventIterator iEvt = bSubEvents;
-  for (; iEvt != eSubEvents; iEvt++) {
+  for (; iEvt != eSubEvents; ++iEvt) {
 
     StoreGateSvc &seStore = *iEvt->ptr()->evtStore();
     ATH_MSG_VERBOSE("SubEvt StoreGate " << seStore.name() << " :"

Control/PileUpTools/PileUpTools/PileUpStream.h

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef PILEUPSTREAM_PILEUPSTREAM_H
@@ -14,7 +14,7 @@
 
 // Framework include files
 #include "GaudiKernel/IEvtSelector.h"
-#include "AthenaKernel/MsgStreamMember.h"
+#include "AthenaBaseComps/AthMessaging.h"
 
 #include "xAODEventInfo/EventInfo.h"
 
@@ -28,15 +28,19 @@ class PileUpMergeSvc;
 /** @class PileUpStream
  * @brief a triple selector/context/store defines a stream
  */
-class PileUpStream {
+class PileUpStream
+  : public AthMessaging
+{
 public:
   typedef IEvtSelector::Context EvtIterator;
 
   /// @name Structors
   //@{
   PileUpStream();
-  PileUpStream(const PileUpStream& rhs);
-  PileUpStream& operator=(const PileUpStream& rhs);
+  PileUpStream(const PileUpStream& rhs) = delete;
+  PileUpStream& operator=(const PileUpStream& rhs) = delete;
+  PileUpStream(PileUpStream&& rhs);
+  PileUpStream& operator=(PileUpStream&& rhs);
   PileUpStream(const std::string& name, 
 	       IEvtSelector* sel, 
 	       StoreGateSvc* store);
@@ -88,11 +92,7 @@ public:
     }
   }
 
-  /// Log a message using the Athena controlled logging system
-  MsgStream& msg( MSG::Level lvl ) const { return m_msg << lvl; }
-  /// Check whether the logging system is active at the provided verbosity level
-  bool msgLvl( MSG::Level lvl ) { return m_msg.get().level() <= lvl; }
-  
+
 private:
   ISvcLocator* serviceLocator() { return p_svcLoc; }
 
@@ -126,12 +126,10 @@ private:
   
   ActiveStoreSvc* p_activeStore;
 
-  //mutable so that ownership can be passed upon copy
-  mutable bool m_ownEvtIterator; ///> do we own p_iter? 
+  bool m_ownEvtIterator; ///> do we own p_iter? 
   /// Private message stream member
-  mutable Athena::MsgStreamMember m_msg;
   bool m_neverLoaded;  ///> has an event been loaded into this stream?
-  mutable bool m_ownStore;  ///> is p_SG a store we cloned from the master one?
+  bool m_ownStore;  ///> is p_SG a store we cloned from the master one?
 
   bool m_used; ///has this stream already been used? (for the current event)
   bool m_hasRing;

Control/PileUpTools/PileUpTools/PileUpToolBase.h

 /* -*- C++ -*- */
 
 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #ifndef PILEUPTOOLS_PILEUPTOOLBASE_H
@@ -21,8 +21,8 @@ class PileUpToolBase :  public extends<AthAlgTool, IPileUpTool> {
 public:
   /// \name structors and AlgTool implementation
   //@{
-  PileUpToolBase(const std::string& name,
-                 const std::string& type,
+  PileUpToolBase(const std::string& type,
+                 const std::string& name,
                  const IInterface* parent);
 
   virtual StatusCode initialize() override {

Control/PileUpTools/src/PileUpMergeSvc.cxx

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "PileUpTools/PileUpMergeSvc.h"
@@ -137,15 +137,8 @@ const xAOD::EventInfo* PileUpMergeSvc::getPileUpEvent( StoreGateSvc* sg, const s
    if( xAODEventInfo ) {
       ATH_MSG_DEBUG("Found xAOD::EventInfo");
       ATH_MSG_DEBUG(" EventInfo has " <<   xAODEventInfo->subEvents().size() << " subevents" );
-      if( xAODEventInfo->evtStore() == nullptr ) {
-         // SG is 0 only when the xAODEventInfo is first read
-         const_cast<xAOD::EventInfo*>(xAODEventInfo)->setEvtStore( sg );
-         // the loop below serves 2 purposes: to recreate subevent links cache
-         // and set SG pointer in subevents 
-         for( auto& subev : xAODEventInfo->subEvents() ) {
-            const_cast<xAOD::EventInfo*>( subev.ptr() )->setEvtStore( sg );
-         }
-      }
+      // recreate subevent links cache
+      xAODEventInfo->subEvents();
    } else {
       // Don't allow more than one thread per slot through here.
       // Otherwise, we can get errors with multiple threads trying
@@ -179,21 +172,20 @@ const xAOD::EventInfo* PileUpMergeSvc::getPileUpEvent( StoreGateSvc* sg, const s
             std::vector< xAOD::EventInfo::SubEvent > subEvents;
 
             // A map translating between the AOD and xAOD pileup event types:
-            static std::map< PileUpEventInfo::SubEvent::pileup_type,
-               xAOD::EventInfo::PileUpType > pileupTypeMap;
-            if( ! pileupTypeMap.size() ) {
+            static const std::map< PileUpEventInfo::SubEvent::pileup_type,
+               xAOD::EventInfo::PileUpType > pileupTypeMap = {
 #define DECLARE_SE_TYPE( TYPE )                                         \
-               pileupTypeMap[ PileUpTimeEventIndex::TYPE ] = xAOD::EventInfo::TYPE
+              { PileUpTimeEventIndex::TYPE, xAOD::EventInfo::TYPE },
 
-               DECLARE_SE_TYPE( Unknown );
-               DECLARE_SE_TYPE( Signal );
-               DECLARE_SE_TYPE( MinimumBias );
-               DECLARE_SE_TYPE( Cavern );
-               DECLARE_SE_TYPE( HaloGas );
-               DECLARE_SE_TYPE( ZeroBias );
+               DECLARE_SE_TYPE( Unknown )
+               DECLARE_SE_TYPE( Signal )
+               DECLARE_SE_TYPE( MinimumBias )
+               DECLARE_SE_TYPE( Cavern )
+               DECLARE_SE_TYPE( HaloGas )
+               DECLARE_SE_TYPE( ZeroBias )
 
 #undef DECLARE_SE_TYPE
-            }
+            };
 
             // A convenience type declaration:
             typedef ElementLink< xAOD::EventInfoContainer > EiLink;

Control/PileUpTools/src/PileUpStream.cxx

 /*
-  Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 #include "PileUpTools/PileUpStream.h"
@@ -13,7 +13,7 @@
 #include "GaudiKernel/ISvcManager.h"
 #include "AthenaKernel/CloneService.h"
 #include "AthenaKernel/IAddressProvider.h"
-#include "AthenaKernel/IProxyProviderSvc.h"
+#include "AthenaKernel/getMessageSvc.h"
 #include "StoreGate/StoreGateSvc.h"
 
 #include "SGTools/DataProxy.h"
@@ -28,17 +28,19 @@ class IOpaqueAddress;
 
 /// Structors
 PileUpStream::PileUpStream():
+  AthMessaging (Athena::getMessageSvc(), "PileUpStream"),
   m_name("INVALID"), p_svcLoc(0), p_sel(0), p_SG(0), p_iter(0), 
   p_mergeSvc(nullptr), p_activeStore(0), m_ownEvtIterator(false),
-  m_msg("PileUpStream"), m_neverLoaded(true), m_ownStore(false),
+  m_neverLoaded(true), m_ownStore(false),
   m_used(false), m_hasRing(false), m_iOriginalRing(0)
 { 
 }
 
-PileUpStream::PileUpStream(const PileUpStream& rhs):
+PileUpStream::PileUpStream(PileUpStream&& rhs):
+  AthMessaging (Athena::getMessageSvc(), rhs.m_name),
   m_name(rhs.m_name), p_svcLoc(rhs.p_svcLoc), p_sel(rhs.p_sel), 
   p_SG(rhs.p_SG), p_iter(rhs.p_iter), p_mergeSvc(rhs.p_mergeSvc), p_activeStore(rhs.p_activeStore),
-  m_ownEvtIterator(rhs.m_ownEvtIterator), m_msg(rhs.m_msg),
+  m_ownEvtIterator(rhs.m_ownEvtIterator),
   m_neverLoaded(rhs.m_neverLoaded), m_ownStore(rhs.m_ownStore),
   m_used(rhs.m_used), m_hasRing(rhs.m_hasRing), m_iOriginalRing(rhs.m_iOriginalRing)
 { 
@@ -48,7 +50,7 @@ PileUpStream::PileUpStream(const PileUpStream& rhs):
 }
 
 PileUpStream&
-PileUpStream::operator=(const PileUpStream& rhs) {
+PileUpStream::operator=(PileUpStream&& rhs) {
   if (this != &rhs) {
     m_name=rhs.m_name;
     p_svcLoc=rhs.p_svcLoc;
@@ -59,7 +61,6 @@ PileUpStream::operator=(const PileUpStream& rhs) {
     p_activeStore=rhs.p_activeStore;
     m_ownEvtIterator=rhs.m_ownEvtIterator;
     rhs.m_ownEvtIterator=false;
-    m_msg=rhs.m_msg;
     m_neverLoaded=rhs.m_neverLoaded;
     m_ownStore=rhs.m_ownStore;
     rhs.m_ownStore=false;
@@ -73,8 +74,9 @@ PileUpStream::operator=(const PileUpStream& rhs) {
 PileUpStream::PileUpStream(const std::string& name, 
 			   ISvcLocator* svcLoc,
 			   IEvtSelector* sel):
+  AthMessaging (Athena::getMessageSvc(), name),
   m_name(name), p_svcLoc(svcLoc), p_sel(sel), p_SG(0), p_iter(0), 
-  m_ownEvtIterator(false), m_msg("PileUpStream"),
+  m_ownEvtIterator(false), 
   m_neverLoaded(true), m_ownStore(false),
   m_used(false), m_hasRing(false), m_iOriginalRing(0)
 { 
@@ -93,8 +95,9 @@ PileUpStream::PileUpStream(const std::string& name,
 PileUpStream::PileUpStream(const std::string& name, 
 			   ISvcLocator* svcLoc,
 			   const std::string& selecName):
+  AthMessaging (Athena::getMessageSvc(), name),
   m_name(name), p_svcLoc(svcLoc), p_sel(0), p_SG(0), p_iter(0),
-  m_ownEvtIterator(false), m_msg("PileUpStream"), 
+  m_ownEvtIterator(false), 
   m_neverLoaded(true), m_ownStore(false),
   m_used(false), m_hasRing(false), m_iOriginalRing(0)
 

Control/SGComps/src/ProxyProviderSvc.cxx

 /*
-  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
 */
 
 #include <algorithm>
@@ -295,15 +295,23 @@ const EventContext& ProxyProviderSvc::contextFromStore (IProxyRegistry& ds) cons
 void 
 ProxyProviderSvc::providerNamesPropertyHandler( Gaudi::Details::PropertyBase& /*theProp*/ ) {
   //add declared providers to the list;
-  std::vector<std::string>::const_iterator iN(m_providerNames.value().begin());
-  std::vector<std::string>::const_iterator iEnd(m_providerNames.value().end());
-  while (iN != iEnd) {
+  std::vector<std::string> providerNames = m_providerNames.value();
+
+  // FIXME: AddressRemappingSvc needs to come at the end, if it's provided.
+  auto it = std::find (providerNames.begin(), providerNames.end(),
+                       "AddressRemappingSvc");
+  if (it != providerNames.end() &&  it != providerNames.end()-1) {
+    providerNames.erase (it);
+    providerNames.push_back ("AddressRemappingSvc");
+  }
+
+  for (const std::string& pName : providerNames) {
     IService *pIS(0);
     IAddressProvider *pAP(0);
-    ListItem tn(*iN);
+    ListItem tn(pName);
     if (!(service(tn.type(), tn.name(), pIS)).isSuccess() ||
 	0 == (pAP = dynamic_cast<IAddressProvider*>(pIS))) {
-      ATH_MSG_ERROR(" getting Address Provider "<< *iN);
+      ATH_MSG_ERROR(" getting Address Provider "<< pName);
       throw GaudiException("Failed to locate address provider",
 			   "ProxyProviderSvc::providerNamesPropertyHandle", 
 			   StatusCode::FAILURE);
@@ -312,7 +320,6 @@ ProxyProviderSvc::providerNamesPropertyHandler( Gaudi::Details::PropertyBase& /*
       ATH_MSG_DEBUG(" added Address Provider "<< pIS->name());
     }
     addProvider(pAP);
-    ++iN;
   }
 
 }

DataQuality/DataQualityInterfaces/src/HanConfig.cxx

 /*
-  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
+  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
 */
 
 // **********************************************************************
@@ -1304,7 +1304,7 @@ ChangeOutputDir( TFile* file, const std::string& path, DirMap_t& directories )
       std::string dirName;
       std::string::size_type k = subPath.find_last_of('/');
       dirName = (k != std::string::npos) ? std::string( subPath, k+1, std::string::npos ) : subPath;
-      TDirectory* dir;
+      TDirectory* dir = nullptr;
       if (!parDir->FindKey(dirName.c_str())) {
 	dir = parDir->mkdir( dirName.c_str() );
       }