如何在C语言中更快解析未知长度的uint64类型字符串？

针对未知长度的十进制字符串转uint64_t的场景，在你已经替换isdigit为直接字符比较的基础上，以下是几个实用的性能优化技巧：

1. 寄存器缓存字符，减少内存访问 #

原实现中每次循环需要两次访问source[0]（一次判断、一次计算），改成先将字符加载到寄存器变量中，可减少一次内存访问开销：

uint64_t parse(const char *source)
{
    uint64_t res = 0;
    unsigned char c;
    while ((c = *source) >= '0' && c <= '9') {
        res = res * 10 + (c - '0');
        ++source;
    }
    return res;
}

这个改动利用寄存器的高速访问特性，避免重复读取内存，对短数字串的提升尤为明显。

2. 循环展开，降低分支开销 #

手动展开循环可以减少循环条件判断的分支次数，降低CPU分支预测的压力。比如展开4次的版本：

uint64_t parse_unrolled(const char *source)
{
    uint64_t res = 0;
    unsigned char c;
    while (1) {
        c = *source;
        if (!(c >= '0' && c <= '9')) break;
        res = res * 10 + (c - '0');
        source++;

        c = *source;
        if (!(c >= '0' && c <= '9')) break;
        res = res * 10 + (c - '0');
        source++;

        c = *source;
        if (!(c >= '0' && c <= '9')) break;
        res = res * 10 + (c - '0');
        source++;

        c = *source;
        if (!(c >= '0' && c <= '9')) break;
        res = res * 10 + (c - '0');
        source++;
    }
    return res;
}

展开次数可根据实际场景调整（比如2次、8次），现代编译器的-O3优化也会自动做循环展开，但手动展开能更精准地控制逻辑。

3. 批量解析多字符，减少乘法操作 #

每次处理多个连续的数字字符，将多次*10合并为一次*10^n，减少乘法指令的执行次数。比如一次处理2个字符的版本：

uint64_t parse_batch_two(const char *source)
{
    uint64_t res = 0;
    while (1) {
        if (!(*source >= '0' && *source <= '9')) break;
        if (*(source+1) >= '0' && *(source+1) <= '9') {
            res = res * 100 + (*source - '0') * 10 + (*(source+1) - '0');
            source += 2;
        } else {
            res = res * 10 + (*source - '0');
            source += 1;
            break;
        }
    }
    return res;
}

同理可扩展到一次处理4个字符（用*10000），这种方式能大幅减少循环次数和乘法操作，对长数字串的性能提升显著。

4. 用位运算替代乘法（编译器友好优化） #

将res * 10替换为等价的位运算组合：(res << 3) + (res << 1)（因为10 = 8 + 2），虽然现代编译器会自动做这种优化，但手动编写可以确保优化生效：

uint64_t parse_bitwise(const char *source)
{
    uint64_t res = 0;
    unsigned char c;
    while ((c = *source) >= '0' && c <= '9') {
        res = (res << 3) + (res << 1) + (c - '0');
        ++source;
    }
    return res;
}

5. SIMD指令并行处理（高吞吐量场景） #

对于需要批量解析大量长数字串的场景，可以利用CPU的SIMD指令（如SSE2、AVX2）一次性处理8-16个字符，并行判断是否为数字并计算数值。以下是一个SSE2实现的示例：

#include <emmintrin.h>

uint64_t parse_simd(const char *source)
{
    uint64_t res = 0;
    const __m128i zero = _mm_set1_epi8('0');
    const __m128i nine = _mm_set1_epi8('9');
    const __m128i pow10_4 = _mm_set1_epi32(10000);
    const __m128i pow10_8 = _mm_set1_epi64x(100000000);

    while (1) {
        __m128i chars = _mm_loadu_si128((const __m128i*)source);
        __m128i is_digit_low = _mm_cmpge_epi8(chars, zero);
        __m128i is_digit_high = _mm_cmple_epi8(chars, nine);
        __m128i is_digit = _mm_and_si128(is_digit_low, is_digit_high);
        int mask = _mm_movemask_epi8(is_digit);
        if (mask == 0) break;

        int first_non_digit = __builtin_ctz(~mask);
        if (first_non_digit < 16) {
            for (int i = 0; i < first_non_digit; i++) {
                res = res * 10 + (source[i] - '0');
            }
            break;
        }

        __m128i digits = _mm_sub_epi8(chars, zero);
        __m128i digits16 = _mm_unpacklo_epi8(digits, _mm_setzero_si128());
        __m128i group0 = _mm_madd_epi16(_mm_unpacklo_epi16(digits16, _mm_set1_epi16(10)), 
                                        _mm_setr_epi32(1000, 100, 10, 1, 0, 0, 0, 0));
        __m128i group1 = _mm_madd_epi16(_mm_unpackhi_epi16(digits16, _mm_set1_epi16(10)), 
                                        _mm_setr_epi32(1000, 100, 10, 1, 0, 0, 0, 0));
        uint32_t vals[4];
        _mm_storeu_si128((__m128i*)vals, _mm_add_epi32(group0, group1));
        res = res * 100000000 + (uint64_t)vals[0] * 10000 + vals[1];
        source += 16;
    }
    return res;
}

这个实现需要编译器支持SSE2（x86平台默认支持），适合高吞吐量的解析场景。

额外提示 #

• 开启编译器优化选项（如-O2、-O3），编译器会自动进行指令重排、寄存器分配等优化，与手动优化形成互补。
• 如果你的场景允许，可以预先判断字符串长度，但未知长度下上述技巧依然适用。

内容的提问来源于stack exchange，提问作者Kevin Meier