INTRODUCCION
Hola all!
Aquí estamos con la primera entraga del curso básico. Para seguirlo
basta con haber hecho algún COM-EXE en ensamblador, saber lo que es una
interrupción, los segmentos y tener nociones generales de las
instrucciones. Si no es así pasaros antes por el curso de ASM de
Pablo Barrón ;)
Voy a dividir este capítulo en dos, optimizaciones del 386, y las
del 486/Pentium.
Otra cosa, no es lo mismo optimizar para velocidad que para tamaño,
aquí voy a poner optimizaciones para velocidad.
OPTIMIZACION EN EL 386
La mayor ventaja que nos ofrece el ensamblador es su velocidad de
ejecución. Los compiladores de C++ y Pascal han logrado un alto grado
de optimización, pero nada automático puede sustituir al programador
(aunque últimamente el WatCom est dejando pasmado a todo el mundo).
Por ejemplo, si asignamos 0 a dos segmentos el compilador hará esto:
xor ax,ax ;Esto está bien optimizado, es más rápido mov es,ax ;xor que 'mov ax,0' xor ax,ax ;Esto es lo que sobra y una persona nunca pondría. mov ds,axPor esta razón no queda más remedio que programar en ensamblador las partes del programa que requieran mayor velocidad. Las optimizaciones más generales son éstas:
lento rápido cmp ax,0 ---> or ax,ax je label ---> jz label cmp ax,bx ---> and ax,bx je label ---> jz label
or ax,ax js label
Comparación de cadenas dirección cad1 -> ES:DI dirección cad2 -> DS:DI longitud -> CX repe cmpsb Sigue hasta que cx = 0 o cad1 distinto de cad2 jcxz label
Pascal C++
Procedure test;ensamblador; * void test(void){
asm * asm{
jmp @los * jmp los
*
@var1: dw 0 * @var1: dw 0
@var2: dw 0 * @var2: dw 0 };
@los: * los:
{Resto del proc} * //Resto del proc
End; * }
Aquí en cada acceso habrá que usar word ptr o byte ptr ya
que Borland identificará @var1 y @var2 como etiquetas y no como
variables.mov bx,700 and 63,bx ;si es de 64 el array mov cx,array[bx]Para definir las tablas se puede usar el Borland en lugar de meter a mano todos los valores:
Pascal:
procedure sin_gen(var tabla:Array of word;per,amp,offset:word);
Var i:Word;
Begin
for i:=0 to per-1 do
tabla[i]:=round(sin(i*2*pi/per)*amp)+offset;
End;
C++:
void sin_gen(int *tabla, int per, int amp,int offset)
{
for(int i=0;i"<"per;i++)
tabla[i]=(int)(sin(i*2*3.1415/per)*amp)+offset;
}
Estos procs nos generaría una tabla de senos que podríamos usar
cómodamente en ASM, y funcionaría mucho más rápido.
Lento Rápido
loop label dec cx
jne label
La orden loop ha sido abandonada por los desarroladores de los
micros. Como resultado es más rápido decrementar y saltar
que hacer el loop (un 10% más rápido en los 386 y hasta un 40%
en 486). dec cx ;Aquí set compara CX y AL, si se cumple -> AL pasará a set al ;valer 1, sino 0.
largo corto
xor bh,bh movzx ax,bl (con signo sería movsx)
mov ax,bx
A pesar de ser más cómodo el MOVZX es muy lento.
imul dx,3 ;Multiplica dx por 3 y pone el resultado en dx
imul ax,dx,3 ;Multiplica dx por 3 y pone el resultado en ax
loopme: inc esi ; opcode
mov [edi+1234h],eax ; opcode, mod/rm , immediate offset
dec ecx ; opcode
jne short loopme ; opcode short_displacement
que
loopme: mov [edi+1234h],eax
inc esi
dec ecx
jne short loopme
En el primer caso se a¤ade un ciclo, en el segundo 3. Si por ejemplo
este loop fuese para copiar una imagen a pantalla de 320x200 tendríamos
add edx, 4
mov esi, [edx]
En el 486 esto sólo ocurre con instrucciones adyacentes. En el PENTIUM
el AGI ocurre incluso con instrucciones separadas 3 puestos:
add esi, 4 ;Esto lo realiza el PIPE1
pop ebx
dec ebx
mov edx, [esi] ;El PIPE2 que hace ‚sta espera a que termine el PIPE1
mov esp,ebp
pop ebp.
es ejecutado como:
mov esp,ebp
[agi] ; pop usa el ESP como puntero
pop ebp
mov spawn, 248
mov dword ptr [esp+4], 1
El 486 pierde 1 ciclo (el 586 no) cuando modifica la parte baja de
un registro DWORD que es usado inmediatamente después:
mov al,0
mov [ebp], eax
Si se pone el ALIGN del código a 16 en el 486 y a 32 en el 586 se
aceleran todas la operaciones, porque coincidir el comienzo de la
página de caché con el de tu rutina, y mientras se esté ejecutando
ésta dará tiempo a que se cargue la siguiente página. Esto acelera
sobre todo el 486.
LEA A,[B+C*INDEX+DISPLACEMENT] es m s lento que...
MOV X,C
MOV A,B
MUL X,INDEX
ADD A,DISPLACEMENT
ADD A,X
- Evitar el uso de MOVZX fuera de un LOOP, y usarlo dentro.
LEA ECX,[EDX*2] ; multiplica EDX * 2 y lo guarda en ECX
LEA ECX,[EDX+EDX*2] ;
LEA ECX,[ECX+ECX*8] ; ECX <-- EDX*27
Y mejor si pones 3 instrucciones entre los dos LEAs para evitar un
AGI en el 586
- Poner a 0 los registros con XOR.
PUSH EBP
mov EBP, ESP
sub ESP, BYTE_COUNT
- Usar JMP SHORT en lugar de JMP siempre que sea posible.1. Mov reg, reg/mem/immed 2. mov mem, reg/imm 3. ALU reg, reg/mem/immed 4. ALU mem, reg/immed 5. inc reg/mem 6. dec reg/mem 7. push reg/mem 8. pop reg 9. nop 10. lea reg/mem 11. Jmp/ Call / Jcc nearHay muchos trucos para acelerar la ejecución del código, como poner instrucciones de cadenas con REP al principio de un LOOP, o sacar el máximo rendimiento del caché, pero las iré poniendo más adelante.
code segment public 'CODE'
assume CS:code,DS:code;,ES:code,SS:code
org 100h
begin:
.386
mov al,13h
int 10h
;Comienzo de paleta 60,40,40, color 230
mov cl,255
mov bx,3f27h ;60,40
@pal0:
mov dx,03C8H
mov al,cl
cli
out dx,al
inc dx
mov al,bh
out dx,al
mov al,bl
out dx,al
out dx,al
sti
dec cx
cmp cl,69
ja short @pal0
mov bl,bh
sar bl,1
dec bh
jns short @pal0
;Fin de paleta
mov ah,9
mov dx,OFFSET Nombre
int 21h
@inicio:
mov bh,9h;950h
inc dx
@l1:
mov ax,0a000h
mov es,ax
mov ds,ax
mov di,bx
scasb
je short @term
imul di,bx,5
sub di,dx
mov ax,10
sub al,bh
sal al,3
mov ds:[di+42245],ax ;42245
mov ds:[di+42885],ax ;42885
add di,dx
mov cx,7
add di,22410
@dib:
imul si,si,371
ror si,3
mov ax,si
and ax,0010000000100000b ;;rand de 32
add ax,4b4bh ;75
stosw
stosw
stosb
sub di,325
loop short @dib
@term:
dec bx
jnz short @l1
;*************************************** call fire
mov bh,0fh
@loop0:
mov ax,ds:[bx]
add al,ah
xor ah,ah
sal ax,4
mov cl,34
div cl
cmp al,7
jb short @skip
mov ah,al
mov ds:[bx-1],ax
mov ds:[bx-321],ax
mov ds:[bx-641],ax
@skip:
inc bx
inc bx
cmp bh,130
jbe short @loop0
;********************************** End fire
in ax,60h ;Leo el teclado
cmp al,1
jnz @inicio
mov ax,03h
int 10h
ret
Nombre db 'BitSpawn$'
code ENDS
END begin
Fichero Demo compilado. (ZIP)
OPTIMIZACION By Bitspawn * Roberto Domínguez
SubNet 93:341/736.0 * FidoNet 2:341/136.0 * @70:343/14*28 Virtual Mail