Сравните 16-байтовые строки с SSE

Команды сравнения векторов производят свой результат в виде маски из элементов, которые имеют значение «все единицы» (истина) или все единицы (ложь) в соответствии со сравнением между соответствующими исходными элементами.

См. https://stackoverflow.com/tags/x86/info для некоторых ссылок, которые расскажут вам, что делают эти встроенные функции.

Код в вопросе выглядит так, как будто он должен работать.

Если вы хотите узнать, какие элементы не равны, используйте версию маски перемещения (pmovmskb или movmskps). Вы можете tzcnt / bsf сканировать биты для первого совпадения или popcnt для подсчета совпадений. Все равно дает вам 0xffff маску, неравенство дает 0.

Вы можете задаться вопросом, пригодится ли здесь SSE4.1 ptest. Его можно использовать, но на самом деле он не быстрее, особенно если вы разветвляете результат вместо того, чтобы превращать его в логическое значение 0 / -1.

 // slower alternative using SSE4.1 ptest
__m128i avec, bvec;
avec = _mm_loadu_si128((__m128i*)(a)); 
bvec = _mm_loadu_si128((__m128i*)(b)); 

__m128i diff = _mm_xor_si128(avec, bvec);  // XOR: all zero only if *a==*b

if(_mm_test_all_zeros(diff, diff))  { //equal 
} else {   //not equal 
}

В asm ptest составляет 2 мопа и не может объединяться с условным переходом jcc. Таким образом, общая ветвь pxor + ptest + составляет 4 мопа для внешнего интерфейса и по-прежнему уничтожает один из входов, если у вас нет AVX для помещения результата xor в третий регистр.

pcmpeqb xmm0, xmm1 / pmovmskb eax, xmm0 / cmp/jcc - всего 3 мопа, при этом cmp / jcc сливается в 1 моп на процессорах Intel и AMD.

Если у вас есть более широкие элементы, вы можете использовать movmskps или movmskpd в результате pcmpeqd/q, чтобы получить 4-битную или 2-битную маску. Это наиболее полезно, если вы хотите сканировать бит или popcnt без деления на 4 или 8 байтов на элемент. (Или с AVX2, 8-битной или 4-битной вместо 32-битной маски.)

ptest является хорошей идеей только в том случае, если вам не нужны какие-либо дополнительные инструкции для создания входных данных для него: проверьте все нули или нет, с маской или без нее. например чтобы проверить некоторые биты в каждом элементе или в некоторых элементах.

Что ж, я не уверен, будет ли это быстрее, но это можно сделать с помощью одной встроенной инструкции SSE 4.2: проверка PCMPISTRI (Packed Compare Implicit Length Strings, Return Index) на наличие флагов переноса и / или переполнения:

if (_mm_cmpistrc(a, b, mode))   // checks the carry flag (not set = equal)
  // equal
else
  // unequal

режим будет (для вашего случая):

const int mode = 
  SIDD_UBYTE_OPS |         // 16-bytes per xmm
  SIDD_CMP_EQUAL_EACH |    // strcmp
  SIDD_NEGATIVE_POLARITY;  // find first different byte

К сожалению, эта инструкция плохо документирована. Так что, если кто-то найдет достойный ресурс, объединяющий все комбинации режимов и результирующих флагов, поделитесь, пожалуйста.

Я постараюсь помочь с забытой Может ли кто-нибудь объяснить эту часть вопроса.

register __m128i xmm0, xmm1; 
register unsigned int eax; 

Здесь мы объявляем несколько переменных. __m128i - это встроенный тип для целочисленных операций с регистрами SSE. Обратите внимание, что имена переменных не имеют никакого значения, но автор назвал их в точности так, как соответствующие регистры ЦП вызываются в сборке. xmm0, xmm1, xmm2, xmm3, ... все регистры для операций SSE. eax - один из регистров общего назначения.

Ключевое слово register использовалось давно, чтобы посоветовать компилятору поместить переменную в регистр процессора. Думаю, сегодня это совершенно бесполезно. Дополнительные сведения см. В этом вопросе.

xmm0 = _mm_loadu_si128((__m128i*)(a)); 
xmm1 = _mm_loadu_si128((__m128i*)(b)); 

Этот код был изменен в соответствии с предложением @harold. Здесь мы загружаем 16 байтов из указанных указателей памяти, которые могут быть невыровненными) в переменные xmm0 и xmm1. В ассемблерном коде эти переменные, скорее всего, будут расположены непосредственно в регистрах, поэтому эти встроенные функции будут генерировать невыровненную нагрузку на память. Преобразование указателя в тип __m128i* необходимо, потому что intrinsic принимает этот тип указателя, хотя я понятия не имею, почему Intel это сделала.

xmm0 = _mm_cmpeq_epi8(xmm0, xmm1); 

Здесь мы сравниваем на равенство каждый байт из переменной xmm0 с соответствующим байтом в переменной xmm1. Суффикс _epi8 означает работу с 8-битными элементами, то есть байтами. Он чем-то похож на memcmp(&xmm0, &xmm1, 16), но дает другие результаты. Он возвращает 16-байтовое значение, которое содержит 0xFF для каждого байта с равными значениями и 0x00 для каждого байта с разными значениями.

eax = _mm_movemask_epi8(xmm0); 

Это очень важная инструкция из SSE2, которая обычно используется для написания оператора if с некоторым условием SSE. Он берет старший бит из каждого из 16 байтов в аргументе XMM и записывает их в одно 16-битное целое число. На уровне сборки этот номер находится в универсальном регистре, что позволяет нам быстро проверить его значение сразу после этого.

if(eax==0xffff) //equal 
else   //not equal

Если все 16 байтов двух регистров XMM были равны, то _mm_cmpeq_epi8 должен возвращать маску со всеми установленными 128 битами. _mm_movemask_epi8 тогда вернет полную 16-битную маску, которая равна 0xFFFF. Если бы любые два сравниваемых байта были разными, соответствующий байт был бы заполнен нулями на _mm_cmpeq_epi8, поэтому _mm_movemask_epi8 вернет 16-битную маску с соответствующим битом не, поэтому он будет меньше 0xFFFF.

Кроме того, вот объясненный код, заключенный в функцию:

bool AreEqual(const char *a, const char *b) {
  __m128i xmm0, xmm1; 
  unsigned int eax; 
  xmm0 = _mm_loadu_si128((__m128i*)(a)); 
  xmm1 = _mm_loadu_si128((__m128i*)(b)); 
  xmm0 = _mm_cmpeq_epi8(xmm0, xmm1); 
  eax = _mm_movemask_epi8(xmm0); 
  return (eax == 0xffff); //equal 
}