ArenaAllocatorRegistry.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthAllocators/ArenaAllocatorRegistry.h"
#include "AthAllocators/ArenaAllocatorCreator.h"
#include "AthAllocators/ArenaAllocatorBase.h"
#include "CxxUtils/checker_macros.h"
#include <vector>
#include <map>
#include <mutex>
#include <cassert>
 
 
namespace SG {
 
 
class ArenaAllocatorRegistryImpl
{
public:
  ~ArenaAllocatorRegistryImpl();
 
 
  size_t registerCreator (const std::string& name,
                          std::unique_ptr<ArenaAllocatorCreator> creator);
 
 
  size_t lookup (const std::string& name);
 
 
  std::unique_ptr<ArenaAllocatorBase> create (size_t i);
 
 
private:
  typedef std::map<std::string, size_t> map_t;
  map_t m_map;
 
  std::vector<std::unique_ptr<ArenaAllocatorCreator> > m_creators;
 
  std::mutex m_mutex;
 
  typedef std::lock_guard<std::mutex> lock_t;
};
 
 
ArenaAllocatorRegistryImpl::~ArenaAllocatorRegistryImpl()
{
}
 
 
size_t
ArenaAllocatorRegistryImpl::registerCreator (const std::string& name,
                                             std::unique_ptr<ArenaAllocatorCreator> creator)
{
  lock_t lock (m_mutex);
 
  // See if there's an existing one by this name.
  // Shouldn't usually happen, since we check that the allocator doesn't
  // exist before calling this, but could happen in a MT job.
  // So we need to check it again with the lock held.
  map_t::iterator it = m_map.find (name);
  if (it != m_map.end()) {
    // creator will be deleted.
    return it->second;
  }
 
  // The new index.
  size_t i = m_creators.size();
 
  // Remember the index and store the creator.
  m_map[name] = i;
  m_creators.push_back (std::move (creator));
  return i;
}
 
 
size_t ArenaAllocatorRegistryImpl::lookup (const std::string& name)
{
  lock_t lock (m_mutex);
  map_t::iterator it = m_map.find (name);
  if (it == m_map.end()) {
    return std::string::npos;
  }
  return it->second;
}
 
 
std::unique_ptr<ArenaAllocatorBase>
ArenaAllocatorRegistryImpl::create (size_t i)
{
  lock_t lock (m_mutex);
  assert (i < m_creators.size());
  return m_creators[i]->create();
}
 
 
//==========================================================================
 
size_t
ArenaAllocatorRegistry::registerCreator (const std::string& name,
                                         std::unique_ptr<ArenaAllocatorCreator> creator)
{
  return m_impl->registerCreator (name, std::move (creator));
}
 
 
size_t ArenaAllocatorRegistry::lookup (const std::string& name)
{
  return m_impl->lookup (name);
}
 
 
std::unique_ptr<ArenaAllocatorBase> ArenaAllocatorRegistry::create (size_t i)
{
  return m_impl->create (i);
}
 
 
ArenaAllocatorRegistry* ArenaAllocatorRegistry::instance()
{
  static ArenaAllocatorRegistry tmp ATLAS_THREAD_SAFE;
  return &tmp;
}
 
 
ArenaAllocatorRegistry::ArenaAllocatorRegistry()
  : m_impl (std::make_unique<ArenaAllocatorRegistryImpl>())
{
}
 
 
ArenaAllocatorRegistry::~ArenaAllocatorRegistry()
{
}
 
 
} // namespace SG