SystemC/TLM (C++) sharing memory pool; static members, static methods, Singleton or?

Question

Context: I am writing a specific communication protocol to be used between TLM models (HW blocks described with SystemC and thus C++). TLM notion is not important, just note that this communication is mimicked by allocating objects, the generic payloads (gps), that are passed between these C++ models of HW blocks.

Aim: Together with the protocol, I want to provide a memory manager that should be able to efficiently handle the gps; this is quite important since in one simulation lots of gps are constructed, used and destroyed and this can slow down things a lot. My goal is also to create something simple that could be used by others without efforts.

Issues:

The first issue I had was in creating a single shared pool for all the blocks communicating with that protocol. I thought about creating a static member in the mm class, but then I realized that:
- Static members require a definition in the cpp. This makes the mm class less intuitive to use (with different people using this, some will forget to do so) and I would prefer to avoid that.
- Depending on where (and in which?) in the cpp file the static variable definition is done, the pool might not have wet the parameters needed to be initialized (i.e., the number of mm instances created).
The second issue is similar to the first one. I want to count the number of instances and thus instead of a pool I need to create a shared counter to be used then by the pool to initialize itself. Again, I wanted to avoid static variable definitions in a cpp file and to guarantee the order of initialization.

I have considered mainly:

static members (discarded for the reasons above)
Singletons (discarded because I don't need to create a whole class for the pool to make it visible by others and single-instanced)
static methods (the approaches I finally picked and that is not far from a complete Singleton)

This is the code I produced (only relevant part included):

/**
* Helper class to count another class' number of instances.
*/
class counter {
public:
  // Constructor
  counter() : count(0) {}

  //Destructor
  virtual ~counter() {}

private:
  unsigned int count;

public:
  unsigned int get_count() {return count;}
  void incr_count() {count++;}
  void decr_count() {count--;}
};


template <unsigned int MAX = 1>
class mm: public tlm::tlm_mm_interface {
//////////////////////////////TYPEDEFS AND ENUMS/////////////////////////////
public:
  typedef tlm::tlm_generic_payload gp_t;

///////////////////////////CLASS (CON/DE)STRUCTOR////////////////////////////
public:
  // Constructor
  mm() {inst_count().incr_count();}

  // Copy constructor
  mm(const mm&) {inst_count().incr_count();}

  // Destructor
  virtual ~mm() {}  // no need to decrease instance count in our case

////////////////////////////////CLASS METHODS////////////////////////////////
public:
  // Counter for number of isntances.
  static counter& inst_count() {
    static counter cnt;
    return cnt;
  }

  /* This pattern makes sure that:
  -- 1. The pool is created only when the first alloc appears
  -- 2. All instances of mm have been already created (known instance sequence)
  -- 3. Only one pool exists */
  static boost::object_pool<gp_t>& get_pool() {
    static boost::object_pool<gp_t> p(
      mm<MAX>::inst_count().get_count() * MAX / 2, // creation size
      mm<MAX>::inst_count().get_count() * MAX      // max size used
    );
    return p;
  }

  // Allocate
  virtual gp_t* allocate() {
    //...
    return gp;
  }

  // Free the generic payload and data_ptr
  virtual void free(gp_t* gp) {
     //...
     get_pool().destroy(gp);
  }
}

Now, the initiator block class header should have a member:

mm m_mm;

And the initiator block class cpp should use this like:

tlm_generic_payload* gp;
gp = m_mm.allocate();
//...
m_mm.free(gp); // In truth this is called by gp->release()...
               // ...not important here

Having an electronic HW background, I am mainly trying to improve coding style, learn new approaches and optimize speed/memory allocation.

Is there a better way to achieve this? In particular considering my doubts:

It seems to me a not optimal workaround to encapsulate the counter in a class, put it locally (but static) in a static method and then do the same for the pool.
even though SystemC "simulation kernel" is single-threaded, I need to consider a multithread case...I am not sure that the relationship between those two static methods is safe even thou independently they should be safe...with C++03 g++ adds code to guarantee it and with C++11:

§6.7 [stmt.dcl] p4 If control enters the declaration concurrently while the variable is being initialized, the concurrent execution shall wait for completion of the initialization.

Thanks in advance.

SystemC/TLM (C++) sharing memory pool; static members, static methods, Singleton or?

0 Answers0