Olga Igonkina authored 6 years ago and Atlas Nightlybuild committed 6 years ago

Adding L1Topo simulated overflow bits to HLTResults

See merge request atlas/athena!14660

(cherry picked from commit db41d69970f65ab622852108337e9bda1ad1b1fe)

0c9895ff Adding sim overflow bits to HLTResults

The MT in the name does not mean that it is thread-safe, but that it is meant
to be used in the new HLT framework with athenaMT. The result building will
be still a single-threaded operation even in the new framework.

first batch of changes towards online output handling served
by external services following offline-like workflow

making use of Gaudi macros to simplify the implementation - queryInterface is handled by the base wrapper class

The getNext method is always called from a single-threaded event loop manager.
Reading in new events is always sequential, even though there may be many events
being processed at the same time.

Now it works like this:
1. Event loop mgr creates an `EventContext` and records it in the event store.
2. Event loop mgr calls `IEvtSelector::createAddress`
3. `TrigEventSelectorByteStream::createAddress` creates a `ByteStreamAddress` for `EventInfo`, which is in line with its name and with the workflow described in the [documentation](/Event/ByteStreamCnvSvc/doc/ByteStream.txt). It also attaches an `EventContext` obtained from the event store to the `ByteStreamAddress`.
4. Event loop mgr calls `IEvtSelector::next` which calls `ByteStreamInputSvc::nextEvent`.
5. `TrigByteStreamInputSvc::nextEvent` gets a new event from `DataCollector::getNext` and passes it on to `ROBDataProviderSvc` using an `EventContext` obtained from the event store.
6. Event loop mgr asks the event store to `loadEventProxies` and then to retrieve an `EventInfo` object. This triggers an automatic conversion from BS (`RawEvent`) to `EventInfo`.

This is mostly to prevent MsgSvc from printing event/slot numbers for
messages printed from a scope which doesn't process any event. e.g.
after pushing an event to the scheduler and before popping a finished event

Take the stream tags from `xAOD::EventInfo` and translate them
into `eformat::helper::StreamTag`. Also move the FullEventFragment
serialisation into the `fullHltResult` method, such that the stream
tag data can be deleted from memory after making a serialised copy
of the FullEventFragment.

after using DeclareInterface macro, the queryInterface override is no longer needed,
extends<> now takes care of queryInterface properly

 - `m_timeoutThread->join()` should not be called under a locked timeout mutex,
otherwise it blocks forever
 - in principle `m_timeoutCond.notify_all()` should be also outside of the locked block
 - `AthService::stop()` should be the last call in `stop()`

- remove msg stream from method parameter
- use ATH_MSG_INFO for all printouts
- use std string stream for detector mask formatting

Previously the time was checked for each slot even if the slot
was not processing any event. Now a vector of bool flags tells
the timeout thread if the timeout should be checked for a given slot.

- use the conversion tool to get xAOD::EventInfo from the old EventInfo
and use the xAOD one throughout the EventLoopMgr
- perhaps the L1 trigger bits still need to be retrieved somehow for the final
result building
- retrieve the HltResult from event store after processing (not really used yet)
- also change the message format for clarity with nthreads>1

Reimplemented the only thing we need from MinimalEventLoopMgr,
i.e. the top-level algorithms initialisation. Made the HltEventLoopMgr
inherit from AthService and moved all messaging to ATH_MSG macros.

Th code didn't compile after previous commit due to merge hiccups.
THistSvcHLT and TrigMonTistSvc are now identical to athena/master.

first attempt to move the services to a new package

Added a possibility to specify a pickle file as job options and read
the full configuration from there instead of reading the python configuration.
It "works" as in it loads the configuration from the pickle file, however
it's not really tested because at this point we don't have any online job
configuration available in a pickle file.

- remove trailing whitespaces
- remove obsolete "optional" service pointers in loop mgr
- move protected members to private and reorder
- move event selector and input svc from Service to AthService,
  use the ATH_MSG macro in the implementation of these
- fix minor compilation warnings
- didn't touch THistSvcHLT which still derives from Service directly

recordAddress for EventInfo proxy fails because it is already recorded
by the input svc. It seems everything works without recordAddress in
the event loop mgr.

CoreDumpSvc gets the number of slots from
Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents
This is not yet set when the service is started, because we initialise
the scheduler only after fork. Therefore, we need to stop and start
CoreDumpSvc after initialising the scheduler, to pick up the number
of slots correctly.

The InputSvc creates a ByteStreamAddress for EventInfo and records it in StoreGate.
Retrieval of EventInfo from the loop manager triggers a call to EventInfoByteStreamCnv
automatically producing the EventInfo object.

Also added extra helper methods in the loop manager for creating and sending
the HLT result.

- defined new exception hltonl::Exception::NoMoreEvents in TrigKernel
- TrigByteStreamInputSvc throws it
- TrigEventSelectorByteStream rethrows
- HltEevntLoopMgr it handles nicely, finishing the event loop

uncommented the getNext call in nextEvent() and added eventDone in drainScheduler()

updated the HLT code to be in line with commit 2ac03440
includes all changes in master up to 28/05/2018 noon

brings the online code and configuration very close to offline,
made sure running bare athena including just TrigServicesEventLoopMgr.py
gives a working job with same services and options as a HLTMPPU job

C++ code in the event loop is highly inspired by and partially simply
copied from AthenaHiveEventLoopMgr

important: initialise the scheduler in hltUpdateAfterFork!
otherwise the scheduler thread gets lost in forking