从字符串中获取 IPv4 地址的最快方法

Posted 2023-02-24

【中文标题】从字符串中获取 IPv4 地址的最快方法

【英文标题】：Fastest way to get IPv4 address from string

【发布时间】：2015-10-19 04:30:47

【问题描述】：

我有以下代码，它比 inet_addr 快大约 7 倍。我想知道是否有办法改进它以使其更快，或者是否存在更快的替代方案。

此代码要求提供有效的以空字符结尾的 IPv4 地址且不包含空格，在我的情况下始终如此，因此我针对这种情况进行了优化。通常你会有更多的错误检查，但如果有一种方法可以使以下更快或存在更快的替代方案，我将不胜感激。

UINT32 GetIP(const char *p)

    UINT32 dwIP=0,dwIP_Part=0;
    while(true)
    
        if(p[0] == 0)
        
            dwIP = (dwIP << 8) | dwIP_Part;
            break;
        
        if(p[0]=='.') 
               
            dwIP = (dwIP << 8) | dwIP_Part;                     
            dwIP_Part = 0;
           p++;
        
        dwIP_Part = (dwIP_Part*10)+(p[0]-'0');
        p++;
    
    return dwIP;

【问题讨论】：

我觉得这个更适合codereview.stackexchange.com

为什么？我想知道从字符串中获取 IP 地址的最快方法是什么。

您还应该注意 UINT32 可能不适合 IP 地址，无需将字节序调整为网络字节顺序。

@Harry CodeReview 专门审查工作代码（您的代码有效），他们可以提出算法改进建议。这并不是说速度技巧不是这里的主题。

@Iwillnotexist Idonotexist 我想如果我的代码确实是目前世界上最快的，那么可能值得去 codereview 看看它是否可以更快？ ;) 我在这里看到了更快的整数转换问题，我认为这与这些类型的问题有关。我自己在这个主题上找不到任何其他内容，如果没有其他选择，它可能会在未来对其他人有所帮助。

【参考方案1】：

既然我们谈论的是最大化 IP 地址解析的吞吐量，我建议使用矢量化解决方案。

这里是 x86 特定的快速解决方案（需要 SSE4.1，或者至少 SSSE3 较差）：

__m128i shuffleTable[65536];    //can be reduced 256x times, see @IwillnotexistIdonotexist

UINT32 MyGetIP(const char *str) 
    __m128i input = _mm_lddqu_si128((const __m128i*)str);   //"192.167.1.3"
    input = _mm_sub_epi8(input, _mm_set1_epi8('0'));        //1 9 2 254 1 6 7 254 1 254 3 208 245 0 8 40 
    __m128i cmp = input;                                    //...X...X.X.XX...  (signs)
    UINT32 mask = _mm_movemask_epi8(cmp);                   //6792 - magic index
    __m128i shuf = shuffleTable[mask];                      //10 -1 -1 -1 8 -1 -1 -1 6 5 4 -1 2 1 0 -1 
    __m128i arr = _mm_shuffle_epi8(input, shuf);            //3 0 0 0 | 1 0 0 0 | 7 6 1 0 | 2 9 1 0 
    __m128i coeffs = _mm_set_epi8(0, 100, 10, 1, 0, 100, 10, 1, 0, 100, 10, 1, 0, 100, 10, 1);
    __m128i prod = _mm_maddubs_epi16(coeffs, arr);          //3 0 | 1 0 | 67 100 | 92 100 
    prod = _mm_hadd_epi16(prod, prod);                      //3 | 1 | 167 | 192 | ? | ? | ? | ?
    __m128i imm = _mm_set_epi8(-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 6, 4, 2, 0);
    prod = _mm_shuffle_epi8(prod, imm);                     //3 1 167 192 0 0 0 0 0 0 0 0 0 0 0 0
    return _mm_extract_epi32(prod, 0);
//  return (UINT32(_mm_extract_epi16(prod, 1)) << 16) + UINT32(_mm_extract_epi16(prod, 0)); //no SSE 4.1

这是shuffleTable 所需的预先计算：

