RCUObject.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
#include "AthenaKernel/RCUObject.h"
#include "AthenaKernel/IRCUSvc.h"
#include "boost/dynamic_bitset.hpp"
#include <cstdlib>
 
 
namespace {
 
 
inline
bool endGrace (const EventContext& ctx,
               boost::dynamic_bitset<>& grace)
{
  EventContext::ContextID_t slot = ctx.slot();
  if (slot == EventContext::INVALID_CONTEXT_ID) return false;
  if (slot >= grace.size()) std::abort();
  grace[slot] = false;
  return grace.any();
}
 
 
} // anonymous namespace
 
 
namespace Athena {
 
 
struct RCUObjectGraceSets
{
  RCUObjectGraceSets (size_t nslots)
    : m_grace (nslots),
      m_oldGrace (nslots)
  {
  }
 
 
  boost::dynamic_bitset<> m_grace;
 
  boost::dynamic_bitset<> m_oldGrace;
};
 
 
IRCUObject::IRCUObject (IRCUSvc& svc)
  : m_svc (&svc),
    m_graceSets (std::make_unique<RCUObjectGraceSets> (svc.getNumSlots())),
    m_nold(0),
    m_dirty(false)
{
  m_svc->add (this);
}
 
 
IRCUObject::IRCUObject (size_t nslots)
  : m_svc (nullptr),
    m_graceSets (std::make_unique<RCUObjectGraceSets> (nslots)),
    m_nold(0),
    m_dirty(false)
{
}
 
 
IRCUObject::~IRCUObject()
{
  if (m_svc && m_svc->remove (this).isFailure())
    std::abort();
}
 
 
IRCUObject::IRCUObject (IRCUObject&& other)
  : m_svc (other.m_svc),
    m_graceSets (std::move (other.m_graceSets)),
    m_nold (other.m_nold),
    m_dirty (false)
{
  other.m_nold = 0;
  if (other.m_dirty) {
    m_dirty = true;
  }
  other.m_dirty = false;
  if (m_svc) {
    if (m_svc->remove (&other).isFailure()) {
      std::abort();
    }
    other.m_svc = nullptr;
    m_svc->add (this);
  }
}
 
 
void IRCUObject::quiescentOol (const EventContext& ctx)
{
  // We get here after the dirty flag has already been checked.
  lock_t g (m_mutex);
  if (!::endGrace(ctx, m_graceSets->m_grace)) {
    clearAll(g);
    m_nold = 0;
    m_dirty = false;
  }
  else if (m_nold > 0 && !::endGrace(ctx, m_graceSets->m_oldGrace)) {
    if (clearOld(g, m_nold)) {
      m_dirty = false;
    }
    m_nold = 0;
  }
}
 
 
bool IRCUObject::endGrace (lock_t& /*lock*/, const EventContext& ctx)
{
  return ::endGrace (ctx, m_graceSets->m_grace);
}
 
 
void IRCUObject::setGrace (lock_t& /*lock*/)
{
  m_graceSets->m_grace.set();
  if (!m_dirty) m_dirty = true;
}
 
 
void IRCUObject::makeOld (lock_t& /*lock*/, size_t garbageSize)
{
  if (garbageSize && m_nold == 0) {
    m_graceSets->m_oldGrace = m_graceSets->m_grace;
    m_nold = garbageSize;
  }
}
 
 
} // namespace Athena