Мне тут RElf присоветовал поиграться с MIRACL - одной из самых быстрых математических библиотек в сети (поддерживает x86, IA-64, SPARC, ARM и т.д).
Библиотека доступна с http://indigo.ie/~mscott/.
Ребята написали ее на С/С++ с inline-овыми ассемблерными вставками на необходимом ассемблере. Меня заинтересовало качество некоторых таких функций. В файле mrmuldv.any в дистрибутиве расположены наиболее часто используемые, и, соответственно, теоретически, наиболее оптимизированные куски кода. Критерий оптимизации - максимальная скорость. Размер - не суть важно. Использование инструкций MMX/SSE/SSE2 - мммм... Не знаю. На ваше усмотрение.
Код функций:

;
;  Intel-80386 pseudo-32 bit version - for Microsoft C V5.0+
;  Written for MS macro-assembler V5.0+ by Andrej Sauer 
;  with 'mr_utype' defined as 'long' (32 bit). See mirdef.hpc
;  Same comments apply as above (except for 8087 requirement)   
;  Note that this version will also work with the latest Zortech and
;  Borland 16-bit compilers, specifically Borland C++ V3.1+
;
;  For large code models (e.g. medium)
;
;           change    _TEXT    to    mrmuldv_TEXT  (in three places)
;           change    NEAR     to    FAR
;           change    [bp+4]   to    [bp+6]
;           change    [bp+8]   to    [bp+10]
;           change    [bp+12]   to   [bp+14]
;           change    [bp+16]  to    [bp+18]
;           change    [bp+20]  to    [bp+22]
;           etc
;
        .386
        ASSUME CS:_TEXT
_TEXT   SEGMENT USE16 PUBLIC 'CODE'

        PUBLIC _muldiv
_muldiv PROC  NEAR
        push  bp                    ;standard C linkage
        mov   bp,sp

        mov   eax,[bp+4]            ;get a
        mul   DWORD PTR [bp+8]      ;multiply by b
        add   eax,DWORD PTR [bp+12] ;add c to low word
        adc   edx,0h                ;add carry to high word
        div   DWORD PTR [bp+16]     ;divide by m
        mov   bx,WORD PTR [bp+20]  ;get address for remainder
        mov   [bx],edx             ;store remainder
        shld  edx,eax,16            ;shift higher half of quotient
                                    ;into lower half of edx

        pop   bp                    ;standard C return
        ret                         ;quotient: high bits in dx, lows in ax

_muldiv endP

        PUBLIC _muldvm
_muldvm PROC  NEAR
        push  bp                    ;standard C linkage
        mov   bp,sp

        mov   edx,[bp+4]            ;get a
        mov   eax,[bp+8]            ;add in c
        div   DWORD PTR [bp+12]     ;divide by m
        mov   bx,WORD PTR [bp+16]   ;get address for remainder
        mov   [bx],edx              ;store remainder
        shld  edx,eax,16            ;shift higher half of quotient
                                    ;into lower half of edx
        pop   bp                    ;standard C return
        ret                         ;quotient: high bits in dx, lows in ax

_muldvm endP


        PUBLIC _muldvd
_muldvd PROC  NEAR
        push  bp                    ;standard C linkage
        mov   bp,sp

        mov   eax,[bp+4]            ;get a
        mul   DWORD PTR [bp+8]      ;multiply by b
        add   eax,DWORD PTR [bp+12] ;add c to low word
        adc   edx,0h                ;add carry to high word
        mov   bx,WORD PTR [bp+16]   ;get address for remainder
        mov   [bx],eax              ;store remainder
        mov   eax,edx
        shld  edx,eax,16            ;shift higher half of quotient
                                    ;into lower half of edx

        pop   bp                    ;standard C return
        ret                         ;quotient: high bits in dx, lows in ax

_muldvd endP


        PUBLIC _muldvd2
_muldvd2 PROC  NEAR
        push  bp                    ;standard C linkage
        mov   bp,sp
        push si

        mov   eax,[bp+4]            ;get a
        mul   DWORD PTR [bp+8]      ;multiply by b
        les   bx,DWORD PTR [bp+12]
        add   eax,DWORD PTR es:[bx]
        adc   edx,0h                ;add carry to high word
        les   si,DWORD PTR [bp+16]
        add   eax,DWORD PTR es:[si]
        adc   edx,0h                ;add carry to high word

        mov   DWORD PTR es:[si],eax              ;store remainder
        les   bx,DWORD PTR [bp+12]
        mov   DWORD PTR es:[bx],edx
        pop   si
        pop   bp                    ;standard C return
        ret           

_muldvd2 endP

_TEXT   ENDS
END

Мдя, а я и не посмотрел на такое когда миракл смотрел :) Это, конечно, верх оптимизации по скорости shld использовать :)

