使用模板和/或constexpr在编译时构建函数

Question

该代码是在即时更改名称约定的情况下编写的，如果造成混乱，我们深表歉意。 我将在这里重写问题以使其更清楚。

在编译时已知一些数据，两个整数数组D和E长度均为L D每个元素为零或一。 E每个元素都包含[0,L]中的值。

然后，我得到了一个在运行时已知的向量X ，它的长度也为L

我想构建一个使用D ， E和X计算某个值的函数，例如：

int comp_rt(int i, array<int, L> X) {
    int v = 0;
    if (D[i] == 0) // D[i] known at compile-time
        return 10;
    for (int j = 0; j < E[i]; ++j) // E[i] known at compile-time
        v += X[j] * (j + 1); // X[j] known at run-time
    return v;
}

由于此计算执行了很多次，因此我想减少开销，并且我认为在编译时对D和E进行检查和循环会很棒。

通常，为了使其更快，而不是使用comp_rt函数（这是通常的情况），我将编写模板专用函数，对于每个i ，它们只会进行数学运算。 例如：

N = 5
D = [0, 1, 1, 0, 1] // Values in {0, 1}
E = [1, 0, 3, 2, 4] // Values in [0, L-1]
X = [1, 3, 5, 7, 9] // Any integer

template <int i> int comp(array<int, L> X);
template <> int comp_tpl<0>(array<int, L> X) { return 10; } // D[0] == 0
template <> int comp_tpl<1>(array<int, L> X) { return 0; } // E[1] == 0, skip loop
template <> int comp_tpl<2>(array<int, L> X) { return X[0] + 2 * X[1] + 3 * X[2]; }
template <> int comp_tpl<3>(array<int, L> X) { return 10; }
template <> int comp_tpl<4>(array<int, L> X) { return compl_tpl<2>(X) + 4 * X[3]; }

我的问题是：是否可以在编译时使用D和E使用模板和/或常量表达式来构建函数，但执行速度与comp_tpl一样快？ 我的意思是构建一些东西，“构建要在运行时计算的表达式”，并且仅将涉及X计算留给运行时。

并且，如果可能，如何完成？ 可以使用哪些通用原理来解决此类问题？

我尝试使用模板来执行此操作，但是生成的代码不如comp_tpl快。我认为有些递归调用在运行时进行评估。

Answer 1

编辑 ：根据有问题的说明进行了更新：
Edit2 ：删除了Conditional 语句 。

这样就可以计算出总和。 它是尾递归^* ：

template<class T, size_t Length> struct Sum {
    template<class Array>
    static T comp(const Array &x, T add = 0) {
        return Sum<T, Length - 1>::comp(x, add + Length * x[Length - 1]);
    }
};

template<class T> struct Sum<T, 0> {
    template<class Array>
    static T comp(const Array &x, T add = 0) {
        return add;
    }
};

这是将其拉在一起并取决于d和e 。 您可能可以对它们进行参数化，但是我认为这比值得的麻烦更多。

constexpr int d[] = { 0, 1, 1, 0, 1 };
constexpr int e[] = { 1, 0, 3, 2, 4 };

template<int N> struct Comp {
    template<class Array>
    static int comp(const Array &x) {
        return d[N] ? Sum<int, e[N]>::comp(x) : 10;
    }
};

用法：

int x[] = { 1, 3, 5, 7, 9 };
Comp<3>::comp(x);

http://ideone.com/PmFBhU

（*）并不是真的，但是足够接近。

Answer 2

（更新：最后讨论了使用clang ++和g ++的计时实验。此外，为简单起见，我在问题中使用了comp_rt的确切主体，这表明它可以完全优化，而无需我们重写函数的主体。）

是的，可以这样做。 但是，g ++似乎在不知不觉中为您做了大量的工作，请参阅最后的实验。 但是，使用clang ++，您确实可以看到运行时版本变慢。

在下面的程序中，除X之外的所有参数都作为模板args传递。 因此，将为您使用的每种参数组合构建一个不同的comp_rt模板函数。 如果L大，这可能会导致二进制文件变大。

