3

我对编译时循环展开的一般解决方案感兴趣（我在 SIMD 设置中使用它，其中每个函数调用需要特定数量的时钟周期，并且可以并行执行多个调用，所以我需要调整数字累加器以最大程度地减少浪费的周期——添加额外的累加器和手动展开会产生显着的改进，但很费力）。

理想情况下，我希望能够写出类似的东西

unroll<N>(f,args...); // with f a pre-defined function
unroll<N>([](...) { ... },args...); // using a lambda

并生成以下内容：

f(1,args...);
f(2,args...);
...
f(N,args...);

到目前为止，我有三种不同的模板元程序解决方案，我想知道不同方法的优缺点是什么，特别是关于编译器如何内联函数调用。

方法1（递归函数） 

template <int N> struct _int{ };

template <int N, typename F, typename ...Args>
inline void unroll_f(_int<N>, F&& f, Args&&... args) {      
    unroll_f(_int<N-1>(),std::forward<F>(f),std::forward<Args>(args)...);
    f(N,args...);
}
template <typename F, typename ...Args>
inline void unroll_f(_int<1>, F&& f, Args&&... args) {
    f(1,args...);
}

调用语法示例：

int x = 2;
auto mult = [](int n,int x) { std::cout << n*x << " "; };

unroll_f(_int<10>(),mult,x); // also works with anonymous lambda
unroll_f(_int<10>(),mult,2); // same syntax when argument is temporary

方法 2（递归构造函数）

template <int N, typename F, typename ...Args>
struct unroll_c {
    unroll_c(F&& f, Args&&... args) {            
        unroll_c<N-1,F,Args...>(std::forward<F>(f),std::forward<Args>(args)...);
        f(N,args...);
    };
};
template <typename F, typename ...Args>
struct unroll_c<1,F,Args...> {
    unroll_c(F&& f, Args&&... args) {
        f(1,args...);
    };
};

调用语法非常难看：

unroll_c<10,decltype(mult)&,int&>(mult,x); 
unroll_c<10,decltype(mult)&,int&>(mult,2); // doesn't compile

如果使用匿名 lambda，则必须显式指定函数的类型，这很尴尬。

方法3（递归静态成员函数）

template <int N>
struct unroll_s {
    template <typename F, typename ...Args>
    static inline void apply(F&& f, Args&&... args) {
        unroll_s<N-1>::apply(std::forward<F>(f),std::forward<Args>(args)...);        
        f(N,args...);
    }
    // can't use static operator() instead of 'apply'
};
template <>
struct unroll_s<1> {
    template <typename F, typename ...Args>
    static inline void apply(F&& f, Args&&... args) {
        f(1,std::forward<Args>(args)...);
    }
};

调用语法示例：

unroll_s<10>::apply(mult,x);
unroll_s<10>::apply(mult,2);

就语法而言，这第三种方法似乎是最干净和最清晰的，但我想知道编译器如何处理这三种方法是否可能存在差异。

4

1 回答 1

6

首先，编译器往往很清楚何时展开循环。也就是说，我不建议显式展开循环。另一方面，索引可以用作类型映射的索引，在这种情况下，有必要展开事物以生成具有不同类型的版本。

不过，我个人的方法是避免递归，而是通过索引扩展来处理展开。这是一个很好地调用和使用的版本的简单演示。传递参数数量的相同技术可以与您的示例中的递归方法一起使用。我认为这种表示法更可取：

#include <iostream>
#include <utility>
#include <initializer_list>

template <typename T> struct unroll_helper;
template <std::size_t... I>
struct unroll_helper<std::integer_sequence<std::size_t, I...> > {
    template <typename F, typename... Args>
    static void call(F&& fun, Args&&... args) {
        std::initializer_list<int>{(fun(I, args...), 0)...};
    }
};

template <int N, typename F, typename... Args>
void unroll(F&& fun, Args&&... args)
{
    unroll_helper<std::make_index_sequence<N> >::call(std::forward<F>(fun), std::forward<Args>(args)...);
}

void print(int index, int arg) {
    std::cout << "print(" << index << ", " << arg << ")\n";
}

int main()
{
    unroll<3>(&print, 17);
}
于 2015-08-12T00:29:27.283 回答