c++ 编译时断言

Question

我正在使用一个可能很危险的宏：

#define REMAINDER(v, size) ((v) & (size -1))

显然它假定大小是 2 的幂。

我想确保 size 确实是 2 的幂，但在编译时。 （运行时测试很简单，但不是我想要的）。

对我来说，一个充分的测试是 size 始终是一个常数（绝不是变量）。

我会使用BOOST_STATIC_ASSERT，但我不知道如何使用它来满足我的需要。

Answer 1

首先要做的是：不需要微优化。当b 是一个实际上是2 次幂的编译时间常数时，任何启用了优化的体面的编译器都会将a % b 转换为该结构。

然后在特定的断言上，您可以使用相同的构造来断言它[*]：

BOOST_STATIC_ASSERT( !(size & (size-1)) );

[*] 请注意，正如 Matthieu M 指出的那样，这仅在 size 是无符号类型时才有效。这应该被断言——在编译时不能断言参数为非负的较小要求：

BOOST_STATIC_ASSERT( (X(0)-1) > X(0) ); // where X is the type of the argument

最后评论后编辑：

你在这里错过了重点。要使静态断言宏起作用，size 必须是编译时间常数。如果它是一个编译时常量，那么只需在定义常量时断言，这也是最好的地方，因为它将用作文档，并将指向需要修改的代码的精确点：

template <typename N>
class hash_map {
public:
   const std::size_t size = N;
   BOOST_STATIC_ASSERT( !(size & (size-1) ) ); // N must be power of 2 for fast %
   //...
};

同时断言在编译时保持不变量对效率很重要，但隐藏代码并不是：只需将模运算留在原处，因为编译器会优化：

std::size_t hash_map::index_of( std::size_t hash ) const {
   return hash % size;
}

因为size 是一个编译时间常数，它是2 的幂（你之前断言过）优化器会将% 转换为优化的操作，而代码仍然可供需要维护的人阅读它。

Answer 2

编辑：除非您有分析证明这是您的代码中的瓶颈，并且您的编译器没有适当地优化 (v % 8) 之类的东西，否则只需编写明显的代码。

否则，既然您在这里处理整数，您可以使用模板而不是宏吗？然后你应该能够在模板中进行静态断言，以便在错误实例化时进行标记。

例如：

template <int size>
int remainder(int v)
{
    BOOST_STATIC_ASSERT(!(size & (size - 1)));

    return v & (size -1);
};

Answer 3

断言：

size && (size & (size - 1) == 0)

编辑：解释。

如果 size 是 2 的幂，则只设置一位。减去 1 将产生一个值，其中设置了原始位之前的所有位。对这些进行与运算得到 0。

如果大小不是 2 的幂，则至少设置两个位。减去 1 将产生一个值，其中设置了原始最低设置位之前的所有位。对这些进行与运算不会产生 0，因为仍然设置了第二个和后面的（从右起）位。

1000 & 0111 == 0000
1100 & 1011 == 1000

Answer 4

// Only use this if size is a power of 2
#define REMAINDER(v, size) ((v) & (size -1))

不要像白痴一样对待您的用户。记录您的函数和宏，然后继续。

---

或者，如果您真的必须哄人，请使用模板：

template <size_t SIZE>
size_t remainder(size_t v) {
   // Perform whatever assertions you like on SIZE here

   return v & (SIZE - 1);
}

请注意，我必须对输入和输出的类型做出一些假设。

Answer 5

Peephole Optimization：在非常小的指令集上执行优化

这包括：

• Constant Folding：例如，如果size 为常量，则此处的size - 1 将在编译期间进行评估
• Strength Reduction: 包括用较快的操作替换慢速操作...当结果相等时（显然）

现在，让我们看一个使用 LLVM backend optimizer 的示例：

// C
int iremainder(int i) { return i % 4; }

unsigned uremainder(unsigned u) { return u % 4; }

// LLVM IR
define i32 @iremainder(i32 %i) nounwind readnone {
entry:
  %0 = srem i32 %i, 4                             ; <i32> [#uses=1]
  ret i32 %0
}

define i32 @uremainder(i32 %u) nounwind readnone {
entry:
  %0 = and i32 %u, 3                              ; <i32> [#uses=1]
  ret i32 %0
}

我们来分析一下好吗？

• u / 4 产生 and i32 %u, 3（在 C 中翻译回 u & 3）
• i / 4 产生 srem i32 %i, 4（在 C 中翻译回 i % 4）

多么智能编译器！它没有忘记对有符号整数执行按位运算不会产生我想要的结果（只要整数为负，并且分支比除法更昂贵）。

士气：这种优化几乎没用，你甚至弄错了。