DelayedConditionsCleanerSvc.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHENASERVICES_DELAYEDCONDITIONSCLEANERTOOLSVC_H
#define ATHENASERVICES_DELAYEDCONDITIONSCLEANERTOOLSVC_H
 
 
#include "AthenaBaseComps/AthService.h"
#include "AthenaKernel/IConditionsCleanerSvc.h"
#include "CxxUtils/Ring.h"
#include <queue>
#include <mutex>
#include <cstdint>
#include <atomic>
#include <unordered_map>
 
 
namespace Athena {
 
 
class DelayedConditionsCleanerTask;
class DelayedConditionsCleanerSvcProps;
 
 
class DelayedConditionsCleanerSvc
  : public extends<AthService, IConditionsCleanerSvc>
{
public:
  typedef CondContBase::key_type key_type;
 
 
  DelayedConditionsCleanerSvc (const std::string& name, ISvcLocator* svc);
 
  ~DelayedConditionsCleanerSvc();
 
 
  virtual StatusCode initialize() override;
 
 
  virtual StatusCode finalize() override;
 
 
  virtual StatusCode event (const EventContext& ctx, bool allowAsync) override;
 
 
  virtual StatusCode condObjAdded (const EventContext& ctx,
                                   CondContBase& cc) override;
 
 
  virtual StatusCode printStats() const override;
 
 
  virtual StatusCode reset() override;
 
 
 
private:
  friend class DelayedConditionsCleanerTask;
 
 
  typedef CxxUtils::Ring<key_type> Ring;
 
 
  using KeyType = CondContBase::KeyType;
 
  typedef std::array<std::vector<key_type>,2> twoKeys_t;
 
 
  class CondContInfo
  {
  public:
    CondContInfo (CondContBase& cc) : m_cc (cc) {}
 
    CondContBase& m_cc;
 
    size_t m_nClean = 0;
 
    size_t m_nRemoved  = 0;
 
    size_t m_removed0 = 0;
 
    size_t m_removed1 = 0;
 
    size_t m_removed2plus = 0;
  };
 
 
  twoKeys_t getKeys(const Ring& runLBRing, const Ring& TSRing) const;
 
  void scheduleClean (std::vector<CondContInfo*>&& cis,
              twoKeys_t&& twoKeys,
                      bool allowAsync);
 
 
  void cleanContainers (std::vector<CondContInfo*>&& cis,
            twoKeys_t&& twoKeys);
 
 
  bool cleanContainer (CondContInfo* ci,
                       const twoKeys_t& keys) const;
 
 
 
  Ring m_runlbn;
  Ring m_timestamp;
 
  std::vector<key_type> m_slotLBN;
  std::vector<key_type> m_slotTimestamp;
  
 
  typedef std::unordered_map<CondContBase*, CondContInfo> CCInfoMap_t;
  CCInfoMap_t m_ccinfo;
 
 
  struct QueueItem
  {
    QueueItem (EventContext::ContextEvt_t evt, CondContInfo& ci)
      : m_evt (evt), m_ci (&ci)
    {}
    
    EventContext::ContextEvt_t m_evt;
    CondContInfo* m_ci;
 
    bool operator< (const QueueItem& other) const
    {
      // Reversed, since we want the lowest to come first.
      return m_evt > other.m_evt;
    }
  };
 
  std::priority_queue<QueueItem> m_work;
 
  typedef std::mutex mutex_t;
  typedef std::lock_guard<mutex_t> lock_t;
  mutable mutex_t m_workMutex;
 
 
  size_t m_nEvents = 0;     // Number of times queue was examined.
  size_t m_queueSum = 0;    // Running sum of queue size.
  size_t m_workRemoved = 0; // Count of items removed from the queue.
  size_t m_maxQueue = 0;    // Maximum queue size.
 
 
  std::atomic<int> m_cleanTasks {0};
 
  std::unique_ptr<DelayedConditionsCleanerSvcProps> m_props;
};
 
 
} // namespace Athena
 
 
#endif // not ATHENASERVICES_DELAYEDCONDITIONSCLEANERTOOLSVC_H