Macro to run code once during the lifetime of the program

Question

I'm using this little macro a lot:

#define RUN_ONCE(runcode) \
{ \
    static bool code_ran = 0; \
    if(!code_ran){ \ 
        code_ran = 1; \
        runcode; \
    } \
}

I find it useful when I want to initialize stuff just once when I don't really care about performance (for example, if it's inside a render loop, it takes just 60 if's per sec). In a random generator, I can do RUN_ONCE(init_random()), so I don't need to separately initialize it, which prevents me from crashing when I call the function without initializing it first.

I'd like to know if any of you use a similar system, and if there's better way of doing this. Or if I should stop using this method immediately...

Answer 1

It is not thread safe. You can use Boost, or standard C++11 std::call_once.

Answer to comment:

Boost and C++11 are defining include library for launching threads and thread synchronization (locks, atomic variables…). The call_once function can either use those to ensure thread safety or use the thread lib of the OS (pthreads for *nix).

A very simplified (unefficent) implementation might be:

static std::mutex mutex;
static bool called = false;
{
   std::lock_guard<std::mutex> lock(mutex);
   if (!called) {
      f(); // <- User code
      called = true;
   }
}

It is not very efficient because the lock is always taken. An optimisation it to atomically check the once flag before taking the mutex:

static std::mutex mutex;
static std::atomic<bool> called = false;
{
   if (!called) {
     std::lock_guard<std::mutex> lock(mutex);
     if (!called) {
        f(); // <- User code
        called = true;
     }
   }
}

The implementation of pthread_once in glibc is interesting: it is much more complicated as it tries to behave correctly in presence of fork.

Boost/C++11 use a functor (function pointer or object with operator()): this way it can be implemented as a function and not a macro (you can use lambda in C++11 to avoid defining a separate function).

Answer 2

Note that macros such as this should be placed in a do { ... } while (0) block, otherwise you will encounter problems when the macro is invoked prior to an else, i.e.

#define RUN_ONCE(runcode) \
do \
{ \
    static bool code_ran = 0; \
    if (!code_ran) \
    { \ 
        code_ran = 1; \
        runcode; \
    } \
} while (0)

e.g. if you have a situation like this:

if (do_foo)
    RUN_ONCE(foo());
else
    printf("do_foo is false\n");

without a do ... while (0) this will expand to:

if (do_foo)
    {
        static bool code_ran = 0;
        if (!code_ran)
        { 
            code_ran = 1;
            foo();
        }
    }; // <<< syntax error here !
else
    printf("do_foo is false\n");

But using the do ... while (0) form we get:

if (do_foo)
    do
    {
        static bool code_ran = 0;
        if (!code_ran)
        { 
            code_ran = 1;
            foo;
        }
    } while (0); // <<< no syntax error here !
else
    printf("do_foo is false\n");

Answer 3

I prefer this over the macro-with-arguments version.

#define RUN_ONCE                                        \
    for (static bool _run_already_ = false;             \
         _run_already_ ? false : _run_already_ = true;) \
/***/

The above is not thread-safe, though. To make it thread safe, one could use std::atomic<>, but only if using C++11 and above.

#include <atomic>

#define RUN_ONCE                                       \
    for (static std::atomic<int> _run_already_(false); \
         !_run_already_.fetch_or(true);)               \
/***/

I used int rather than bool as the std::atomic<> template parameter because the standard doesn't seem to require the bool specialization to implement the fetch_or() method.

Either way, it can be used like this:

RUN_ONCE
{
    printf("Hello only once!\n");
    /* Other statements follow */
}

Or like this:

RUN_ONCE printf("Hello only once!\n");

It also supports returning directly from the RUN_ONCE body:

// Returns false the first time it's invoked,
// then it always returns true
bool test_run_once() {
    RUN_ONCE return false;

    return true;
}

Answer 4

Why are you putting code that determines correct usage of the function external to the function.

Rather than that why not put the code inside the function then it can never be used incorrectly.
The top priority is maintenance and re-use. You should write your code so that it can not be used incorrectly.

Thus rather than:

#define RUN_ONCE(runcode) \
{ \
    static bool code_ran = 0; \
    if(!code_ran){ \ 
        code_ran = 1; \
        runcode; \
    } \
}

void init_random()
{
    srand(time(NULL));
}

int main()
{
    RUN_ONCE(init_random())
}

You can do this:

void init_random()
{
    static bool code_ran = 0;
    if(!code_ran)
    {
        code_ran = 1;
        srand(time(NULL));
    }
}

int main()
{
    init_random();
}

Answer 5

Macros are generally a bad choice because some mad sod always finds a bad way to use them...

RUN_ONCE(}else{ or_not();)