Swap 2D Double Arrays in c++

Question

I have the following method to swap two double arrays (double**) in c++. Profiling the code, the method is accounting for 7% of the runtime... I was thinking that this should be a low cost operation, any suggestions? I am new with c++, but i was hoping to just swap the references to the arrays.

 62 void Solver::Swap(double** &v1, double** &v2)
 63 {
 64         double** vswap = NULL;
 65         vswap = v2;
 66         v2 = v1;
 67         v1 = vswap;
 68 }

Answer 1

The code looks fine. Its is just a pointer assignment. It depends on how many times the method was got called.

Answer 2

I guess your profiler is getting confused here a bit, as this method really only swaps two pointers, which is very cheap. Unless this method is called a lot, it shouldn't show up in a profile. Does your profiler tell you how often this method gets called?

One issue you have to be aware of with swapping is that one array might be in the cache and the other not (especially if they are large), so constantly swapping pointers might trash the cache, but this would show up as a general slow-down.

Answer 3

Ok,

Yea, ran into the solution too quickly without thinking about it

Answer 4

1) Make sure your function is inlined.

2) You can inplace swap, using a XOR for instance

3) Try to force the compiler to pass arguments using register instead of the stack (even though there's lot of register stress on x86, it's worth trying) - you can use the standard register keyword or play with fastcall on MS' compiler.

typedef double** TwoDimArray;

class Solver
{
  inline void Swap( register TwoDimArray& a, register TwoDimArray& b )
  {
    a ^= b ^= a ^= b;
  }
};

4) Don't bother giving default values for temporaries like vswap.

Answer 5

Are you sure you profiled fully optimized code?

You should inlinethis function.

Other than that the only thing I see is that you first assign NULL to vswap and immediately afterwards some other value - but this should be taken care of by the optimizer.

 inline void Solver::Swap(double** &v1, double** &v2)
 {
   double** vswap = v2;
   v2 = v1;
   v1 = vswap;
 }

However, why don't you use std::swap()?

Answer 6

Don't assume that the 7% means this operation is slow - it depends on what else is going on.

You can have an operation that only takes 1 nanosecond, and make it take nearly 100% of the time, by doing nothing else.