【学习笔记】builtin函数

前言

看到 $\mathrm{NOI}$ 系列支持 $\text{builtin}$ 函数，喜出望外，赶紧去学了一下。拾来的别人的牙慧。

免责声明：我是看别人说的可以用，一切后果由使用者自行承担。

注意 $\text{builtin}$ 函数的参数都是 $\mathtt{unsigned}\mathtt{int}$ 类型。函数名的末尾加上 $\mathrm{ll}$ 则变为 $\mathtt{unsigned}\mathtt{long}\mathtt{long}$ 类型。

最低二进制位

原意应该是 $\mathrm{find}\mathrm{first}\mathrm{set}$，找到第一个被 $\mathrm{set}$ 为 $1$ 的二进制位。

__builtin_ffs，若参数为 $n$，返回值为 $x$，表示 $2^{x-1}$ 是 $n$ 的最低二进制位。

为了某种统一性，$n=0$ 时的返回值为 $x=0$ 。

性能测试

测试环境为 学校机房的电脑 $Windows10$ 系统 $64$ 位机，配置 $\text{Inter(R) Core(TM) i5-9500T}$ $\text{CPU @ 2.20GHz 2.21 GHz}$ 。

参赛选手是我们最喜欢的查表法（预处理 $2^{16}$ 以内的所有数的结果）和内置函数。

使用 $mt19937$ 随机（两次的种子相同）生成 $32$ 位无符号整形，进行 $10^8$ 次查询，不开 $O2$ 时，查表法约 $2.9$ 秒，内置函数约 $2.4$ 秒；开启 $O2$ 后，即使进行 $10^9$ 次查询，运行速度差异不到 $0.1$ 秒。可见查表法极快，效率差异的原因或许是函数调用。

而使用 $\text{mt19937\_64}$ 生成 $64$ 位无符号整形时，进行 $5\times 10^8$ 次查询，开启 $O2$ 的情况下查表法仍然是以约 $6$ 秒的成绩略落后于内置函数 $5.4$ 秒的成绩。所以有了结论：随机数据下内置函数最快！

当然，事实上二者的差距比较小。我的建议是用内置函数，因为方便。

最高二进制位

这个不能直接查。但是我们可以 $\mathrm{count}\mathrm{leading}\mathrm{zero}$，数前导零！

__builtin_clz，返回前导零的数量。注意它是从第 $32$ 位（毕竟参数是无符号整形）开始数的。

$\text{2022/8/22 update}$：参数为 $0$ 会导致 $\text{runtime error}$，难以置信！$\text{sanitizer}$ 也会提醒你这一点。

另：一位著名选手也有一种快速求最高二进制位的方法，而且是 $\mathcal{O}(1)$ 的，无任何内联函数。虽然跑得更慢就是啦。

二进制位计数

这是最常用的。它听上去很简单，却成了自由发挥想象力的舞台！

下面是瞎讲一通。具体只要记住 $\mathrm{population}\mathrm{count}$，即 __builtin_popcount 就好了。

查表法

一般自己的程序就这么实现——预处理一个 $2^8$ 或者更长的表，按照每 $8$ 位直接查表。

事实上还有一种离谱的写法：利用 宏递归展开，如

# define BIT2(n)       n,       n+1,       n+1,       n+2
# define BIT4(n) BIT2(n), BIT2(n+1), BIT2(n+1), BIT2(n+2)
# define BIT6(n) BIT4(n), BIT4(n+1), BIT4(n+1), BIT4(n+2)
# define BIT8(n) BIT6(n), BIT6(n+1), BIT6(n+1), BIT6(n+2)
static const uint8_t table[256] = {BIT8(0)};

每次考虑最高的 $2$ 个二进制位，剩下的部分递归。

并行计算

从未听说过的技巧，但是极具想象力。考虑到这样一个事实：$2^k>k(k\in \mathbb{N})$，也就是说，任意 $k$ 位二进制数，二进制下 $1$ 的数量可以直接存储到它原来所占用的二进制位里。

那么，类似 $\mathrm{fft}$ 去掉递归的方法，我们从最底层开始，逐步合并。最底层是只考虑 $1$ 个二进制位，那么原本的 $\mathrm{bit}$ 就是二进制下 $1$ 的数量。然后我们合并相邻的两个：

n = ( n & 0x55555555 ) + ( (n >> 1) & 0x55555555 );

也就是将两个相邻的块（此时块长为一）的值加在一起。得到的结果不会超出新的块长的二进制位，所以块长翻倍。此时我们继续

n = ( n & 0x33333333 ) + ( ( n >> 2 ) & 0x33333333 );
n = ( n & 0x0F0F0F0F ) + ( ( n >> 4 ) & 0x0F0F0F0F );
n = ( n & 0x00FF00FF ) + ( ( n >> 8 ) & 0x00FF00FF );
n = ( n & 0x0000FFFF ) + ( ( n >> 16 ) & 0x000FFFF );

就能得到最终结果了！真是富有创造力！

一级优化

观察到最后一步等价于 $n=(n\mathrm{mod}{2}^{16})+\frac{n}{2^{16}}$，考虑将其转化为 $n\mathrm{mod}(2^{16}-1)$ 。显然二者是相等的，因为结果不超过 $32$，模 $2^{16}-1=65535$ 也没什么问题。

二级优化

仍然运用上面的思考，$n\mathrm{mod}(2^k-1)$ 在 $2^k-1>32$ 时等价于 $k$ 位为一组的二进制值相加。显然应当取 $k=6$，如何实现呢？

第一步要解决长度为 $3$ 的分组。事实上我们可以使用 $n-{\sum }_{i=1}^{+\infty }\lfloor \frac{n}{2^i}\rfloor$ 得到任意数的二进制位 $1$ 的个数，因为 $2^k-2^{k-1}-\cdots -2^0=1$，就恰好会贡献 $1$ 。

那么第一步无非是

n = n - ( (n >> 1) & 033333333333 ) - ( (n >> 2) & 011111111111 );

由于是 $3$ 位为一组，采用了更容易理解的八进制数字常量。然后接下来，并行计算与取模，放在一起即可。

return ( ( n + ( n >> 3 ) ) & 030707070707 ) % 63;

分支预测

__builtin_expect(exp,c) 表示表达式 $exp$ 的结果更可能是 c ∈ { 0 , 1 } c\in\{0,1\} c∈{0,1}，一般常用于 $\mathrm{if}$ 语句的判断。例如

if(__builtin_expect(zxy == sister, true))
	puts("I've already know that it's definitely right!");

则编译器认为，这个 $\mathrm{if}$ 语句很可能会成立，那么在汇编中就成了：如果该语句不成立，跳过 $\mathrm{if}$ 内的语句块。由于该 $\mathrm{if}$ 很可能成立，所以跳转的次数就会很少。习得卡常新技巧！