Друзья, насколько Ваши Асм-коды реально эффективны?

Там и х64 можно, и линупс, и что угодно. Гуглите jwasm/uasm, интересная весьма весчь.

Асм мб и быстрее Си после всех оптимизаций, но кто ими занимается в реальных проектах? Разве что времени много, можно заняться байто*бством. Такое и отлаживать сложнее в разы, и вообще. For fun, я игрался когда-то , но для реальных проектов, особенно если на заказ - проще Си. Хотя часто бесит особо "умный" компилятор.

Кстати, видели такой сайт ? https://godbolt.org/ Вывод дизасм-листинга разных компилеров (gcc, студия).

 

Спасибо, но уже видел.

опять Спасибо, но gcc мне вполне хватает == писать всё на Асме есмь лишняя мутотень (по мне), куда разумней использовать Асм-вставки в gcc.

для меня проганье == своеобразная развлекуха.. время от времени ей занимаюсь

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

особо вумный компиль обычно от мокрых, а другие куда-более покладисты

 

ХАХА таки я одолел MD5!
Версия 1.0 уступала С/C++ компиляции. Но затем в 1.01 я смог обогнать сишку, 8.18 такт/байт против 6.86 т/б.
Хотя конечно изначально С код не оптимизирован, у меня есть Сишный код который при должной оптимизации может и побыстрей моего. Но я его пока не проверял. Так что ассемблере можно всё что угодно делать. Я имею ввиду любые проекты, имею ввиду именно мой стиль высокоуровнего программирования. Я так считаю.

--- Сообщение объединено, 6 янв 2021 ---

Кстати. Автор исходников за основу что было взято. Copyright (C) 2002 Aladdin Enterprises. Peter Deutsch
Код у него реально не очень оптимальный. А во обще, там эти хэши довольно трудно оптимизируются.

 

главный принцип оптимазы == надо смотреть сколько "мёртвого" кода на циклах имеется, то бишь, к примеру, часть кода в цикле работает один раз, а потом тупо тарабанится мильЁны развЪЪЪ впустую. кстати, на старых процах с этим даже лучше было, пч мертвячина отсекалась на блоках IF и получались холостые сравнения без запуска потрохов блока, а сейчас потроха иф-ов исполняются до проверки условия и проц постоянно тупо сбрасывает левые ветки

 

что бы перевернуть последовательность байт, на ассемблере может хватить всего лишь 1 команды

Код (ASM):

1. bswap eax

а вот на сишечки уже так не выйдет

 

Не хочу тебя расстраивать, но __builtin_bswap32 и аналоги делают именно это.

 

не расстроил абсолютно,это же интринзик

 

Занятно, но по ходу, такой мною не любимый АРМ, может легко уделать Атлон и все 686+. Именно в MD5!
А во обще, АРМ это хороший процессор, и я, извиняюсь что, я его ругал. Просто на нём надо уметь кодить, используя сильные стороны, и не используя слабые.

Код (ASM):

1.  
2. ;//Раунд 1.
3. ROUND1 MACRO accum:req, const_b:req, const_c:req, const_d:req, k:req, s:req, Ti:req
4.    ;;accum = (accum + ((const_b & const_c) | (~const_b & const_d)) + data[k] + Ti) <<< s + const_b
5.    mov ebp, const_b
6.    mov edi, const_b
7.    and ebp, const_c ;;=(const_b & const_c)
8.    not edi
9.    and edi, const_d ;;=(~const_b & const_d)
10.    or edi, ebp ;;=((const_b & const_c) | (~const_b & const_d))
11.    add accum, [esi][k*4]
12.    lea accum, [accum+edi+Ti]
13.    rol accum, s ;;=accum <<< s
14.    add accum, const_b
15.    EXITM <>
16. ENDM
17.  

Сколько этот код тактов на 686+ выдаёт? 7 тактов должен!
А если на ARM переделать?
У ARM нельзя загрузить константу в 32 бита, поэтому помещаем их в массив.
У ARM можно делать операции reg,reg,reg, этим и воспользуемся.

Код (ASM):