起初 D[i]==0难以理解 D[i]==0 。 我将其放置在 enable_if 。 这里有 comp_tpl两种定义，一种在 D[i]==0时使用，而在 D[i]==1 。 老实说，这可能是不必要的，我怀疑即使您只是在单个 comp_rt函数模板中使用了函数的原始主体，代码仍将以最佳方式进行编译。 （我已经消除了这种复杂性）。

我在函数中加入了这样的一行：

    using confirm_Ei_is_known_at_compile_time = array<char,E[i]>;

这确认了编译器在编译时就知道E[i] 。 这等效于typedef，并且必须在编译时知道array中元素的数量。 例如，如果您尝试使用X[i]而不是E[i]作为array的大小，则编译器将拒绝该代码。 注意：此行不执行任何操作，只是在编译时进行完整性检查。

最后，假定E[i]在编译时是已知的，则编译器可以展开循环（如果以其自身的智慧，认为可以加快循环速度）。 确保打开所有优化-gcc有一个选项-funroll-all-loops 。

通过将相关参数作为模板参数传递，编译器可以进行更多优化。 但是我不确定它会选择这样做！ 需要进行实验。

---

这是我用于计时实验的完整程序。

#include<array>
#include<iostream>
using namespace std;

/*
 * L is a positive integer
 * D is vector of booleans of length L
 * E is a vector of ints [0,L) of length L
 * i will be in [0,L) also, therefore it is small enough that we can
 *         treat it as if it's known at compile time also
 *
 * The only thing that is *not* known at compile time is:
 * X is a vector of ints of length L
 *
 * Therefore, our goal is something like:
 *
 *   template<int L, int i, int D[L], int E[L]>
 *   int compute(int X[L]);
 */

template<int L, int i, const bool (&D)[L], const int (&E)[L]> // arrays passed, by reference, at compile-time
typename enable_if< D[i]==0 , int> :: type
comp_tpl(int (&)[L]) {
        return 10;
}
template<int L, int i, const bool (&D)[L], const int (&E)[L]> // arrays passed, by reference, at compile-time
typename enable_if< D[i]==1 , int> :: type
comp_tpl(int (&X)[L]) {
    int v = 0;
    //using confirm_Ei_is_known_at_compile_time = array<char,E[i]>;
    for (int j = 0; j < E[i]; ++j) // E[i] known at compile-time
        v += X[j] * (j + 1); // X[j] known at run-time
    return v;
}

template<int L, int i, const bool (&D)[L], const int (&E)[L]> // arrays passed, by reference, at compile-time
int
comp_tpl_simple(int (&X)[L]) {
    if (D[i] == 0) // D[i] known at compile-time
        return 10;
    int v = 0;
    using confirm_Ei_is_known_at_compile_time = array<char,E[i]>;
    for (int j = 0; j < E[i]; ++j) // E[i] known at compile-time
        v += X[j] * (j + 1); // X[j] known at run-time
    return v;
}

template<int L> // arrays passed, by reference, at compile-time
int
comp_rt(int i, const bool (&D)[L], const int (&E)[L], int (&X)[L]) {
    if (D[i] == 0) // D[i] known at compile-time
        return 10;
    int v = 0;
    for (int j = 0; j < E[i]; ++j) // E[i] known at compile-time
        v += X[j] * (j + 1); // X[j] known at run-time
    return v;
}


constexpr int L = 5;
extern constexpr bool D[L] {0, 1, 1, 0, 1};  // Values in {0, 1}
extern constexpr int  E[L] {1, 0, 3, 2, 4}; // Values in [0, L-1]

void change_X_arbitrarily(int (&X)[L]) {
    for(int j=0; j<L; ++j)
        ++X[j];
}

int main() {
    int X[L] {1, 3, 5, 7, 9}; // Any integer

#ifdef USE_RUNTIME
    #define comp(L,i,D,E,X) comp_rt<L>(i,D,E,X)
#endif
#ifdef USE_TEMPLATE
    #define comp(L,i,D,E,X) comp_tpl_simple<L,i,D,E>(X)
#endif

    int total=0;
    for(int outer_reps=0; outer_reps<10000; ++outer_reps) {
        for(int inner_reps=0; inner_reps<100000; ++inner_reps) {
            total += comp(L,0,D,E,X);
            total += comp(L,1,D,E,X);
            total += comp(L,2,D,E,X);
            total += comp(L,3,D,E,X);
            total += comp(L,4,D,E,X);
        }
        change_X_arbitrarily(X);
    }

    cout << total << endl; // should be 39798784
}

