一道简单面试题引出的优化方法讨论 (Ⅰ)

笔者曾多年在百度基础架构部负责面试培训工作，喜欢使用简单而有内涵的题目来考查面试者，现在分享一道曾经在内部很流行的面试题与其的多种解决方法。

问题

在一个内存文件中找出所有以 Windows换行符(\r\n)结尾的行首指针，并保存在数组中，结果不要求有序

这个面试题在很多面试者刚听到的时候，不免会发出惊讶，这么简单？
大部分人能很快写出下面的朴素算法。

朴素算法

void tokenize(const char *buffer, size_t buffer_size, size_t *tokens, size_t token_size)
{
    for (size_t i = 0; i < buffer_size - 1; ++i)
    {
        if (buffer[i] == '\r' && buffer[i + 1] == '\n')
            *tokens++ = i + 2;
    }
}

然后我就会接着问，你觉得可以优化吗？这时候大部分面试者就会陷入沉思。那我们来看看都会有什么样的优化思路。

优化思路

1. 算法优化
2. 并行化

算法优化

对于算法优化，首先观察刚才程序中最耗时的部分，就是寻址操作。对于朴素算法，寻址操作的复杂度是O(N)，那么减少寻址的次数就是一种优化思路。

方法一

因为子串有两个字符长，所以并不需要访问母串中的每一个字符。
我给出一种方法，先判断第二个字符，如果是\n就比较第一个字符 ，如果是\r就后移一个位置，否则就后移两个位置。

void tokenize(const char *buffer, size_t buffer_size, size_t *tokens, size_t token_size)
{
    for (size_t i = 0, j = 1; j < buffer_size;)
    {
        if (buffer[j] == '\n')
        {
            if (buffer[i] == '\r')
            {
                *tokens++ = j + 1;
            }
            i += 1;
            j += 1;
        }
        else if (buffer[j] == '\r')
        {
            i += 1;
            j += 1;
        }
        else
        {
            i += 2;
            j += 2;
        }
    }
}

方法二

有的同学稍经点拔，会提出可以只检查偶数位的字符，思路基本一致，方法如下。

void tokenize(const char *buffer, size_t buffer_size, size_t *tokens, size_t token_size)
{
    if (buffer_size > 1 && buffer[0] == '\r' && buffer[1] == '\n')
        *tokens++ = 2;

    for (size_t i = 2; i < buffer_size - 1; i += 2)
    {
        if (buffer[i] == '\r')
        {
            if (buffer[i + 1] == '\n')
                *tokens++ = i + 2;
        }
        else if (buffer[i] == '\n')
        {
            if (buffer[i - 1] == '\r')
                *tokens++ = i + 1;
        }
    }

    if (buffer_size > 1 && (buffer_size & 0x01) == 0x01)
    {
        if (buffer[buffer_size - 2] == '\r' && buffer[buffer_size - 1] == '\n')
            *tokens++ = buffer_size;
    }
}

并行化

除了算法上的优化，还有工程方面的优化，并行化就是一个重要的方向。
并行化分为SIMD（单指令多数据）和SMT（同时多线程）和SIMT（单指令多线程）三种，下面依次列举这些方法。

方法三 SIMD

SIMD通常是借助CPU的指令集来实现，如下面代码中使用的AVX2指令集

static inline void foo(const __m256i &pattern, const __m256i *mem, size_t offset, size_t *&tokens)
{
    const __m256i data = _mm256_loadu_si256(mem);
    const __m256i cmp = _mm256_cmpeq_epi16(data, pattern);
    unsigned int mask = _mm256_movemask_epi8(cmp);

    size_t shift = 0;
    while (mask != 0)
    {
        const int pad = __builtin_ctz(mask);
        mask >>= pad;
        mask >>= 2;
        shift += pad + 2;
        *tokens++ = offset + shift;
    }
}

void tokenize(const char *buffer, size_t buffer_size, size_t *tokens, size_t token_size)
{
    const __m256i pattern = _mm256_set1_epi16('\n' << 8 | '\r');

    for (size_t i = 0; i < buffer_size; i += sizeof(__m256i))
    {
        foo(pattern, reinterpret_cast<const __m256i *>(buffer + i), i, tokens);
        foo(pattern, reinterpret_cast<const __m256i *>(buffer + i + 1), i + 1, tokens);
    }
}

方法四 SMT

SMT的程序我们借助比较成熟的编程接口OpenMP来实现，在朴素方法上的改动非常少

void tokenize(const char *buffer, size_t buffer_size, size_t *tokens, size_t token_size)
{
    size_t token_index = 0;
#pragma omp parallel for
    for (size_t i = 0; i < buffer_size - 1; ++i)
    {
        if (buffer[i] == '\r' && buffer[i + 1] == '\n')
        {
            size_t index;
#pragma omp atomic capture
            index = token_index++;
            tokens[index] = i + 2;
        }
    }
}

方法五（前两种的结合）

SIMD和SMT的优化方向并不冲突，我们可以结合实现
比如一个处理器有8个核，每个核支持2个超线程，同时支持256bit宽的SIMD指令集，那它的并行度就是8*2*8=128，我们要充分利用起来

static inline void foo(const __m256i &pattern, const __m256i *mem, size_t offset, size_t *tokens, size_t &token_index)
{
    const __m256i data = _mm256_loadu_si256(mem);
    const __m256i cmp = _mm256_cmpeq_epi16(data, pattern);
    unsigned int mask = _mm256_movemask_epi8(cmp);

    size_t shift = 0;
    while (mask != 0)
    {
        const int pad = __builtin_ctz(mask);
        mask >>= pad;
        mask >>= 2;
        shift += pad + 2;

        size_t index;
#pragma omp atomic capture
        index = token_index++;
        tokens[index] = offset + shift;
    }
}

void tokenize(const char *buffer, size_t buffer_size, size_t *tokens, size_t token_size)
{
    const __m256i pattern = _mm256_set1_epi16('\n' << 8 | '\r');
    size_t token_index = 0;

#pragma omp parallel for
    for (size_t i = 0; i < buffer_size; i += sizeof(__m256i))
    {
        foo(pattern, reinterpret_cast<const __m256i *>(buffer + i), i, tokens, token_index);
        foo(pattern, reinterpret_cast<const __m256i *>(buffer + i + 1), i + 1, tokens, token_index);
    }
}

测试结论

对于以上五种方法，我们看一下实际运行情况。
因为我们使用了-O2的编译选项，并且我们的程序相对而言非常简单，所以编译器实际上已经做了很多优化工作，下面的测试数据是在编译器的优化之后，体现了不同方法的差别。

数据：构造1G长的随机文件，\r和\n出现的概率分别为1/256，总行数16247

算法	用时(ms)
朴素方法	507
方法一	397
方法二	365
方法三	106
方法四	91
方法五	21

测试机器 Intel(R) Xeon(R) CPU E5-2690 v3 @ 2.60GHz，6核6线程
编译器 gcc 7.2 编译选项 -O2

关于SIMT方法，会在第二篇中详细讨论，请继续阅读，从文本文件中检出所有行的多种优化方法 (Ⅱ)