Memory Allocation Speed

[amccorm]

Hi guys,

I'm doing some scientific programming (dynamic mesh relaxation). My best language is Python, but I'm converting my code to C++ for speed. I've got it working, but have some questions on how to optimize it for speed. My first question is this: if I'm doing a lot of vector operations, is it hurting me to declare new memory
often? E.g., here's a simple vector function

float* vAdd(float* x1, float* x2){
// returns the vector x1 + x2
float* result = new float[3];
result[0] = x1[0] + x2[0];
result[1] = x1[1] + x2[1];
result[2] = x1[2] + x2[2];
return result;
}

In a outer function, I may call this 4 times, storing the values in variables
n1, n2, n3, n4. Would it be smarter to make n1, n2, n3, n4 global variables so as not have to reallocate memory for each call? I.e., also pass in the pointer
to the appropriate n.

[Bazzy]

I may call this 4 times

Anything done 4 times doesn't affect speed

Would it be smarter to make n1, n2, n3, n4 global variables so as not have to reallocate memory for each call? I.e., also pass in the pointer

you can pass them even if they are not global:

void vAdd ( float* x1, float* x2, float *result ){
    result[0] = x1[0] + x2[0];
    result[1] = x1[1] + x2[1];
    result[2] = x1[2] + x2[2];
}

void somewhere()
{
    float n4[3];
    vAdd ( x, y, n4 );
}

[amccorm]

Bazzy,

You are right. If it were only 4 it wouldn't effect speed. But I call THAT function once for each of my 1000 edges, and then all the edges once for each of my 100,000 iterations! So we're talking 400 million calls, which does matter. I guess my question is whether the memory allocation time is on the order of the calculation time, or if it is much smaller (or larger!) ?

[Bazzy]

Allocating / Freeing memory many times unnecessairly will indeed effect performance

[Disch]

Did you ever consider objectifying this?

Something like...

class Vector3
{
public:
  float x, y, z;

  inline Vector3 operator + (const Vector3& r) const
  {
    return Vector3(x+r.x,y+r.y,z+r.z);
  }
};

That way you can just do this:

myvec = a + b;

Instead of this:

vAdd(a,b,myvec);

[EzwRko23]

Avoid dynamic memory allocationif you can. New and delete are extremely slow in C++. Every call to new is typically 80-300 CPU cycles on modern processors if you are lucky (= no cache miss). So you might be much better off with placing your vectors on the stack and copying them (even if it requires copying 32B, it would be still faster). The float calculations are negligible compared to allocation time.

[jsmith]

Dynamic allocation of arrays is done when either the number of elements is not known at compile time
or if the size isn't fixed for the lifetime of the array.

Since your vAdd function always allocates a fixed-length array of 3 elements, dynamic memory allocation
is not needed.

I would do exactly as Disch suggested.

[EzwRko23]

Dynamic allocation of arrays is done when either the number of elements is not known at compile time or if the size isn't fixed for the lifetime of the array.

...or if the size of the data is so large, they wouldn't fit on the stack or you need to pass the objects up the stack (which would require copying).