typed-counter.hpp

Go to the documentation of this file.

/*
  TYPED-COUNTER.hpp  -  maintain a set of type based contexts 

   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>

  **Lumiera** is free software; you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by the
  Free Software Foundation; either version 2 of the License, or (at your
  option) any later version. See the file COPYING for further details.

*/


#ifndef LIB_TYPED_COUNTER_H
#define LIB_TYPED_COUNTER_H

#include "lib/error.hpp"
#include "lib/sync-classlock.hpp"

#include <atomic>
#include <string>
#include <deque>


namespace util {
  std::string showSize (size_t)   noexcept;
}

namespace lib {
  
  typedef size_t IxID;              
  
  using std::deque;
  using std::string;
  
  
  template<class CX>
  class TypedContext
    {
      static IxID lastGeneratedTypeID;
      
    public:
      static IxID
      newTypeID (IxID& typeID)
        {
          ClassLock<TypedContext> synchronised;
          if (!typeID)
            typeID = ++lastGeneratedTypeID;
          return typeID;
        }
      
      template<typename TY>
      class ID
        {
          static IxID typeID;
          
        public:
          static IxID
          get()
            {
              if (typeID)
                return typeID;
              else
                return newTypeID(typeID);
            }
        };
    };
  
  template<class CX>
  IxID TypedContext<CX>::lastGeneratedTypeID (0);
  
  template<class CX>
  template<typename TY>
  IxID TypedContext<CX>::ID<TY>::typeID (0);
  
  
  
  
  class TypedCounter
    : public Sync<>
    {
      mutable deque<std::atomic_int64_t> counters_;
      
      template<typename TY>
      IxID
      slot()  const
        {
          IxID typeID = TypedContext<TypedCounter>::ID<TY>::get();
          if (size() < typeID)
            {       // protect against concurrent slot allocations
              Lock sync{this};
              if (size() < typeID)
                counters_.resize (typeID);
            }
          
          ENSURE (counters_.size() >= typeID);
          return (typeID - 1);
        }
      
      
    public:
      template<class X>
      int64_t
      get()  const
        {
          return counters_[slot<X>()].load(std::memory_order_relaxed);
        }
      
      template<class X>
      int64_t
      inc()
        {                                 // yields the value seen previously
          return 1 + counters_[slot<X>()].fetch_add(+1, std::memory_order_relaxed);
        }
      
      template<class X>
      int64_t
      dec()
        {
          return -1 + counters_[slot<X>()].fetch_add(-1, std::memory_order_relaxed);
        }
      
      
      /* == diagnostics == */
      
      size_t size() const { return counters_.size(); }
      bool empty()  const { return counters_.empty();}
    };
  
  
  
  template<typename TY>
  class FamilyMember
    {
      const size_t id_;
      
      static std::atomic_size_t memberCounter;
      
      static size_t
      allocateNextMember()
        {                       // Note : returning previous value before increment
          return memberCounter.fetch_add(+1, std::memory_order_relaxed);
        }
      
    public:
      FamilyMember()
        : id_{allocateNextMember()}
        { }
      
      operator size_t()  const
        {
          return id_;
        }
      
      operator string()  const
        {
          return util::showSize (this->id_);
        }
      
      friend string
      operator+ (string const& prefix, FamilyMember id)
      {
        return prefix+string(id);
      }
      
      friend string
      operator+ (const char* prefix, FamilyMember id)
      {
        return string(prefix)+id;
      }
    };
  
  template<typename TY>
  std::atomic_size_t FamilyMember<TY>::memberCounter{0};
  
  
  
} // namespace lib
#endif