Changing an inlined global function to a constant propagated functor argument

Question

I made a change to some code to increase user flexibility. However, this worsened performance in the original use cases. The original code made a call to a global function, and the new code made the global function a user-provided functor that defaults to the (now) global functor. I expected performance to be the same if the user used the default global functor, but that was not the case.

I will first present an outline of the original code and then explain the changes to produce the new code. ImportantFunction is the global function mentioned in the first paragraph above. Imagine ImportantFunction is something like std::less<>, funcD is something like std::sort, and funcA, funcB, and funcC are std::sort's helper functions. To keep the code clean, I am omitting additional function args for all of these functions. At first my code looked something like this:

void ImportantFunction(/*...*/){
    // ...
}

void funcA(){
    // ...
    ImportantFunction();
    // ...
}

void funcB(){
    // ...
    ImportantFunction();
    // ...
}

void funcC(){
    // ...
    funcA();
    // ...
    funcB();
    // ...
}

void funcD(/* non-functor args*/, /*Functor args*/){
    // ...
    funcC(/* ... */);
    // ...
}

The original code was fast and efficient. I then decided that the user should be able to provide their own definition of ImportantFunction. In accordance with T.40, I decided that ImportantFunction should be changed into a functor:

class DefaultImportantClass{
    [[gnu::always_inline]] constexpr inline void operator()(/* Important functions args*/) const {
        // ImportantFunction's body
    }
}

In the cases that an ImportantClass object was a compile-time constant, such as is the case with a DefaultImportantClass, I wanted it to propagate through the code and have the same performance characteristics as if ImportantClass's operator() were an inlined global function. However, my testing shows that my new code did not perform as well as when I used ImportantFunction.

funcD takes several functor args. I do not know if the other functor args are constant propagated, but they are passed and forwarded the same way as important class.

template<typename ImportantFunctor = DefaultImportantClass>
constexpr inline void funcD( /* non-functor args passed by value*/, \
ImportantFunctor&& important_functor = DefaultImportantClass{},\
/* other functor args passed by r-value reference */) noexcept {
        
    // ...
    funcC(/* non-functor args passed by value*/, std::forward<ImportantFunctor>(important_functor), /* other functor args passed with std::forward /*);
}

important_functor is then passed around the exact same way in funcA, funcB, and funcC. As an example, I will show how important_functor is then called in funcA.

template<typename ImportantClass>
[[gnu::always_inline]] constexpr inline void funcA(ImportantClass&& important_functor){
    important_functor(/* args */);
}

To call funcD with the default functor, I just called

funcD(/* non-functor args */);

Any clue why my code is not performing as well as in the non-functor case?