Сишный и сиплюсплюсный код написаны достаточно чисто. А вот к подобным ассемблерным вставкам у мя изначально недоверие. В особенности после постоянных постов наших корифеев и выпендрежей на win32.asmcommunity. Когда я увидел div, то тоже не порадовался. Да и вообще, bp они используют. Мда :(

Может лучше посмотреть мат.библиотеки от AMD & intel и работать с ними.
Тока там сильная заточка под расширения идёт и всякие арктангенсы считаются в основном.

MIRACL - это не только ценный мех но и три-четыре килограмма _легкоусваиваимого_ мяса :)
Там же и криптография есть! SHA/RSA и т.д. Интеловская библиотека рулит, само-собой, но и MIRACL ничего! А интел только для интела пишет! :(

Гм.. как всегда я натупил с превой попытки =)
Чего-то плохо понял, что значит Intel-80386 pseudo-32 bit version. И les bx,DWORD PTR [bp+12] наводят на сомнения.
Да и без этого, imho, код какой-то странный.
Во-первых, можно обойтись без организации стекового кадра через ebp - это уже сэкономит пару команд.
Во-вторых, размер этих подпрограмм наводит на мысль, что их лучше-бы не вызывать через call, а делать inline.
Ты пишешь, что это так и сделано, но в данном примере что-то не похоже :(

Про amdшные либы я имел ввиду - надёргать оттуда ассемблерную реализацию и прикрутить заместо этого ^^.
Но я тут глянул какую-то библу - там сплошные матрицы и тригонометрия - простых операций и нет :(
Хотя да, с такими библиотеками есть пороблемы - их сильно затачивают под соответствующие процы.
Я как-то смотрел что-то от интела, там местами используют SSE2, когда можно и MMX обойтись. Видимо - чтобы не работало на атлонах :(

Я SHA + RSA за неделю с нуля написал :) По RSA посмотрел литературу и пару реализаций, а по SHA rfc прочитал и одной функцией сделал :)
А код тут и вправду похож на выдернутый из дизассемблера :)

В защиту bp

Если сегмент стека и данных не совпадают, то обойтись без использования bp нельзя, так как байты сэкономленные на push bp/pop bp будут с лихвой компенсированны байтами съеденными префиксом ss. Но в четвертой процедуре один les bx,DWORD PTR [bp+12] точно лишний.

Интересно используеться ли код из mrmuldv.* для факторизации RSA

Ага используеться . В factor.exe нашёл код , вот например процедура muldiv :

0040D080            sub_40D080      proc near      ; CODE XREF: sub_4073B0+178p
0040D080                                           ; sub_407670+C3p ...
0040D080
0040D080            arg_0           = dword ptr  8
0040D080            arg_4           = dword ptr  0Ch
0040D080            arg_8           = dword ptr  10h
0040D080            arg_C           = dword ptr  14h
0040D080            arg_10          = dword ptr  18h
0040D080
0040D080 55                         push    ebp
0040D081 8B EC                      mov     ebp, esp
0040D083 53                         push    ebx
0040D084 8B 45 08                   mov     eax, [ebp+arg_0]
0040D087 F7 65 0C                   mul     [ebp+arg_4]
0040D08A 03 45 10                   add     eax, [ebp+arg_8]
0040D08D 83 D2 00                   adc     edx, 0
0040D090 F7 75 14                   div     [ebp+arg_C]
0040D093 8B 5D 18                   mov     ebx, [ebp+arg_10]
0040D096 89 13                      mov     [ebx], edx
0040D098 5B                         pop     ebx
0040D099 5D                         pop     ebp
0040D09A C3                         retn
0040D09A            sub_40D080      endp

Интересно сравнивал ли кто factor.exe с другими программами (ppsiqs,rsa tool,cryptool ...) по
скорости . Я имею ввиду на одном PC под виндой при факторизации небольших чисел , просто в качестве теста .

[ Black_mirror : Если сегмент стека и данных не совпадают, то обойтись без использования bp нельзя, так как байты сэкономленные на push bp/pop bp будут с лихвой компенсированны байтами съеденными префиксом ss ]

Что-то я уже и сам начал сомневаться. Разве при адресации к стеку через sp нужно будет добавлять префикс ss?
Размер опкода, конечно, увеличится на байт из-за sp, но количество команд сократится, => скорость будет выше.



imho в коде, который привёл bogrus можно убрать все push/pop:
ebp меняем на esp, соответственно скорректировав arg_XX.
ebx меняем на ecx - его вроде как можно менять по стандарту.
Хотя во всех доках пишут, что такие небольшие по размеру ф-ции надо inline делать.
Тогда размер ещё сократится, и возможно станет меньше чем код нужный для вызова такой ф-ции :)
К тому же избавимся от очень медленных операций push перед вызовом - их операнды наверняка уже и так в регистрах, call/ret - просто не нужно.

S_T_A_S_
В реальном режиме через sp адресоваться нельзя. Можно только так: [si],[di],[bx],[bp],[bx+si],[bx+di],[bp+si],[bp+di]. Ну еще конечно смещение может быть. Хотя все это вы и без меня знаете.

DOS, слава богу, сдох. Поэтому отказ от bp - это нормально. Так и надо.

Мне тут RElf присоветовал поиграться с MIRACL - одной из самых быстрых математических библиотек в сети (поддерживает x86, IA-64, SPARC, ARM и т.д).
Как раз в результате разговора с ним о скоростях различных библиотек вырисовалась такая линка:
http://cr.yp.to/speed/mult.html

Данные, конечно, несколько несвежи, но реальное положение дел все-таки показывают....

GMP, получается, основательно быстрее...
Было бы любопытно погонять под профилировщиком...