self discrimination?

[teathinker]

Hi, I found an interesting issue in my performance analysis.

class aclass
{
public:
    entt::delegate<int(int, int)> delegate1;
    inline int fun (int i, int j)
    {
        return i + j;
    }
};

Now I have two instances

aclass a1;
aclass a2;

I found
a1.delegate1.connect<&aclass::fun>(a2);
is faster than
a1.delegate1.connect<&aclass::fun>(a1);
when run
a1.delegate1(x,y)

Looks to me some optimization is blocked when a class is connected to itself. Any idea why? Thanks.
C++17 with gcc version 9.2.0 (GCC) on kernel 5.10.0

[skypjack]

Best title ever prize goes to you. 😄
Nothing changes in the two cases under the hood. It's likely something that boils down to the compiler.
Unfortunately, it's not even something of which I'm aware, this is the first time such a thing gets reported. I'm sorry.

[skypjack]

How do you measure the perf difference? If you've a repro code, I can give it a try with msvc and clang too.

[teathinker]

I simply run in a loop with a technique to make sure the loop won't get optimized out.

#include "entt/delegate.h"
#include <iostream>
#include <chrono>

using namespace chrono;

template <class Tp>
[[gnu::always_inline]] inline void DoNotOptimize(Tp const& value) {
    asm volatile("" : : "r,m"(value) : "memory");
}

template <class Tp>
[[gnu::always_inline]] inline void DoNotOptimize(Tp& value) {
    asm volatile("" : "+m,r"(value) : : "memory");
}

int main()
{
    class aclass
    {
    public:
        entt::delegate<int(int, int)> delegate1;
        inline int fun (int i, int j)
        {
            return i + j;
        }
    };

    long n_round = 100000;

    aclass a1;
    aclass a2;
    a1.delegate1.connect<&aclass::fun>(a2);
    int j = 1;
    int res = 0;
    auto start = high_resolution_clock::now();
    for (int i = 0; i < n_round; i++)
    {
        res += a1.delegate1(i, j);
        ::DoNotOptimize(res);
    }
    auto stop = high_resolution_clock::now();
    auto dur = duration_cast<nanoseconds>(stop - start).count();
    std::cout << "connect to other " << static_cast<double>(dur)  / n_round << " ns" << std::endl;

    aclass a3;
    a3.delegate1.connect<&aclass::fun>(a3);
    res = 0;
    start = high_resolution_clock::now();
    for (int i = 0; i < n_round; i++)
    {
        res += a3.delegate1(i, j);
        ::DoNotOptimize(res);
    }
    stop = high_resolution_clock::now();
    dur = duration_cast<nanoseconds>(stop - start).count();
    std::cout << "connect to self " << static_cast<double>(dur)  / n_round << " ns" << std::endl;
    return 0;
}

results with -O3 on my machine:

connect to other 0.29017 ns
connect to self 1.04333 ns

[skypjack]

I did a few experiments. With the code above, it seems something that highly depends on the order of execution.
Just swap the two and self will take half of the time of other in this case. At least, this is what I'm observing locally.

[teathinker]

What compiler version are you using? I swapped them but observed no difference. I looked into assembly and did see more optimization when a1 connected to other. Here it is: https://godbolt.org/z/oETh9P38a
Just switch a1's connection to a2 and back to a1 you will see the difference. Thanks.

[teathinker]

Interestingly, if I switch compiler to 11.2, their assembly are still different but optimization is at the same degree and no time difference can be observed. Maybe the solution is just to update the compiler. Thanks.