如何让编译器优化全相同函数的分发表，消除动态分发？

问题背景 #

现有如下通用分发表实现代码：

#include <utility>

template <class D, std::size_t... I> auto dispatch(std::size_t i, std::index_sequence<I...>) {
    using F = decltype(&D::template dispatch<0>);
    static constexpr F table[sizeof...(I)] = {&D::template dispatch<I>...};
    return table[i]();
}
template <class D, std::size_t MAX_SIZE> auto dispatch(std::size_t i) {
    return dispatch<D>(i, std::make_index_sequence<MAX_SIZE>());
}

struct Dispatcher {
    template <std::size_t I> static auto dispatch() {
        return 42;
    }
};

auto foo(std::size_t i) {
    constexpr std::size_t MAX_SIZE = 10;
    if (i < MAX_SIZE) {
        return dispatch<Dispatcher, MAX_SIZE>(i);
    }
    return 0;
}

在GCC 14.1、Clang 18.1的-O3优化级别下，编译器会生成10个完全相同的Dispatcher::dispatch<I>()实例，并通过分发表执行动态分发。但实际场景中，当分发表内所有函数逻辑完全一致时，希望编译器能跳过动态分发直接返回结果；仅当函数逻辑存在差异时，才保留分发表与动态分发逻辑。

解决方案 #

编译期显式判断函数同一性 #

通过编译期检查所有分发函数的地址是否一致，实现分支优化：

#include <utility>
#include <array>

// 编译期检查所有D::dispatch<I>的地址是否相同
template <class D, std::size_t... I>
constexpr bool all_dispatch_same(std::index_sequence<I...>) {
    using F = decltype(&D::template dispatch<0>);
    const std::array<F, sizeof...(I)> funcs = {&D::template dispatch<I>...};
    for (std::size_t j = 1; j < funcs.size(); ++j) {
        if (funcs[j] != funcs[0]) {
            return false;
        }
    }
    return true;
}

// 所有函数相同时的分支：直接调用第一个函数
template <class D, std::size_t... I>
auto dispatch_impl(std::size_t, std::index_sequence<I...>, std::true_type) {
    return D::template dispatch<0>();
}

// 函数不同时的分支：保留原分发表逻辑
template <class D, std::size_t... I>
auto dispatch_impl(std::size_t i, std::index_sequence<I...>, std::false_type) {
    using F = decltype(&D::template dispatch<0>);
    static constexpr F table[sizeof...(I)] = {&D::template dispatch<I>...};
    return table[i]();
}

// 对外接口：根据编译期判断结果选择分支
template <class D, std::size_t MAX_SIZE>
auto dispatch(std::size_t i) {
    constexpr bool all_same = all_dispatch_same<D>(std::make_index_sequence<MAX_SIZE>());
    return dispatch_impl<D>(i, std::make_index_sequence<MAX_SIZE>(), std::bool_constant<all_same>());
}

// 测试用Dispatcher
struct Dispatcher {
    template <std::size_t I>
    static auto dispatch() {
        return 42;
    }
};

// 调用示例
auto foo(std::size_t i) {
    constexpr std::size_t MAX_SIZE = 10;
    if (i < MAX_SIZE) {
        return dispatch<Dispatcher, MAX_SIZE>(i);
    }
    return 0;
}

原理说明 #

1. all_dispatch_same在编译期遍历所有D::dispatch<I>的函数地址，判断是否全部一致；
2. 利用std::bool_constant<all_same>触发编译期分支：
   • 当所有函数地址相同时，直接调用任意一个实例（这里选dispatch<0>），完全消除动态分发；
   • 当函数地址存在差异时，保留原分发表逻辑，正常执行动态分发。

效果验证 #

修改后的代码在-O3优化下，GCC和Clang都会对foo函数生成极简代码：当i<10时直接返回42，不会生成分发表和冗余的函数实例；只有当Dispatcher::dispatch<I>的实现随I变化时，编译器才会生成分发表并保留动态分发逻辑。

内容的提问来源于stack exchange，提问作者eyelash