void MyInit() 
    memset(shuffleTable, -1, sizeof(shuffleTable));
    int len[4];
    for (len[0] = 1; len[0] <= 3; len[0]++)
        for (len[1] = 1; len[1] <= 3; len[1]++)
            for (len[2] = 1; len[2] <= 3; len[2]++)
                for (len[3] = 1; len[3] <= 3; len[3]++) 
                    int slen = len[0] + len[1] + len[2] + len[3] + 4;
                    int rem = 16 - slen;
                    for (int rmask = 0; rmask < 1<<rem; rmask++) 
//                     int rmask = (1<<rem)-1;    //note: only maximal rmask is possible if strings are zero-padded
                        int mask = 0;
                        char shuf[16] = -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1;
                        int pos = 0;
                        for (int i = 0; i < 4; i++) 
                            for (int j = 0; j < len[i]; j++) 
                                shuf[(3-i) * 4 + (len[i]-1-j)] = pos;
                                pos++;
                            
                            mask ^= (1<<pos);
                            pos++;
                        
                        mask ^= (rmask<<slen);
                        _mm_store_si128(&shuffleTable[mask], _mm_loadu_si128((__m128i*)shuf));
                    
                

带有测试的完整代码是可用的here。在 Ivy Bridge 处理器上打印：

C0A70103
Time = 0.406   (1556701184)
Time = 3.133   (1556701184)

这意味着建议的解决方案在吞吐量方面比 OP 的代码快 7.8 倍。它每秒处理 3.36 亿个地址（单核 3.4 Ghz）。

现在我将尝试解释它是如何工作的。请注意，在列表的每一行上，您都可以看到刚刚计算的值的内容。所有数组都以小端顺序打印（尽管set 内部函数使用大端）。

首先，我们通过lddqu指令从未对齐的地址加载16个字节。请注意，在 64 位模式下，内存是由 16 字节块分配的，因此这会自动运行良好。在 32 位上，理论上它可能会导致超出范围访问的问题。虽然我不相信它真的可以。无论结束后字节中的值如何，后续代码都将正常工作。无论如何，您最好确保每个 IP 地址至少占用 16 个字节的存储空间。

然后我们从所有字符中减去“0”。在那之后 '。'变成-2，零变成-48，所有数字都保持非负数。现在我们用_mm_movemask_epi8对所有字节的符号进行位掩码。

根据此掩码的值，我们从查找表shuffleTable 中获取一个重要的 16 字节混洗掩码。该表非常大：总共 1Mb。预先计算需要相当长的时间。但是，它不会占用 CPU 缓存中的宝贵空间，因为该表中只有 81 个元素真正被使用。这是因为 IP 地址的每一部分都可以是一位、两位、三位长 => 因此总共有 81 个变体。 请注意，字符串末尾之后的随机无用字节原则上可能会导致查找表中的内存占用增加。

编辑：你可以在 cmets 中找到一个由@IwillnotexistIdonotexist 修改的版本，它使用的查找表只有 4Kb 大小（不过速度有点慢）。

巧妙的 _mm_shuffle_epi8 内在函数允许我们使用我们的 shuffle 掩码重新排序字节。因此 XMM 寄存器包含四个 4 字节的块，每个块都包含小端顺序的数字。我们通过_mm_maddubs_epi16 后跟_mm_hadd_epi16 将每个块转换为16 位数字。然后我们对寄存器的字节进行重新排序，这样整个IP地址就占据了低4个字节。

最后，我们将 XMM 寄存器的低 4 字节提取到 GP 寄存器。它是使用 SSE4.1 内在函数 (_mm_extract_epi32) 完成的。如果没有，用_mm_extract_epi16替换成其他行，但运行会慢一些。

最后，这里是生成的程序集（MSVC2013），这样你就可以检查你的编译器没有生成任何可疑的东西：

lddqu   xmm1, XMMWORD PTR [rcx]
psubb   xmm1, xmm6
pmovmskb ecx, xmm1
mov ecx, ecx               //useless, see @PeterCordes and @IwillnotexistIdonotexist
add rcx, rcx               //can be removed, see @EvgenyKluev
pshufb  xmm1, XMMWORD PTR [r13+rcx*8]
movdqa  xmm0, xmm8
pmaddubsw xmm0, xmm1
phaddw  xmm0, xmm0
pshufb  xmm0, xmm7
pextrd  eax, xmm0, 0

附：如果您还在阅读，请务必查看 cmets =)

【讨论】：

