#include <functional>
#include <iostream>
#include <source_location>
#include <type_traits>
#include <utility>

void loc(std::source_location l = std::source_location::current())
{
    std::cout << l.file_name() << ':' << l.line() << ' ' << l.function_name() << "\n";
}

void function() { loc(); }
auto lambda = [] { loc(); };
struct functor_type { void operator()() { loc(); } };
struct struct_type { void method() { loc(); } };

template<typename Callable, typename... Args>
decltype(auto) apply_test(Callable &&c, Args &&...args)
{
    std::decay_t<Callable> callable = std::forward<Callable>(c);
    std::tuple<Args...> arguments = {std::forward<Args>(args)...};
    return std::apply(callable, arguments);
}

template <typename Callable, typename... Args>
decltype(auto) function_test(Callable &&c, Args &&...args)
{
    using result_type = std::invoke_result_t<Callable, Args...>;
    std::function<result_type(Args...)> function = std::forward<Callable>(c);
    return function(std::forward<Args>(args)...);
}

template<typename Callable, typename... Args>
std::invoke_result_t<Callable, Args...> invoke_test(Callable &&c, Args &&...args)
{
    return std::invoke(std::forward<Callable>(c), std::forward<Args>(args)...);
}

template<typename Callable, typename... Args>
void test_by_code(Callable &&c, Args &&...args)
{
    asm volatile("mfence" : : : "memory");
    apply_test(c, args...);
    asm volatile("mfence" : : : "memory");
    function_test(c, args...);
    asm volatile("mfence" : : : "memory");
    invoke_test(c, args...);
    asm volatile("mfence" : : : "memory");
}

int main()
{
    test_by_code(function);
    test_by_code(lambda);
    test_by_code(functor_type{});
    test_by_code(&struct_type::method, struct_type{});
}