Converting c implemented static allocated workspace to c++

Question

I have a working function implementation in c that requires a large locally allocated chunk of memory as a working space. This function gets called a lot in succession where it is guaranteed that the required amount of working space does not change. To optimize the function I have refactored it to allocate a static single continuous piece of memory the first time it is called, that is only released when it is asked to. It looks something like this

void worker(struct* ptr, size_t m) {
    static double *stack;
    static size_t  sz_stack;
    static double *alpha;
    static double *delta;

    if (!ptr) {
        if (stack) {
            free(stack);
        }
        stack    = NULL;
        sz_stack = 0;
        return;
    }

    if (!stack) {
        sz_stack = 2*m;
        stack    = calloc(sz_stack, sizeof(*stack));

        if (stack==NULL)
            // Error and cleanup
        alpha = stack;
        delta = alpha + m;
    }

    // Do work using alpha and delta as arrays
    return;
}

The caller can call this function successively where ptr will hold the final result as long as the problem size given by m does not change. When the caller is done with the function, or the problem size changes, he calls worker(NULL, 0); and the allocated memory will be freed.

I am now working on rewriting this codebase to c++ and as the best practices tell me I have used individual std::vector for alpha and delta instead of the contiguous stack. However, profiling revealed that there is a huge bottleneck as the std::vector containers are allocated and free'd each and every function call.

My question now is:

What is the modern c++ way to maintain a contiguous piece of working space for a function in between calls?

Answer 1

If it is guaranteed that the required working space will not be changing during contiguous function calls (as you mentioned), to me it seems the simplest solution would be to use a static array (somewhat similar to your C code, but using 'new' and 'delete[]' instead of 'calloc' and 'free').

Answer 2

static is a dreadful thing because it plays really badly with thread safety and is wholly unnecessary.

The modern way is one of the following:

Declare the memory further up on the stack. vector<> or array<> or even malloc if you like. Pass a pointer (or, equivalently, reference) to this memory into your function.

int main()
{
   vector<double> storage;
   while (1)
   {
      worker(&storage,0,0);
   }
   return 0;
}

Or, write your function as a member of a class. Declare the memory as a member of your class. Create one instance of your class, then call the function repeatedly:

struct oo_hack
{
  void worker (struct* ptr, size_t m) 
  {
    // Do some things using storage
  }
  vector<double> storage;
}
int main()
{
   oo_hack myhack; // This is on the stack, but has a vector inside
   while (1)
   {
   myhack.worker(0,0);
   }
  return 0;
} // memory gets freed here

I'd suggest declaring the memory further up on the stack and passing it into the functions, but you may prefer the second.

Answer 3

The C++ way would be to have a class with a private array that you can then manage.

It seems to me that the way you are handling static memory is very analogous to a constructor and destructor. I would have the array as the sole private member and then your worker function as a public member function.

Also, in terms of performance, STL can do some strange things and each implementation can be more or less strange than the next. If you really want speed (as you've seen), sometimes you have to handle things yourself.