@PeterCordes pmovmskb 指令保证将要求吹出的整个寄存器（r32 或 r64）填零。不幸的是，_mm_movemask_epi8() 和底层（在 GCC 上）__builtin_ia32_pmovmskb128() 内在函数都返回 int，因此编译器迫切需要使用 pmovmskb r32, xmm 形式而不是 pmovmskb r64, xmm 形式，这将是有利可图的。然后编译器觉得需要进行符号扩展，因为返回值名义上是int。我也注意到了这一点，并试图压制它，但意识到问题是根深蒂固的。

@Harry 你必须绝对让表格消失，或者你能负担得起让它更小（比如，256 个条目 x 16 字节/条目？）如果是这样，可以修改 stgatilov 的代码以提取使用 完美哈希 的 81 个可能的有效数字掩码。我对散列的一个秘密技巧是使用单个 SSE4.2 指令 CRC，您可以将其与 _mm_crc32_*() 一起使用。对于这个用例，在mask = _mm_crc32_u16(0, mask << a) >> (32-n); 中找到a 和n，这样你就有2^n 箱，并且在散列后没有任何有效掩码发生冲突。您可能应该能够降低到 n=8（256 个条目）。

@EvgenyKluev 我成功地制作了 stgatilov 出色开端的 256-bin 完美哈希变体。 You may view it here（警告，使用 GCC 对齐属性）。它的速度只有一半多一点，但 LUT 占用的空间减少了 256 倍。

先生们，我刚刚成功地删除了 crc 指令，方法是在我的完美哈希中使用不同的魔法乘法常数。 This new version 因此甚至不需要 SSE4.2，而且速度稍快。目前，在我的 i7-4700MQ 处理器上，时间资源： stgatilov @0.465、我自己 @0.645 和 Harry @2.996 秒。 空间资源： stgatilov @ 1MB，我自己 @ 4KB，Harry @ 可以忽略不计。因此，我的速度慢了 40%，但使用了 0.4% 的内存，我的哈希表负载因子是 81/256 ~ 31.6% 而不是 81/65536 ~ 0.12%。

@Harry：我没有测试它，但我希望如果我们完全用计算代替查找，这将使最快的算法减慢 2 到 3 倍。它仍然可能比您的版本快得多，因为许多计算是并行完成的。即将推出的 Skylake 架构允许矢量化 lzcnt 指令（使用 AVX512 指令集），因此几乎所有计算都可以与其并行完成；但它不太可能胜过这里提到的两种方法。

【参考方案2】：

至于替代方案：这与您的相似，但有一些错误检查：

#include <iostream>
#include <string>
#include <cstdint>

uint32_t getip(const std::string &sip)

    uint32_t r=0, b, p=0, c=0;
    const char *s;
    s = sip.c_str();
    while (*s)
    
        r<<=8;
        b=0;
        while (*s&&((*s==' ')||(*s=='\t'))) s++;
        while (*s)
        
            if ((*s==' ')||(*s=='\t'))  while (*s&&((*s==' ')||(*s=='\t'))) s++; if (*s!='.') break; 
            if (*s=='.')  p++; s++; break; 
            if ((*s>='0')&&(*s<='9'))
            
                b*=10;
                b+=(*s-'0');
                s++;
            
        
        if ((b>255)||(*s=='.')) return 0;
        r+=b;
        c++;
    
    return ((c==4)&&(p==3))?r:0;


void testip(const std::string &sip)

    uint32_t nIP=0;
    nIP = getip(sip);
    std::cout << "\nsIP = " << sip << " --> " << std::hex << nIP << "\n";


int main()

    testip("192.167.1.3");
    testip("292.167.1.3");
    testip("192.267.1.3");
    testip("192.167.1000.3");
    testip("192.167.1.300");
    testip("192.167.1.");
    testip("192.167.1");
    testip("192.167..1");
    testip("192.167.1.3.");
    testip("192.1 67.1.3.");
    testip("192 . 167 . 1 . 3");
    testip(" 192 . 167 . 1 . 3 ");
    return 0;

【讨论】：

与我原来的速度相比，你的速度是多少？

@Harry：我没有进行（没有数据）特定的批量速度测试；无论如何只会与特定的机器有关，但只需使用上述数据运行两者即可获得相同的速度（此处无意义）。