Guard flag when dealing with memory allocation

Question

I hava some trouble understanding about guard flag in the following code.

// User-defined operator new.  
    void *operator new( size_t stAllocateBlock ) {  
       static int fInOpNew = 0;   // Guard flag.  

       if ( fLogMemory && !fInOpNew ) {  
          fInOpNew = 1;  
          clog << "Memory block " << ++cBlocksAllocated  
              << " allocated for " << stAllocateBlock  
              << " bytes\n";  
          fInOpNew = 0;  
       }  
       return malloc( stAllocateBlock );  
    } 

Anyone help to understand this ?

Thanks

EDIT: Thanks for clearing my doubt, and I understand this now. I got this code from here: https://msdn.microsoft.com/en-us/library/kftdy56f.aspx, they used same guard for delete also. Is the reason same ?

Please check my code, and share your suggestions to improve the code. Also, how to protect the code in multi threading with an example ? I would really appreciate this and it will clear my understanding about thread safe code, and also memory management very well.

Thanks

My version of code:

/*
 * Memory leak detector
 */

#include <iostream> // for cout, clog
#include <new>      // for size_t

using std::clog;
using std::cout;


/* Logging toggle, 0x0 - No, 0xFF - Yes */
char    logMemory;

/* Number of Memory blocks allocated */
int     memoryBlocksAllocated;

void* AllocateMemory(size_t size)
{
    /*
     * Guard flag for protecting from reentrancy (recursion),
     * as clog also make use of new operator for
     * allocating memory to the buffer.
     */

    static char InOperationNew = 0x0;

    if ( logMemory && !InOperationNew ) {
        InOperationNew = 0xFF;
        clog << "Memory block allocated " << ++memoryBlocksAllocated
        <<" for requested size " << size << " bytes\n";
        InOperationNew = 0x0;
    }

    return malloc(size);
}

void ReleaseMemory(void *ptr)
{
    /*
     * Guard flag for protecting from reentrancy (recursion),
     * as clog also make use of new operator for
     * allocating memory to the buffer.
     */

    static char InOperationDelete = 0x0;


    if ( logMemory && !InOperationDelete ) {
        InOperationDelete = 0xFF;
        clog << "Memory block deallocated " << memoryBlocksAllocated-- << "\n";
        InOperationDelete = 0x0;
    }

    free(ptr);
}

/* User defined(overriden) global scope new operator */
void* operator new (size_t size)
{
    return AllocateMemory(size);
}

/* User defined(overriden) global scope new[] array operator */
void* operator new[] (size_t size)
{
    return AllocateMemory(size);
}


/* User defined(overriden) global scope delete operator */
void operator delete (void *ptr)
{
    ReleaseMemory(ptr);
}

/* User defined(overriden) global scope delete[] array operator */
void operator delete[] (void *ptr)
{
    ReleaseMemory(ptr);
}

int main()
{
    logMemory = 0xFF;   // Enable logging

    // Allocate and destroy an array of objects
    char *objArray = new char[2];
    if ( objArray )
    {
        delete[] objArray;
    }
    else {
        cout << "Memory allocation failed\n";
        return -1;
    }

    // Allocate and destroy an object
    char *obj = new char;
    if ( obj )
    {
        delete obj;
    }
    else {
        cout << "Memory allocation failed\n";
        return -1;
    }

    logMemory = 0x0;    // Disable logging

    return 0;
}

Answer 1

From what I understand this is an attempt to avoid clobbering of the log stream by multiple threads.

Say two threads call the function at the same time. The messages being printed would get mixed (depending on the buffering mechanism used by the runtime).

To avoid this the programmer has created a static flag. Static variables local to a function are shared across all calls.

The intent is that when one call is logging the message it will first set the flag to 1. This will not allow other threads to enter. (See if !fInOpNew)

When it is done printing it sets the flag back to 0.

Though this mechanism at avoiding race condition in not going to work. Since the Two threads can enter the if condition and then the flag can be set.

The programmer needs to use atomic primitives like compare and swap to ensure protection of critical section.

Also use of static variables won't be safe. If two threads write to it simultaneously, it can get a value not equal to 0 or 1.

Edit : As suggested by Toby Speight, another purpose of the flag to avoid reentrance. calling the << operator on clog is also a function that might make use of the new operator (could be the same new operator). This will lead to an infinite recursion of this function. The flag makes sure that the logging in not invoked when the << operator calls new.

The assumption that the program is single threaded doesn't bring in race condition.