Why doesn't g++ fully optimize these loops / operator calls? - c++

Question

Consider this struct which can for example represent a structure of 2 4D vectors:
struct A {
double x[4];
double y[4];
A() : A(0.0, 0.0) { }
A(double xp, double yp)
{
std::fill_n(x, 4, xp);
std::fill_n(y, 4, yp);
}
// Simple element-wise delegation of the mathematical operations
friend A operator+(const A &l, const A &r)
{
A res;
for (int i = 0; i < 4; i++)
{
res.x[i] = l.x[i] + r.x[i];
res.y[i] = l.y[i] + r.y[i];
}
return res;
}
friend A operator*(const A &l, const double &r)
{
A res;
for (int i = 0; i < 4; i++)
{
res.x[i] = l.x[i] * r;
res.y[i] = l.y[i] * r;
}
return res;
}
friend A operator*(const double &l, const A &r)
{
A res;
for (int i = 0; i < 4; i++)
{
res.x[i] = l * r.x[i];
res.y[i] = l * r.y[i];
}
return res;
}
friend std::ostream &operator<<(std::ostream &stream, const A &a)
{
for (int i = 0; i < 4; i++)
std::cout << "(" << a.x[i] << "|" << a.y[i] << ") ";
return stream;
}
};
For convenience, the struct has a few operators defined, which simply delegate to member- and element-wise operations.
Now, consider two different versions of a second struct B, that contains objects of A:
struct B { // version 1
double f1;
double f2; // Two coefficients
A buff1;
A buff2;
A buffa[4]; // Objects of struct A
// The following functions use the operators defined on struct A
void mathA(int i, double d) // Some math operations
{
buff2 = buff1 + buffa[i] * d;
}
void mathB() // Some more math (vector) operations
{
buff1 = f1 * (buffa[0] + buffa[3]) + f2 * (buffa[1] + buffa[2]);
}
};
and
struct B { // version 2
double f1;
double f2; // Two coefficients
A buff1;
A buff2;
A buffa[4]; // Objects of struct A
// The following functions DO NOT use the operators defined on struct A
void mathA(int i, double d) // Some math operations
{
for (int j = 0; j < 4; j++)
{
buff2.x[j] = buff1.x[j] + buffa[i].x[j] * d;
buff2.y[j] = buff1.y[j] + buffa[i].y[j] * d;
}
}
void mathB() // Some more math (vector) operations
{
for (int j = 0; j < 4; j++)
{
buff1.x[j] = f1 * (buffa[0].x[j] + buffa[3].x[j]) + f2 * (buffa[1].x[j] + buffa[2].x[j]);
buff1.y[j] = f1 * (buffa[0].y[j] + buffa[3].y[j]) + f2 * (buffa[1].y[j] + buffa[2].y[j]);
}
}
};
As you can see, the secont version of struct B performs the same mathematical operations, but the first version uses the operators of struct A while the second performs these operations manually in mathA and mathB. Note that the second version of struct B does not actually use the operators defined in struct A.
Let's add a main function to test the functionality of struct B (Diff window, "Left"):
int main(int argc, char **argv)
{
B b;
b.f1 = 0.5;
b.f2 = 0.8;
b.buff1 = A(0.7, 0.8);
b.buff2 = A(1.7, 2.8);
b.mathA(1, 0.9);
b.mathB();
std::cout << b.buff1 << "\n" << b.buff2;
}
I have prepared examples of both cases in godbolt here. Both cases are compiled using g++ 7.1.0 on optimization level -O3. The left case corresponds to version 1, the right case to version 2 of struct B.
As you can see in the disassembly, the compiler generates two labels for version 1, which correspond to the mathX functions in struct B:
64 B::mathA(int, double):
[…]
76 B::mathB():
As my analysis shows, the first example is much slower compared to the second example. The functions are called more than 1 billion times in my actual code and are thus very much contributing to the overall runtime. I assume this is partially due to the jumps to the function definitions.
Is there a way to force the compiler to produce an assembly that is identical to the second example? I.e. with using the definitions of the operators?
Update
Since the compiler seemed to generate labels and jumps for mathX(…) my idea was to attempt to inline these functions. Using the inline keyword changed nothing, but for g++ you can use __attribute__((always_inline)) which will force the compiler to inline the function (documentation):
struct B { // version 3
// …
mathA(int i, double d) __attribute__((always_inline))
{
// …
}
mathB() __attribute__((always_inline))
{
// …
}
};
This improved the performance, which is now somewhere between version 1 and version 2. This is still not perfect, but if no better solution will be found, I will go with this one.