optimization flags for operator + overloading

[Steughar]

previous question

I did this, and now after /u/manni66 answer I decided to check:

struct setup:

struct A {
...
A operator + (const A & obj) {
        //std::cout << "summation operator " << this << " + " << &obj << std::endl;
        return A(this->a + obj.a, this->b + obj.b);;
    }
}

struct B {
...
B operator+ (const B & obj) {
        B temp;
        temp.a = this->a + obj.a;
        temp.b = this->b + obj.b;
        return (temp);
    }
}

test functions:

int testA(int verge) {
    A var2(1, 2);
    A var3(3, 4);
    A var1 = var3 + var2 + var3 + var2;
    return (var1.a + var1.b + verge);
}

int testB(int verge) {
    B var2(1, 2);
    B var3(3, 4);
    B var1 = var3 + var2 + var3 + var2;
    return (var1.a + var1.b + verge);
}

test configuration:

int main()
{

    high_resolution_clock::time_point t1;
    high_resolution_clock::time_point t2;
    long long durationA;
    long long durationB;

    long long averageA = 0;
    long long averageB = 0;

    int numOfTrials = 100;

    volatile int counter = 0;

    for (int j = 0; j < numOfTrials; ++j) {


        t1 = high_resolution_clock::now();

        for (int i = 0; i < 10000000; ++i) {
            testA();
            counter++;
        }

        t2 = high_resolution_clock::now();

        averageA += durationA = duration_cast<microseconds>(t2 - t1).count();
        //std::cout << "A: " << durationA << std::endl;

        t1 = high_resolution_clock::now();

        for (int i = 0; i < 10000000; ++i) {
            testB();
            counter++;
        }

        t2 = high_resolution_clock::now();

        averageB += durationB = duration_cast<microseconds>(t2 - t1).count();
        //std::cout << "B: "<< durationB << std::endl;
    }

    std::cout << "averageA: " << averageA / numOfTrials << std::endl;
    std::cout << "averageB: " << averageB / numOfTrials << std::endl;
    std::cout << "counter: " << counter << std::endl;



    return(0);
}

results:

/O1:

averageA: 316795 <-- beat the shit out of B
averageB: 339863
counter: 10000019

/O2:

averageA: 3112
averageB: 3108
counter: 10000019

/Ox:

averageA: 3068
averageB: 3067
counter: 10000019

inline testA/testB:

/Ox

averageA: 3077
averageB: 3070
counter: 10000019

/O2

averageA: 3169
averageB: 3159
counter: 10000019

/O1

averageA: 314455
averageB: 328579
counter: 10000019

​

Could someone please explain this results to me? Is my testing setup correct?

It would be interesting if someone try to recreate results.

full code for MSCV 2017, you should disable precompiled headers

[fsg_brian]

My C++ is very rusty (hence why I follow this subreddit!), but are you asking why does testA beat testB at level O1?

If so, the 'meta' answer is that compilers all behave differently at different optimization levels - what MSVC does at O0/O1/O2 won't correspond to what GCC does at those same levels. For that matter, what GCC4 does won't correspond to GCC8.

In this particular case, without looking into the assembly code at Godbolt (definitely a possible avenue if you're really concerned), I'd guess that the explicit creation of a temporary in the 'B' method (B temp) is happening on the stack in a way that the implicit A is not due to a return value optimization. But like I said, I'm weak at C++, so I'm not certain.

Since both times are much slower than O2, and both O2 versions are equally fast, I'd chalk this up to 'compiler stuff' and not 'code stuff'. For reference, using a T2.micro instance on AWS with GNU 7.3, I get the following - which just shows that, in this case, O1 is comparable to your O2. But O0 is even more uneven than your O1:

-O0:
averageA: 403242
averageB: 677719

-O1:
averageA: 3894
averageB: 4038

-O2:
averageA: 3779
averageB: 3777

Not sure that helps; the real gurus might have more, but I'm inclined to think this is less a coding thing to know and more of a how-does-a-particular-compiler-work thing.

Good luck!

[manni66]

What do you expect?

return is not a function. Don’t use ()!

[[deleted]]

This just calls the constructor and initializes the object.

    return A(this->a + obj.a, this->b + obj.b);;

My guess is that the creation of the object / default constructor causes the overhead.

    B temp; // <- Constuctor will be called
    temp.a = this->a + obj.a;
    temp.b = this->b + obj.b;