一般来说，对于 BigInteger 来说这是一种糟糕的格式，请参阅https://codereview.stackexchange.com/a/237764对 BigInteger 每字节使用一位十进制数字的设计缺陷进行代码审查，以及您可以/应该做什么。
And see 长整数例程可以从 SSE 中受益吗？@Mysticial 关于存储数据的方法的注释，这些数据使 SIMD for BigInteger 数学变得实用，特别是部分字算术，其中您的临时变量可能不会“标准化”，让您可以进行惰性进位处理。
但显然你只是问this代码，随机初始化和打印函数，而不是如何在这种格式的两个数字之间进行数学运算。
我们可以很好地对这两者进行矢量化。我的LongNumPrintName()是您的直接替代品。
For LongNumInit我只是展示一个存储两个 32 字节块并返回一个递增指针的构建块。循环调用它。 （每次调用它自然会生成 2 个向量，因此对于较小的 N，您可以制作一个替代版本。）
LongNumInit
生成包含随机数字的 1 GB 文本文件的最快方法是什么？在 4GHz Skylake 上以大约 33 GB/s 的速度生成空格分隔的随机 ASCII 十进制数字，包括write()系统调用/dev/null。 （这高于 DRAM 带宽；128kiB 的缓存阻塞让存储命中 L2 缓存。内核驱动程序/dev/null甚至不读取用户空间缓冲区。）
它可以很容易地改编成 AVX2 版本void LongNumInit(uint8_t *L, size_t N )。我的答案是使用 AVX2 xorshift128+ PRNG（在 64 位元素中使用 4 个独立的 PRNG 进行矢量化）__m256i) like xorshift128+ 的 AVX/SSE 版本。这应该与你的随机性质量相似rand() % 10.
它通过乘法逆元将其分解为十进制数字，并通过移位和模除以 10vpmulhuw, using 为什么GCC在实现整数除法时使用乘以奇怪的数字？。 （实际上使用 GNU C 本机向量语法让 GCC 确定魔术常数并发出乘法和移位以方便语法，例如v16u dig1 = v % ten; and v /= ten;)
您可以使用_mm256_packus_epi16将两个 16 位数字向量打包成 8 位元素，而不是将奇数元素转换为 ASCII' '将偶数元素转换为 ASCII'0'..'9'。 （所以改变vec_store_digit_and_space用常量打包向量对而不是 O'Ring，见下文）
使用 gcc、clang 或 ICC（或者希望任何其他能够理解 C99 的 GNU C 方言和 Intel 内在函数的编译器）来编译它。
See https://gcc.gnu.org/onlinedocs/gcc/Vector-Extensions.html为了__attribute__((vector_size(32)))部分，以及https://software.intel.com/sites/landingpage/IntrinsicsGuide/为了_mm256_*东西。还https://stackoverflow.com/tags/sse/info.
#include <immintrin.h>
// GNU C native vectors let us get the compiler to do stuff like %10 each element
typedef unsigned short v16u __attribute__((vector_size(32)));
// returns p + size of stores. Caller should use outpos = f(vec, outpos)
// p must be aligned
__m256i* vec_store_digits(__m256i vec, __m256i *restrict p)
{
v16u v = (v16u)vec;
v16u ten = (v16u)_mm256_set1_epi16(10);
v16u divisor = (v16u)_mm256_set1_epi16(6554); // ceil((2^16-1) / 10.0)
v16u div6554 = v / divisor; // Basically the entropy from the upper two decimal digits: 0..65.
// Probably some correlation with the modulo-based values, especially dig3, but we do this instead of
// dig4 for more ILP and fewer instructions total.
v16u dig1 = v % ten;
v /= ten;
v16u dig2 = v % ten;
v /= ten;
v16u dig3 = v % ten;
// dig4 would overlap much of the randomness that div6554 gets
// __m256i or v16u assignment is an aligned store
v16u *vecbuf = (v16u*)p;
// pack 16->8 bits.
vecbuf[0] = _mm256_packus_epi16(div6554, dig1);
vecbuf[1] = _mm256_packus_epi16(dig2, dig3)
return p + 2; // always a constant number of full vectors
}
逻辑在random_decimal_fill_buffer插入换行符的操作可以完全删除，因为您只需要一个由十进制数字组成的平面数组。只需循环调用上述函数，直到填满缓冲区。
处理小尺寸（小于完整向量）：
将 malloc 填充到下一个 32 字节的倍数会很方便，因此执行 32 字节加载始终是安全的，而无需检查是否可能跨越到未映射的页面。
并使用C11aligned_alloc获得 32 字节对齐的存储。例如，aligned_alloc(32, (size+31) & -32)。即使 N 是奇数，这也让我们可以进行完整的 32 字节存储。从逻辑上讲，只有缓冲区的前 N 个字节保存了我们的真实数据，但是我们可以方便地进行填充，以避免对 N 小于 32 或不是 32 的倍数进行任何额外的条件检查。
不幸的是 ISO C 和 glibc 丢失了aligned_realloc and aligned_calloc。 MSVC 实际上提供了这些：为什么大多数平台上没有“aligned_realloc”？允许您有时在对齐缓冲区的末尾分配更多空间而不复制它。 “try_realloc”对于 C++ 来说是理想的选择，如果不可复制的对象更改地址，则可能需要运行复制构造函数。非表达性的分配器 API 会强制执行有时不必要的复制，这是我最讨厌的事情。
LongNumPrint
采取uint8_t *Namearg 是糟糕的设计。如果调用者想要 printf a"something:"先串起来，他们可以做到。你的函数应该做什么printf "%d"确实对于一个int.
由于您以相反的打印顺序存储数字，因此您需要将字节反转到 tmp 缓冲区并将 0..9 字节值转换为'0'..'9'通过 ORing 得到的 ASCII 字符值'0'。然后将该缓冲区传递给fwrite.
具体来说，使用alignas(32) char tmpbuf[8192];作为局部变量。
您可以使用固定大小的块（例如 1kiB 或 8kiB），而不是分配可能巨大的缓冲区。您可能仍然想通过 stdio （而不是write()直接管理您自己的 I/O 缓冲）。具有 8kiB 缓冲区，高效fwrite可能只是将其传递给write()直接而不是 memcpy 到 stdio 缓冲区中。您可能想尝试对此进行调整，但保持 tmp 缓冲区小于 L1d 缓存的一半将意味着在写入后重新读取它时，它在缓存中仍然很热。
缓存阻塞使循环边界变得更加复杂，但对于非常大的 N 来说这是值得的。
一次反转 32 个字节:
您可以通过决定您的数字以 MSD 优先顺序存储来避免这项工作，但如果您确实想实现加法，则必须从末尾向后循环。
您的功能可以用 SIMD 实现_mm_shuffle_epi8反转 16 字节块，从数字数组的末尾开始写入 tmp 缓冲区的开头。
或者更好，加载vmovdqu / vinserti12816 字节负载供给_mm256_shuffle_epi8在通道内进行字节反转，设置 32 字节存储。
在英特尔 CPU 上，vinserti128解码为加载+ALU uop，但它可以在任何向量 ALU 端口上运行，而不仅仅是 shuffle 端口。因此两个 128 位加载比 256 位加载更高效 ->vpshufb - > vpermq如果缓存中的数据很热，这可能会成为洗牌端口吞吐量的瓶颈。 Intel CPU 每个时钟周期最多可以执行 2 次加载 + 1 次存储（或者在 IceLake 中，2 次加载 + 2 次存储）。如果没有内存瓶颈，我们可能会在前端遇到瓶颈，因此实际上不会使加载+存储和洗牌端口饱和。 (https://agner.org/optimize/ and https://uops.info/)
这个函数也被简化了，假设我们总是可以读取 32 个字节L不会进入未映射的页面。但是，在对小 N 进行 32 字节反转之后，输入的前 N 个字节将成为 32 字节块中的最后 N 个字节。如果我们总是能够安全地进行 32 字节加载，那将是最方便的ending在缓冲区的末尾，但期望在对象之前进行填充是不合理的。
#include <immintrin.h>
#include <stdalign.h>
#include <stddef.h>
#include <stdio.h>
#include <stdint.h>
// one vector of 32 bytes of digits, reversed and converted to ASCII
static inline
void ASCIIrev32B(void *dst, const void *src)
{
__m128i hi = _mm_loadu_si128(1 + (const __m128i*)src); // unaligned loads
__m128i lo = _mm_loadu_si128(src);
__m256i v = _mm256_set_m128i(lo, hi); // reverse 128-bit hi/lo halves
// compilers will hoist constants out of inline functions
__m128i byterev_lane = _mm_set_epi8(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15);
__m256i byterev = _mm256_broadcastsi128_si256(byterev_lane); // same in each lane
v = _mm256_shuffle_epi8(v, byterev); // in-lane reverse
v = _mm256_or_si256(v, _mm256_set1_epi8('0')); // digits to ASCII
_mm256_storeu_si256(dst, v); // Will usually be aligned in practice.
}
// Tested for N=32; could be bugs in the loop bounds for other N
// returns bytes written, like fwrite: N means no error, 0 means error in all fwrites
size_t LongNumPrint( uint8_t *num, size_t N)
{
// caller can print a name if it wants
const int revbufsize = 8192; // 8kiB on the stack should be fine
alignas(32) char revbuf[revbufsize];
if (N<32) {
// TODO: maybe use a smaller revbuf for this case to avoid touching new stack pages
ASCIIrev32B(revbuf, num); // the data we want is at the *end* of a 32-byte reverse
return fwrite(revbuf+32-N, 1, N, stdout);
}
size_t bytes_written = 0;
const uint8_t *inp = num+N; // start with last 32 bytes of num[]
do {
size_t chunksize = (inp - num >= revbufsize) ? revbufsize : inp - num;
const uint8_t *inp_stop = inp - chunksize + 32; // leave one full vector for the end
uint8_t *outp = revbuf;
while (inp > inp_stop) { // may run 0 times
inp -= 32;
ASCIIrev32B(outp, inp);
outp += 32;
}
// reverse first (lowest address) 32 bytes of this chunk of num
// into last 32 bytes of this chunk of revbuf
// if chunksize%32 != 0 this will overlap, which is fine.
ASCIIrev32B(revbuf + chunksize - 32, inp_stop - 32);
bytes_written += fwrite(revbuf, 1, chunksize, stdout);
inp = inp_stop - 32;
} while ( inp > num );
return bytes_written;
// caller can putchar('\n') if it wants
}
// wrapper that prints name and newline
void LongNumPrintName(uint8_t *num, size_t N, const char *name)
{
printf("%s:", name);
//LongNumPrint_scalar(num, N);
LongNumPrint(num, N);
putchar('\n');
}
// main() included on Godbolt link that runs successfully
这将编译并运行（在戈德螺栓上) with gcc -O3 -march=haswell并为 N=32 的标量循环产生相同的输出main通过。 （我用了rand()代替MyRandom()，因此我们可以使用您的 init 函数使用相同的种子进行测试并获得相同的数字。）
未经测试较大的 N，但 chunksize = min(ptrdiff, 8k) 的一般思想并使用它从末尾向下循环num[]应该是固体的。
如果我们转换第一个，我们可以加载（而不仅仅是存储）对齐向量N%32字节并将其传递给fwrite在开始主循环之前。但这可能会导致额外的write()系统调用，或在 stdio 内进行笨重的复制。 （除非已经有缓冲的文本尚未打印，例如Name:，在这种情况下我们已经受到了惩罚。）
请注意，从技术上讲，C UB 是递减的inp过去的开始num. So inp -= 32代替inp = inp_stop-32将有用于离开外循环的迭代的 UB。我实际上在这个版本中避免了这种情况，但无论如何它通常都是有效的，因为我认为 GCC 假设一个平面内存模型，并且 de-factor 定义了指针比较的行为。普通操作系统保留零页，因此num绝对不能在物理内存开头的 32 个字节内（所以inp无法换行到高地址。）这一段主要是第一次完全未经测试的尝试留下的，我认为该尝试在内循环中将指针递减得比实际情况更远。
