TrigT1CaloByteStream: Thread-safety hacks for L1CaloErrorByteStreamTool.

L1CaloErrorByteStreamTool is a public tool that is accumulating
information about unpacking errors.  Hack it so that the information
is made slot-specific and locked.  This should get things going,
but the design on this should be reconsidered.

Trigger/TrigT1/TrigT1CaloByteStream/src/L1CaloErrorByteStreamTool.cxx

@@ -60,10 +60,12 @@ StatusCode L1CaloErrorByteStreamTool::finalize()
 // Set ROB status error
 
 void L1CaloErrorByteStreamTool::robError(const uint32_t robid,
-                                         const unsigned int err)
+                                         const unsigned int err) const
 {
-  if (err && m_robMap.find(robid) == m_robMap.end()) {
-    m_robMap.insert(std::make_pair(robid, err));
+  ErrorMaps& maps = *m_maps;
+  std::scoped_lock lock (maps.m_mutex);
+  if (err && maps.m_robMap.find(robid) == maps.m_robMap.end()) {
+    maps.m_robMap.insert(std::make_pair(robid, err));
   }
   return;
 }
@@ -71,10 +73,12 @@ void L1CaloErrorByteStreamTool::robError(const uint32_t robid,
 // Set ROD unpacking error
 
 void L1CaloErrorByteStreamTool::rodError(const uint32_t robid,
-                                         const unsigned int err)
+                                         const unsigned int err) const
 {
-  if (err && m_rodMap.find(robid) == m_rodMap.end()) {
-    m_rodMap.insert(std::make_pair(robid, err));
+  ErrorMaps& maps = *m_maps;
+  std::scoped_lock lock (maps.m_mutex);
+  if (err && maps.m_rodMap.find(robid) == maps.m_rodMap.end()) {
+    maps.m_rodMap.insert(std::make_pair(robid, err));
   }
   return;
 }
@@ -84,22 +88,24 @@ void L1CaloErrorByteStreamTool::rodError(const uint32_t robid,
 StatusCode L1CaloErrorByteStreamTool::errors(std::vector<unsigned int>*
                                                                  const errColl)
 {
-  if (!m_robMap.empty() || !m_rodMap.empty()) {
-    errColl->push_back(m_robMap.size());
-    ErrorMap::const_iterator iter  = m_robMap.begin();
-    ErrorMap::const_iterator iterE = m_robMap.end();
+  ErrorMaps& maps = *m_maps;
+  std::scoped_lock lock (maps.m_mutex);
+  if (!maps.m_robMap.empty() || !maps.m_rodMap.empty()) {
+    errColl->push_back(maps.m_robMap.size());
+    ErrorMap::const_iterator iter  = maps.m_robMap.begin();
+    ErrorMap::const_iterator iterE = maps.m_robMap.end();
     for (; iter != iterE; ++iter) {
       errColl->push_back(iter->first);
       errColl->push_back(iter->second);
     }
-    m_robMap.clear();
-    iter  = m_rodMap.begin();
-    iterE = m_rodMap.end();
+    maps.m_robMap.clear();
+    iter  = maps.m_rodMap.begin();
+    iterE = maps.m_rodMap.end();
     for (; iter != iterE; ++iter) {
       errColl->push_back(iter->first);
       errColl->push_back(iter->second);
     }
-    m_rodMap.clear();
+    maps.m_rodMap.clear();
   }
   return StatusCode::SUCCESS;
 }

Trigger/TrigT1/TrigT1CaloByteStream/src/L1CaloErrorByteStreamTool.h

@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "AthenaBaseComps/AthAlgTool.h"
+#include "AthenaKernel/SlotSpecificObj.h"
 
 class IInterface;
 class InterfaceID;
@@ -34,23 +35,27 @@ class L1CaloErrorByteStreamTool : public AthAlgTool {
    /// AlgTool InterfaceID
    static const InterfaceID& interfaceID();
 
-   virtual StatusCode initialize();
-   virtual StatusCode finalize();
+   virtual StatusCode initialize() override;
+   virtual StatusCode finalize() override;
 
    /// Set ROB status error
-   void robError(uint32_t robid, unsigned int err);
+   void robError(uint32_t robid, unsigned int err) const;
    /// Set ROD unpacking error
-   void rodError(uint32_t robid, unsigned int err);
+   void rodError(uint32_t robid, unsigned int err) const;
    /// Fill vector with accumulated errors and reset
    StatusCode errors(std::vector<unsigned int>* errColl);
 
  private:
 
-   // Maps of accumulated errors
+   // FIXME: do this in a sane way...
    typedef std::map<uint32_t, unsigned int> ErrorMap;
-   ErrorMap m_robMap;
-   ErrorMap m_rodMap;
-
+   struct ErrorMaps {
+     // Maps of accumulated errors
+     ErrorMap m_robMap;
+     ErrorMap m_rodMap;
+     std::mutex m_mutex;
+   };
+   mutable SG::SlotSpecificObj<ErrorMaps> m_maps;
 };
 
 } // end namespace