1.  
2. and r0, const_b, const_c  ;;=(const_b & const_c)
3. bic r1, const_d, const_b  ;;=(~const_b & const_d)
4. or r0, r0, r1;;=((const_b & const_c) | (~const_b & const_d))
5. add accum, [r8][k*4]
6. add accum, r0, [r9+i]
7. rol accum, accum, s ;;=accum <<< s
8.  add accum, accum, const_b
9.  

Код очень грязный, но думаю мысль понятна!

 

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

 

если хотите увеличить скорость данного кода:
- используйте инструкцию: ANDN вместо: mov, not, and
- в конце разбавьте зависимые инструкции: add, lea, rol, add инструкциями следующего раунда с другими регистрами

 

Да ладно! ANDN Это из какого набора инструкция? У меня старый процессор! И сейчас х86-32!

--- Сообщение объединено, 9 янв 2021 в 02:04 ---

В современных процессорах ядро RISC и оно умеет в коде высматривать цепочку инструкции типа как в моём коде и преобразовывать в подобия ARM инструкций. Но у меня старый процессор Athlon II X4 640, у него ядро фактически от атлон хп.

--- Сообщение объединено, 9 янв 2021 в 02:45 ---

Это называется слияние инструкций, мой тоже может сливать некоторый, например cmp/j*, но более сложные варианты умеют сливать процы следующего поколения!

--- Сообщение объединено, 9 янв 2021 в 02:53 ---

Короче говоря, нет у меня такой инструкции.
https://wiki2.org/en/Bit_Manipulation_Instruction_Sets

 

Переставил в макрофункции ROUND3 const_d и const_b, убрал зависимость в следующей функцией, в результате 6.36 тактов/байт, пожалуй это всё, на что способен атлон и все 686+. Дальше без слияния, поднять быстродействие уже не возможно. Но это возможно лишь, в следующих по поколению процессорах, например в райзенах.
АРМ может и быстрей, вероятно не меньше 5 т/б, причём не самый новый.

 

Драка с компилятором С продолжается! На этот раз sha256!
Пока компилятор С от M$ выигрывает, со счётом 24.2 и 27.7 т/б. Но я чувствую, что я смогу, обыграть компилятор мелких!

 

Сейчас набросал код для ARM Cortex для hash MD5.
Получилось 4 такта на байт, хотя арме надо ещё 2 команд на загрузку data[k] + Ti в регистры r2 и r3. Да, константы поместил в массив. А как ещё быстро загрузить 32 бита?
И это на суперскалярном ARM'е с макс 3 инструкции за такт. Новые кортексы могут как я говорил, по 5 инструкций делать.
Так же, нашёл данные, что процессор типа Skylake выполняет код на ассемблере за 4.94 такта/байт, автор кода Maxim Masiutin. Можно найти на гитхабе.
https://github.com/maximmasiutin/MD5_Transform-x64

--- Сообщение объединено, 13 янв 2021 в 02:36 ---

Ах да забыл.

Код (ASM):

