Performance of method overloading

[zhqrbitee]

Hi, thanks for the great library! We have used pybind11 for quite a long time and one thing we notice that in pybind11, the performance of overload methods is decided by the location where it is defines, e.g.

    m.def("add", [](int a, int b) { return a + b; }, "a"_a, "b"_a);
    m.def("add", [](const std::string& a, const std::string& b) { return a + b; }, "a"_a, "b"_a);

    // reverse order
    m.def("add1", [](const std::string& a, const std::string& b) { return a + b; }, "a"_a, "b"_a);
    m.def("add1", [](int a, int b) { return a + b; }, "a"_a, "b"_a);

The add1(int, int) has a worse performance that add(int, int), as it is put in the second place in the overload list. I think this is because pybind11 will always try the first one in the overload and if it fails, then try the second. We actually saw > 10us of overhead when calling the last method out of 8 overloads.

With nanobind11, it seems much much better, but we still observe similar degradation when compare the last one to the first one. So did nanobind11 use the similar mechanize, e.g. try the first one, if fail, then go to the next?

[wjakob]

In short: yes. Same mechanism, but much faster.