请注意我如何使用#define选择要使用的功能。 我编译并运行：

$ clang++ SO.cpp -std=gnu++0x -O3 -DUSE_TEMPLATE -o SO && time -p ./SO
39798784  // the total value from all the calls, as a check
real 0.00
user 0.00
sys 0.00

计算1,000,000,000次需要零秒！ 但是运行时版本需要2.7秒

$ clang++ SO.cpp -std=gnu++0x -O3 -DUSE_RUNTIME -o SO && time -p ./SO
39798784  // the total value from all the calls, as a check
real 2.70
user 2.68
sys 0.00

我在那里使用了clang3.3和-O3 。

使用g ++ 4.8.2时，我会收到有关-O3的不确定行为的警告，但奇怪的是，无论是运行时版本还是模板版本，运行时均为零秒！ 也许即使在“运行时”模式下，g ++仍在为我们启用编译时的技巧。 这里的教训是，编译器确实比我们更了解优化！

无论如何，如果我退回到g++-4.8.2 -O2那么两种情况下的运行时间都是6.8秒。 很奇怪！ 有时添加更多的O会使它变慢！

一个解释：在这种情况下， X实际上在编译时是已知的。 它是此代码中的局部变量，并且会确定性地进行更新，因此编译器能够完全预测它并在编译时计算答案！ 看来g ++正在这样做（非常令人印象深刻！）。 因此，在我的最新实验中，我将X从main移到了全局变量之外，现在优化的行为“符合预期”。 comp_tpl始终比现在的comp_rt快得多。

Answer 3

（很抱歉添加另一个答案）

（我将示例代码放在最后）

我的实验和进一步的思考使我确信，只需进行很小的修改就可以使用原始代码。 编译器非常擅长进行优化，以至于我发现有时很难放慢速度！ 仅通过将X标记为volatile，或使用rand()随机数据不断对其进行编辑，才能真正使“运行时”版本变慢。

首先，如果只有一个D向量和一个E向量，则只需将constexpr放在数组声明的前面。

constexpr int D[] = { 0, 1, 1, 0, 1 };
constexpr int E[] = { 1, 0, 3, 2, 4 };

（如果您有多个这样的向量，并且您想为每个向量准备“部分编译前”的函数，我们可以通过模板参数传递它们，如我的其他答案）。

我们还需要处理原始函数中的i索引： int comp_rt(int i, array<int, L> X); 。 它应该是模板参数：

template<size_t i>
int comp_rt(array<int, L> X);

该函数的主体不需要更改。 现在，编译器知道i ， D[i]和E[i]是常量表达式。 涉及D[i]和E[i]的表达式被其常量值替换。 在编译时， if (true) ，将测试if(D[i]==0)替换为if (true)或if (false) 。 同样，循环将被展开，因为编译器确切地知道E[i]的值。 展开了循环，编译器可以看到v只是一个长整数。 在这种情况下，它将用显式总和替换，删除所有零项，并加总所有常数项，依此类推。 所有这些都在编译时完成。 在这里，我们几乎无能为力帮助编译器。 这等效于可以使用的一些更复杂的模板解决方案。

将g ++和clang ++与-O2和-O3一起使用。

在我的一些实验中，无论我需要进行多少次迭代， gcc的程序都在零秒内运行。 这是因为算法是确定性的，并且gcc可以预先计算X会发生的所有事情（即使我定期更改X！）。 在那种情况下，部分问题是我将X为局部变量，但教训是编译器可以看到确定性程序并预先计算所有内容，即使您不希望这样做！ clang似乎在这里没有积极地优化。

如果您有一些比您希望的慢的代码，并且可以将完整的代码组合在一起来演示该慢速代码，那么也许我们可以建议其他小的更改。 但是我相信在数据上简单使用constexpr以及i的模板参数将可以解决问题。

---

