Warm up some variables in C++

Question

I have a C++ library that works on some numeric values, this values are not available at compile time but are immediatly available at runtime and are based on machine-related details, in short I need values like display resolution, the number of CPU cores and so on.

The key points of my question are:

• I can't ask to the user to input this values ( both the coders/user of my lib and the final user )
• I need to do this warm up only once the application starts, it's a 1 time only thing
• this values are later used by methods and classes

the possible solutions are:

• build a data structure Data, declare some Data dummy where dummy is the name of the variable used to store everything and the contructor/s will handle the one time inizialization for the related values
• wrap something like the first solution in a method like WarmUp() and putting this method right after the start for the main() ( it's also a simple thing to remember and use )

the big problems that are still unsolved are:

• the user can declare more than 1 data structure since Data it's a type and there are no restrictions about throwing 2-4-5-17 variables of the same type in C++
• the WarmUp() method can be a little intrusive in the design of the other classes, it can also happen that the WarmUp() method is used in local methods and not in the main().

I basically need to force the creation of 1 single instance of 1 specific type at runtime when I have no power over the actual use of my library, or at least I need to design this in a way that the user will immediately understand what kind of error is going on keeping the use of the library intuitive and simple as much as possible.

Can you see a solution to this ?

---

EDIT:

my problems are also more difficult due to the fact that I'm also trying to get a multi-threading compatible data structure.

Answer 1

What about to use lazily-create singleton? E.g

struct Data
{
  static Data & instance()
  {
    static Data data_;
    return data_;
  }
private:
  Data()
  {
    //init
  }
}

Data would be initialized on first use, when you call Data::instance()

Edit: as for multithreading, read efficient thread-safe singleton in C++

Edit2 realisation using boost::call_once

Answer 2

Warmup is usually related to performance issues (and makes me think of the processor cache, see the __builtin_prefetch of GCC).

Maybe you want to make a singleton class, there are many solutions to this (e.g. this C++ singleton tutorial).

Also, if performance is the primary concern, you could consider that the configured parameters are given at initialization (or even at installation) time. Then, you could specialize your code, perhaps as simply as having templates and instanciating them at first by emitting (at runtime = initialization time) the appropriate C++ stub source code and compiling it (at "runtime", e.g. at initialization) and dynamically loading it (using plugins & dlopen ...). See also this answer.

Answer 3

First, as others have said, the obvious (and best) answer to this is a singleton. Since you've added the multithreading requirement, however: there are two solutions, depending on whether the object will be modified by code using the singleton. (From your description, I gather not.) If not, then it is sufficient to use the "naïve" implementation of a singleton, and ensure that the singleton is initialized before threads are started. If no thread is started before you enter main (and I would consider it bad practice otherwise), then something like the following is largely sufficient:

class Singleton
{
    static Singleton const* ourInstance;
    Singleton();

    Singleton( Singleton const& );
    Singleton& operator=( Singleton const& );

public:
    static Singleton const& instance();
};

and in the implementation:

Singleton const* Singleton::ourInstance = &Singleton::instance();

Singleton const&
Singleton::instance()
{
    if ( ourInstance == NULL ) {
        ourInstance = new Singleton;
    }
    return *ourInstance;
}

No locking is necessary, since no thread will be modifying anything once threading starts.

If the singleton is mutable, then you have to protect all access to it. You could do something like the above (without the const, obviously), and leave the locking to the client, but in such cases, I'd prefer locking in the instance function, and returning an std::shared_ptr with a deleter which frees the lock, which was acquired in the instance function. I think something like the following could work (but I've never actually needed it, and so haven't tried it):

class Singleton
{
    static Singleton* ourInstance;
    static std::mutex ourMutex;

    class LockForPointer
    {
    public:
        operator()( Singleton* )
        {
            Singleton::ourMutex.unlock();
        }
    };
    class LockForInstance
    {
        bool myOwnershipIsTransfered;
    public:
        LockForInstance
            : myOwnershipIsTransfered( false )
        {
            Singleton::ourMutex.lock();
        }
        ~LockForInstance()
        {
            if ( !myOwnershipIsTransfered ) {
                Singleton::ourMutex.unlock();
            }
        }
        LockForPointer transferOwnership()
        {
            myOwnershipIsTransfered = true;
            return LockForPointer();
        }
    };
public:
    static std::shared_ptr<Singleton> instance();
};

and the implementation:

static Singleton* ourInstance = NULL;
static std::mutex ourMutex;

std::shared_ptr<Singleton>
Singleton::instance()
{
    LockForInstance lock;
    if ( ourInstance == NULL ) {
        ourInstance = new Singleton;
    }
    return std::shared_ptr<Singleton>( ourInstance, lock.transferOwnership() );
}

This way, the same lock is used for the check for null and for accessing the data.