Подтвердить что ты не робот

Самый быстрый способ получить IPv4-адрес из строки

У меня есть следующий код, который примерно в 7 раз быстрее, чем inet_addr. Мне было интересно, есть ли способ улучшить это, чтобы сделать его еще быстрее или если существует более быстрая альтернатива.

Этот код требует, чтобы действительный нулевой 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;
}
4b9b3361

ОТВЕТЫ

Ответ 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));
                    }
                }
}

Полный код с тестированием доступен здесь. На процессоре Ivy Bridge он печатает:

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

Это означает, что предлагаемое решение в 7,8 раза быстрее с точки зрения пропускной способности, чем код OP. Он обрабатывает 336 миллионов адресов в секунду (одно ядро ​​3,4 ГГц).

Теперь я попытаюсь объяснить, как это работает. Обратите внимание, что в каждой строке списка вы можете увидеть содержимое только что вычисленного значения. Все массивы печатаются в порядке малых порядков (хотя set intrinsics используют big-endian).

Прежде всего, мы загружаем 16 байтов из неравномерного адреса командой lddqu. Обратите внимание, что в 64-битном режиме память выделяется 16-байтовыми кусками, поэтому это работает хорошо автоматически. В 32-битном случае теоретически это может вызвать проблемы с доступом за пределы диапазона. Хотя я не верю, что это действительно возможно. Последующий код будет работать правильно независимо от значений в байтах после конца. В любом случае, вы должны убедиться, что каждый IP-адрес занимает не менее 16 байт памяти.

Затем мы вычитаем "0" из всех символов. После этого '.' превращается в -2, а нуль переходит в -48, все цифры остаются неотрицательными. Теперь мы принимаем битмаску с признаками всех байтов с _mm_movemask_epi8.

В зависимости от значения этой маски, мы получаем нетривиальную 16-байтную тасовую маску из таблицы поиска shuffleTable. Стол довольно большой: всего 1 Мб. И это требует довольно много времени, чтобы прекомпостировать. Тем не менее, он не занимает драгоценное пространство в кэше процессора, потому что на самом деле используются только 81 элемента из этой таблицы. Это связано с тем, что каждая часть IP-адреса может быть одной, двумя, тремя цифрами длиной = > , следовательно, всего 81 вариант. Обратите внимание, что случайные байт-бит после окончания строки в принципе могут привести к увеличению объема памяти в таблице поиска.

EDIT: вы можете найти версию, измененную @IwillnotexistIdonotexist в комментариях, которая использует таблицу поиска только размером 4Kb (хотя она немного медленнее).

Гениальная _mm_shuffle_epi8 внутренняя позволяет нам изменять порядок байтов с помощью нашей маски тасов. В результате XMM-регистр содержит четыре 4-байтовых блока, каждый блок содержит цифры в порядке малозначности. Мы преобразуем каждый блок в 16-разрядное число на _mm_maddubs_epi16, за которым следует _mm_hadd_epi16. Затем мы переупорядочиваем байты регистра, так что весь IP-адрес занимает более низкие 4 байта.

Наконец, мы извлекаем нижние 4 байта из регистра XMM в регистр 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

P.S. Если вы все еще читаете это, обязательно просмотрите комментарии =)

Ответ 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;
}