在此示例代码中，我进行了另一处更改。 我间接使用tuple_size<array<char, D[i]> > :: value而不是简单地使用D_i ，这并没有真正改变含义，但是我认为这会鼓励较早的编译器在编译时进行评估。 我的目标是尽可能地使代码的原始可读性匹配，例如将整个功能放在一个位置，而不是将其分成多个模板。

constexpr int L   = 5;
constexpr int D[] = { 0, 1, 1, 0, 1 };
constexpr int E[] = { 1, 0, 3, 2, 4 };
template<int i>
int comp_rt(array<int, L> X) {
    using D_i_type = array<char, D[i]>;
    int v = 0;
    if (tuple_size<D_i_type>::value == 0) // D[i] known at compile-time
        return 10;
    using E_i_type = array<char, E[i]>;
    for (int j = 0; j < tuple_size<E_i_type>::value; ++j) { // E[i] known at compile-time
        v += X[j] * (j + 1); // X[j] known at run-time
    }
    return v;
}

Answer 4

使用constexpr函数，可以在编译时完成

#include <iostream>
#include <array>
#include <utility>

#include <cstddef>
#include <type_traits>

  /// A type that represents a parameter pack of zero or more integers.
  template<typename T, T... I>
    struct integer_sequence
    {
      static_assert( std::is_integral<T>::value, "Integral type" );

      using type = T;

      static constexpr T size = sizeof...(I);

      /// Generate an integer_sequence with an additional element.
      template<T N>
        using append = integer_sequence<T, I..., N>;

      using next = append<size>;
    };

  template<typename T, T... I>
    constexpr T integer_sequence<T, I...>::size;

  template<std::size_t... I>
    using index_sequence = integer_sequence<std::size_t, I...>;

  namespace detail
  {
    // Metafunction that generates an integer_sequence of T containing [0, N)
    template<typename T, T Nt, std::size_t N>
      struct iota
      {
        static_assert( Nt >= 0, "N cannot be negative" );

        using type = typename iota<T, Nt-1, N-1>::type::next;
      };

    // Terminal case of the recursive metafunction.
    template<typename T, T Nt>
      struct iota<T, Nt, 0ul>
      {
        using type = integer_sequence<T>;
      };
  }


  // make_integer_sequence<T, N> is an alias for integer_sequence<T, 0,...N-1>
  template<typename T, T N>
    using make_integer_sequence = typename detail::iota<T, N, N>::type;

  template<int N>
    using make_index_sequence = make_integer_sequence<std::size_t, N>;


  // index_sequence_for<A, B, C> is an alias for index_sequence<0, 1, 2>
  template<typename... Args>
    using index_sequence_for = make_index_sequence<sizeof...(Args)>;
//--------------------My part starts here-------------------------------------------------------
template <size_t N> constexpr int computebis(int bound,std::array<int,N> X,int j)
{
  return (j<bound) ? X[j]*(j+1) + computebis(bound,X,j+1) : 0;
}

template <size_t N> constexpr int compute2(std::array<int,N> D,
                                            std::array<int,N> E,
                                            std::array<int,N> X,int index)
{
  return (D[index]==0) ? 10 : computebis(E[index],X,0);
}


template <size_t N,std::size_t... Indices> constexpr std::array<int,N> mfill(std::array<int,N> D,
                                                                            std::array<int,N> E,
                                                                            std::array<int,N> X,
                                                                            index_sequence<Indices...>)
{
  return {{ compute2(D,E,X,Indices)... }};
}

template <size_t N> constexpr std::array<int,N> mfill(std::array<int,N> D,std::array<int,N> E,std::array<int,N> X)
{
  return mfill(D,E,X,make_index_sequence<N>{});
}


int main(int argc, char *argv[])
{

  std::array<int,5> D= {0,1,1,0,1};
  std::array<int,5> E= {1,0,3,2,4};
  std::array<int,5> X= {1,3,5,7,9};
  //to be sure that it is done at compil time
  const auto X2 =  mfill(D,E,X);

  for(auto e:X2){
    std::cout<<e<<std::endl;
  }

编辑：代码更新受C ++ 11中创建N元素constexpr数组的启发，我在那里做了所有第一部分