Оптимизация функции шифрования ГОСТ

Вот результаты тестов:



Processor======Old version================bogrus version===



PIII 533________0.006218-0.006378__________0.003921-0.003961

PIV 2,4 dual_____0.001996-0.001997__________0.001613-0.001614

PIV 2,8_________0.001985-0.001996__________0.000716-0.000742



На Селеронах разница чуть-ли не в три раза.

 

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

Код (Text):

1.  
2. #define MACRO_GOST4_OLD(aa,bb)                  \
3. {                                               \
4.     _asm{mov eax, [ecx][aa]}                    \
5.     _asm{add eax, edi}                          \
6.     _asm{mov dl,  al}                           \
7.     _asm{mov bl,  ah}                           \
8.     _asm{mov al,  [ebp][edx+OFFSET_GOST_SBOX1]} \
9.     _asm{mov ah,  [ebp][ebx+OFFSET_GOST_SBOX2]} \
10.     _asm{ror eax, 16}                           \
11.     _asm{mov dl,  al}                           \
12.     _asm{mov bl,  ah}                           \
13.     _asm{mov al,  [ebp][edx+OFFSET_GOST_SBOX3]} \
14.     _asm{mov ah,  [ebp][ebx+OFFSET_GOST_SBOX4]} \
15.     _asm{ror eax, 5}                            \
16.     _asm{xor esi, eax}                          \
17.                                                 \
18.     _asm{mov eax, [ecx][bb]}                    \
19.     _asm{add eax, esi}                          \
20.     _asm{mov dl,  al}                           \
21.     _asm{mov bl,  ah}                           \
22.     _asm{mov al,  [ebp][edx+OFFSET_GOST_SBOX1]} \
23.     _asm{mov ah,  [ebp][ebx+OFFSET_GOST_SBOX2]} \
24.     _asm{ror eax, 16}                           \
25.     _asm{mov dl,  al}                           \
26.     _asm{mov bl,  ah}                           \
27.     _asm{mov al,  [ebp][edx+OFFSET_GOST_SBOX3]} \
28.     _asm{mov ah,  [ebp][ebx+OFFSET_GOST_SBOX4]} \
29.     _asm{ror eax, 5}                            \
30.     _asm{xor edi, eax}                          \
31. }
32.  
33.  
34.  
35. VOID EncipherGOST4(
36.     IN  CONST PVOID     pKey,
37.     IN  CONST PVOID     pSBox,
38.     OUT PVOID           pDst,
39.     IN  CONST PVOID     pSrc,
40.     IN  PVOID           pSynchro,
41.     IN  ULONG           uLength)
42. {
43.     ULONG uCount = 0;
44.  
45.     _asm
46.     {
47.         pushad
48.         mov     eax,    uLength
49.         add     eax,    7
50.         and     eax,    ~7
51.         mov     uCount, eax
52.         mov     edx,    pSynchro
53.         mov     esi,    [edx]
54.         mov     edi,    [edx+4]
55.         mov     ebx,    pSrc
56.         mov     eax,    pDst
57.         mov     ecx,    pKey
58.         xor     edx,    edx
59.     up:
60.         push    eax
61.         push    ebx
62.         mov     ebx,    esi
63.         mov     esi,    edi
64.         mov     edi,    ebx
65.         xor     ebx,    ebx
66.         push    ebp
67.         mov     ebp,    pSBox
68.     }
69.  
70.     MACRO_GOST4(0,  4)
71.     MACRO_GOST4(8,  12)
72.     MACRO_GOST4(16, 20)
73.     MACRO_GOST4(24, 28)
74.     MACRO_GOST4(0,  4)
75.     MACRO_GOST4(8,  12)
76.     MACRO_GOST4(16, 20)
77.     MACRO_GOST4(24, 28)
78.     MACRO_GOST4(0,  4)
79.     MACRO_GOST4(8,  12)
80.     MACRO_GOST4(16, 20)
81.     MACRO_GOST4(24, 28)
82.     MACRO_GOST4(28, 24)
83.     MACRO_GOST4(20, 16)
84.     MACRO_GOST4(12, 8)
85.     MACRO_GOST4(4,  0)
86.  
87.     _asm
88.     {
89.         pop     ebp
90.         pop     ebx
91.         xor     esi,     DWORD PTR [ebx]
92.         xor     edi,     DWORD PTR [ebx+4]
93.         pop     eax
94.         mov     [eax],   esi
95.         mov     [eax+4], edi
96.         add     ebx,     8
97.         add     eax,     8
98.         sub     uCount,  8
99.         jnz     up
100.         popad
101.     }
102. }
103.  

 

2all: а если разбить узел замены на 4 части и заюзать xlatb? Насколько это лучше по сравнению с movzx?

 

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

 

Вопрос по теме: а какую скорость уважаемые коллеги ожидали бы увидеть (или видели) от реализации ГОСТ-28147 на 32-х разрядном MIPS, работающем на 100 мегагерцах? (Шифрование память-память, SDRAM)

В килобайтах/секунду, или в чем её в этом случае мерять логичнее?

(Использование кэша процессора, внутренней его памяти (CRAM) - детали реализации, но все равно интересно как они могут повлиять на конечный результат...)