1.  
2.     ;//Раунд 1.     4 tics
3. ROUND1 MACRO accum:req, const_b:req, const_c:req, const_d:req, k:req, s:req, i:req
4.     ;;accum = (accum + ((const_b & const_c) | (~const_b & const_d)) + data[k] + Ti) <<< s + const_b
5.     ldr     r2, [r9,#k]                 ;;=data[k]
6.     ldr     r3, [r10,#i]                ;;=T[i]
7.     and     r0, const_b, const_c        ;;=(const_b & const_c)
8.     bic     r1, const_d, const_b        ;;=(const_d & ~const_b)
9.     add     r2, r3                      ;;=(data[k] + T[i])
10.     orr     r0, r1                      ;;=((const_b & const_c) | (~const_b & const_d))
11.     add     accum, r2                   ;;=accum +(data[k] + T[i])
12.     add     accum, r0                   ;;=accum + ((const_b & const_c) | (~const_b & const_d))
13.     add     accum, const_b, accum rol s ;;accum=const_b+accum <<< s
14.     EXITM <>
15. ENDM
16.     ;//Раунд 2.     4 tics
17. ROUND2 MACRO accum:req, const_b:req, const_c:req, const_d:req, k:req, s:req, i:req
18.     ;;accum = (accum + ((const_b & const_d) | (const_c & ~const_d)) + data[k] + Ti) <<< s + const_b;
19.     ldr     r2, [r9,#k]                 ;;=data[k]
20.     ldr     r3, [r10,#i]                ;;=T[i]
21.     bic     r1, const_c, const_d        ;;=(const_c & ~const_d)
22.     and     r0, const_b, const_d        ;;=(const_b & const_d)
23.     add     r2, r3                      ;;=(data[k] + T[i])
24.     orr     r0, r1                      ;;=((const_b & const_d) | (const_c & ~const_d))
25.     add     accum, r2                   ;;=accum +(data[k] + T[i])
26.     add     accum, r0                   ;;=accum + ((const_b & const_c) | (~const_b & const_d))
27.     add     accum, const_b, accum rol s ;;accum=const_b+accum <<< s
28.     EXITM <>
29. ENDM
30.     ;//Раунд 3.     4 tics
31. ROUND3 MACRO accum:req, const_b:req, const_c:req, const_d:req, k:req, s:req, Ti:req
32.     ;;accum = (accum + (const_b ^ const_c ^ const_d) + data[k] + Ti) <<< s + const_b
33.     ldr     r2, [r9,#k]                 ;;=data[k]
34.     ldr     r3, [r10,#i]                ;;=T[i]
35.     eor     r0, const_b, const_c
36.     add     r2, r3                      ;;=(data[k] + T[i])
37.     eor     r0, const_d                 ;;=(const_b ^ const_c ^ const_d)
38.     add     accum, r2                   ;;=accum +(data[k] + T[i])
39.     add     accum, r0                   ;;=accum + (const_b ^ const_c ^ const_d)
40.     add     accum, const_b, accum rol s ;;accum=const_b+accum <<< s
41.     EXITM <>
42. ENDM
43.     ;//Раунд 4.     4 tics
44. ROUND4 MACRO accum:req, const_b:req, const_c:req, const_d:req, k:req, s:req, Ti:req
45.     ;;accum = (accum + (const_c ^ (const_b | ~const_d)) + data[k] + Ti) <<< s + const_b
46.     ldr     r2, [r9,#k]                 ;;=data[k]
47.     ldr     r3, [r10,#i]                ;;=T[i]
48.     orn     r0, const_b, const_d        ;;=(const_d & ~const_b)
49.     add     r2, r3                      ;;=(data[k] + T[i])
50.     eor     r0, const_c                 ;;=(const_c ^ (const_b | ~const_d))
51.     add     accum, r2                   ;;=accum +(data[k] + T[i])
52.     add     accum, r0                   ;;=accum +
53.     add     accum, const_b, accum rol s ;;accum=const_b+accum <<< s
54.     EXITM <>
55. ENDM
56.  

Видно что код не совсем синтаксически верный. Но это можно подправить. Если кто не понял, каждый макрос вызывается 16 раз.

 

На сайте http://govnokod.ru
есть примеры и как получается код на Си (..) компиляторах, в сравнении с его асм пониманием.

P.S. А, вообще, на http://rosettacode.org/wiki/Category:Programming_Languages есть решения и на ассемблерах.

 

ARM процессор более совершенней чем x86. Hash'и же быстрей рассчитывает.
По думать только, ещё неделю назад я говорил об обратном.
НО х86 уверено проиграл АРМ32 бита.
Чооо слияние инструкций.......... аааааааааааааа.......... задрали, это просто читерствооооооооо х86
Так играть нельзя, ARM выиграл, и я вынужден это признать.

 

Нашёл быстрый алгоритм SHA-256, но он какой странный.
https://habr.com/ru/sandbox/80821/
Хэш совсем другой, или это другая реализация совсем? Но скорость не реальная 2.7 т/б!, в десять раз быстрей чем у меня на асме.

 

"нагнулся за копейкой, порвал на рубь"
на x86 есть AVX512 - сразу можно 16 хэшей (SHA1) считать за раз

 

А вот у меня нет AVX512, и что? В тот же кортекс можно напихать подобных инструкций ускорителей.