ошибка страницы maskmovdqu / _mm_maskmoveu_si128 - как избежать?

maskmovdqu не выполняет подавление ошибок, в отличие от AVX vmaskmovps или маскированных хранилищ AVX512. Это решит вашу проблему, хотя, возможно, и не самым эффективным способом.

Как описано в справочном руководстве Intel по ISA, с нулевой маской (поэтому ничего не сохраняется для память) Исключения, связанные с адресацией памяти и ошибками страниц, все еще могут сигнализироваться (зависит от реализации).

Я предполагаю, что с ненулевой маской гарантируется, что она совершит ошибку страницы, если 16 байтов включают какие-либо страницы, недоступные для записи. Или, возможно, в некоторых реализациях маска подавляет ошибки, даже когда происходит некоторое сохранение (нули на неотображенной странице, но ненулевые в других местах)

В любом случае, на реальных процессорах это не быстрая инструкция.

maskmovdqu иногда мог быть хорош на одноядерном Pentium 4 (или не на IDK), и/или его предшественник MMX мог быть полезен на Pentium в порядке очереди. Сохранения с обходом маскированного кеша гораздо менее полезны на современных процессорах, где L3 является обычным резервом, а кеши большие. Возможно, более важно то, что между одним ядром и контроллером(ами) памяти существует больше механизмов, потому что все должно работать правильно, даже если другое ядро ​​делало перезагрузку этой памяти в какой-то момент, поэтому запись неполной строки возможна. может быть, даже менее эффективным.

Как правило, это ужасный выбор, если вы действительно храните всего 8 или 12 байтов. (В основном то же самое, что и хранилище NT, которое не записывает полную строку). Особенно, если вы используете несколько узких хранилищ для захвата фрагментов данных и помещения их в один непрерывный поток. Я бы не предполагал, что несколько перекрывающихся maskmovdqu хранилищ приведут к одному эффективному хранилищу всей строки кэша, как только вы в конечном итоге закончите одно, даже если маски означают, что ни один байт фактически не записывается дважды.

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

Чтобы сохранить верхние 8 байтов регистра XMM, используйте movhps.

Запись в кеш также позволяет делать перекрывающиеся хранилища, например movdqu. Таким образом, вы можете объединить несколько 12-байтовых объектов, перетасовав их каждый в конец регистра XMM (или загрузив их таким образом в первую очередь), а затем использовать movdqu для сохранения в [rdi], [rdi+12], [rdi+24] и т. д. перекрытие совершенно нормально; объединение в буфере хранилища может поглотить его еще до того, как он будет зафиксирован в кэше L1d, а если нет, то кэш L1d все еще будет довольно быстрым.

В начале записи большого массива, если вы не знаете выравнивание, вы можете сделать невыровненные movdqu из первых 16 байтов вашего вывода. Затем сделайте первое выровненное хранилище по 16 байтам, возможно, перекрывающееся с этим. Если ваш общий выходной размер всегда> = 16 байт, эта стратегия не требует большого количества ветвлений, чтобы вы могли выполнять выровненные хранилища для большей части этого. В конце вы можете сделать то же самое с окончательным потенциально невыровненным вектором, который может частично перекрывать последний выровненный вектор. (Или, если массив выровнен, то перекрытия нет, и он тоже выровнен. movdqu работает так же быстро, как movdqa, если адрес выровнен на современных процессорах.)

Что ж, поскольку кажется, что нет хорошего способа предсказать ошибку страницы, я пошел другим путем. Это прямое решение asm:

Во-первых, мы используем таблицу для сдвига результата в соответствии с bytes_inside. Затем узнаем, сколько байт нужно записать. Поскольку необходимо записать не более 15 байтов, это работает как 4-этапный процесс. Мы просто проверяем биты bytes_to_write — если установлен бит «8» (то есть бит 3), мы используем movq. для бита 2 требуется movd, для бита 1 — pextrw, а для бита 0 — pextrb. После каждого сохранения указатель данных соответственно увеличивается, и соответственно сдвигается регистр данных.

Регистры:

• r10: result_data_ptr
• r11: байты_внутри
• xmm0.word[6]: размер элемента данных
• xmm2: наш элемент данных
• shuf_inside: таблица данных для побайтового вращения регистра xmm с использованием pshufb (psrldq позволяет только немедленный подсчет байтового сдвига)

.DATA
ALIGN 16
shuf_inside   byte 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,0
              byte 2,3,4,5,6,7,8,9,10,11,12,13,14,15,0,1
              byte 3,4,5,6,7,8,9,10,11,12,13,14,15,0,1,2
              byte 4,5,6,7,8,9,10,11,12,13,14,15,0,1,2,3
              byte 5,6,7,8,9,10,11,12,13,14,15,0,1,2,3,4
              byte 6,7,8,9,10,11,12,13,14,15,0,1,2,3,4,5
              byte 7,8,9,10,11,12,13,14,15,0,1,2,3,4,5,6
              byte 8,9,10,11,12,13,14,15,0,1,2,3,4,5,6,7
              byte 9,10,11,12,13,14,15,0,1,2,3,4,5,6,7,8
              byte 10,11,12,13,14,15,0,1,2,3,4,5,6,7,8,9
              byte 11,12,13,14,15,0,1,2,3,4,5,6,7,8,9,10
              byte 12,13,14,15,0,1,2,3,4,5,6,7,8,9,10,11
              byte 13,14,15,0,1,2,3,4,5,6,7,8,9,10,11,12
              byte 14,15,0,1,2,3,4,5,6,7,8,9,10,11,12,13
              byte 15,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14
.CODE
[...]
        lea             rax,        [ shuf_inside ]
        shl             r11,        4
        pshufb          xmm2,       [ rax + r11 - 16 ]
        shr             r11,        4
        pextrw          rax,        xmm0,       6           ;reducedStrideWithPadding - i.e. size of item
        sub             rax,        r11                     ;bytes_to_write
        ;
        test            rax,        8
        jz              lessThan8
        movq            qword ptr [r10], xmm2
        psrldq          xmm2,       8
        add             r10,        8
        lessThan8:
        test            rax,        4
        jz              lessThan4
        movd            dword ptr [r10], xmm2
        psrldq          xmm2,       4
        add             r10,        4
        lessThan4:
        test            rax,        2
        jz              lessThan2
        pextrw          word ptr [r10], xmm2, 0
        psrldq          xmm2,       2
        add             r10,        2
        lessThan2:
        test            rax,        1
        jz              lessThan1
        pextrb          byte ptr [r10], xmm2, 0
        lessThan1: