Question

I have a function that has a large number if individual input parameters, the function is also run hundreds of millions of times during the program.

If i wanted to optimize this function, should I create a new data structure that holds all the input parameters and pass it to the function by reference instead of passing each parameter individually to the function? Or would it not matter because the compiler is smart enough to deal wit this in an even more efficient manner?

Answer 1

In general, it’s much better to pass a data structure that contains your variables. This isn’t pretty to look at or use:

void f(int a, int b, int c, int d, int e, int f)
{
   // do stuff
}

This is much nicer:

void f(Params p)
{
  // do stuff with p
}

You may want to do pass by reference, so the compiler can just pass a reference to the object, and not copy the entire data structure.
As a real example:

double distance(double x1, double y1, double z1, double x2, double y2, double z2)
{
    double dx = x1 - x2;
    double dy = y1 - y2;
    double dz = z1 - z2;

    return sqrt(dx*dx + dy*dy + dz*dz);
}

It would be better if encapsulated our (x, y, z) into a data structure though:

struct Point
{
    double x;
    double y;
    double z;
};

double distance(const Point &p1, const Point &p2)
{
    double dx = p1.x - p2.x;
    double dy = p1.y - p2.y;
    double dz = p1.z - p2.z;

    return sqrt(dx*dx + dy*dy + dz*dz);
}

Much cleaner code, and you get the added bonus that it could* perform better (*Depending on how smart your compiler is at optimizing either version).

Obviously this could vary wildly depending on what you’re actually trying to accomplish, but if you have several (4+) variables that have a similar usage in a certain context, it may be better to just pass it in a data structure.