如何使动态数组或向量以与标准数组类似的速度运行？ C ++

Question

I'm still quite inexperienced in C++ and i'm trying to write sum code to add numbers precisely. This is a dll plugin for some finite difference software and the code is called several million times during a run. I want to write a function where any number of arguments can be passed in and the sum will be returned. My code looks like:

#include <cstdarg>

double SumFunction(int numArgs, ...){ // this allows me to pass any number 
                                      // of arguments to my function.
va_list args;
va_start(args,numArgs); //necessary prerequisites for using cstdarg

double myarray[10];
for (int i = 0; i < numArgs; i++) {
    myarray[i] = va_arg(args,double);
}       // I imagine this is sloppy code; however i cannot create
        // myarray{numArgs] because numArgs is not a const int.
sum(myarray); // The actual method of addition is not relevant here, but
              //for more complicated methods, I need to put the summation 
              // terms in a list.

vector<double> vec(numArgs); // instead, place all values in a vector
for (int i = 0; i < numArgs; i++) {
    vec.at(i) = va_arg(args,double);
}
sum(vec); //This would be passed by reference, of course. The function sum
          // doesn't actually exist, it would all be contained within the 
          // current function. This is method is twice as slow as placing 
          //all the values in the static array.

double *vec;
vec =  new double[numArgs];
for (int i = 0; i < (numArgs); i++) {
    vec[i] = va_arg(args,double);
}
sum(vec); // Again half of the speed of using a standard array and 
          // increasing in magnitude for every extra dynamic array!

delete[] vec;
va_end(args);
}

So the problem I have is that using an oversized static array is sloppy programming, but using either a vector or a dynamic array slows the program down considerably. So I really don't know what to do. Can anyone help, please?

Answer 1

When using a std::vector the optimizer must consider that relocation is possible and this introduces an extra indirection.

In other words the code for

v[index] += value;

where v is for example a std::vector<int> is expanded to

int *p = v._begin + index;
*p += value;

ie from vector you need first to get the field _begin (that contains where the content starts in memory), then apply the index, and then dereference to get the value and mutate it.

If the code performing the computation on the elements of the vector in a loop calls any unknown non-inlined code, the optimizer is forced to assume that unknown code may mutate the _begin field of the vector and this will require doing the two-steps indirection for each element.

(NOTE: that the vector is passed with a cost std::vector<T>& reference is totally irrelevant: a const reference doesn't mean that the vector is const but simply puts a limitation on what operations are permitted using that reference ; external code could have a non- const reference to access the vector and const ness can also be legally casted away... const ness of references is basically ignored by the optimizer ).

One way to remove this extra lookup (if you know that the vector is not being resized during the computation) is to cache this address in a local and use that instead of the vector operator [] to access the element:

int *p = &v[0];
for (int i=0,n=v.size(); i<n; i++) {
    /// use p[i] instead of v[i]
}

This will generate code that is almost as efficient as a static array because, given that the address of p is not published, nothing in the body of the loop can change it and the value p can be assumed constant (something that cannot be done for v._begin as the optimizer cannot know if someone else knows the address of _begin ).

I'm saying "almost" because a static array only requires indexing, while using a dynamically allocated area requires "base + indexing" access; most CPUs however provide this kind of memory access at no extra cost. Moreover if you're processing elements in sequence the indexing addressing becomes just a sequential memory access but only if you can assume the start address constant (ie not in the case of std::vector<T>::operator[] ).

Answer 2

One way to speed the code up (at the cost of making it more complicated) is to reuse a dynamic array or vector between calls, then you will avoid incurring the overhead of memory allocation and deallocation each time you call the function.

For example declare these variables outside your function either as global variables or as member variables inside some class. I'll just make them globals for ease of explanation:

double* sumArray = NULL;
int sumArraySize = 0;

In your SumFunction, check if the array exists and if not allocate it, and resize if necessary:

double SumFunction(int numArgs, ...){ // this allows me to pass any number 
                                  // of arguments to my function.
    va_list args;
    va_start(args,numArgs); //necessary prerequisites for using cstdarg

    // if the array has already been allocated, check if it is large enough and delete if not:
    if((sumArray != NULL) && (numArgs > sumArraySize))
    {
        delete[] sumArray;
        sumArray = NULL;
    }

    // allocate the array, but only if necessary:
    if(sumArray == NULL)
    {
        sumArray = new double[numArgs];
        sumArraySize = numArgs;
    }

    double *vec = sumArray;   // set to your array, reusable between calls
    for (int i = 0; i < (numArgs); i++) {
        vec[i] = va_arg(args,double);
    }
    sum(vec, numArgs); // you will need to pass the array size

    va_end(args);

    // note no array deallocation
}

The catch is that you need to remember to deallocate the array at some point by calling a function similar to this (like I said, you pay for speed with extra complexity):

void freeSumArray()
{
    if(sumArray != NULL)
    {
        delete[] sumArray;
        sumArray = NULL;
        sumArraySize = 0;
    }
}

You can take a similar (and simpler/cleaner) approach with a vector, allocate it the first time if it doesn't already exist, or call resize() on it with numArgs if it does.

Answer 3

Assuming that the "max storage ever needed" is in the order of 10-50, I'd say using a local array is perfectly fine.

Using vector<T> will use 3 * sizeof(*T) (at least) to track the contents of the vector. So if we compare that to an array of double arr[10]; , then that's 7 elements more on the stack of equal size (or 8.5 in 32-bit build). But you also need a call to new , which takes a size argument. So that takes up AT LEAST one, more likely 2-3 elements of stackspace, and the implementation of new is quite possibly not straightforward, so further calls are needed, which take up further stack-space.

If you "don't know" the number of elements, and need to cope with quite large numbers of elements, then using a hybrid solution, where you have a small stack-based local array, and if numargs > small_size use vector, and then pass vec.data() to the function sum .