FSUB % ST (1), % ST (0) # ST (0) ST (0) ST (1) FSUB %ST(0), %ST(1) # ST (1) ST (0) ST (1) #cima alla pila ST(0) / ST(1)

Transcript

1 ADD intero:.long 1000 reale:.double 0.5 FIADDL intero # ST (0) ST (0)+intero FADDL reale # ST (0) ST (0)+reale FADDL %st(0), %ST(3) # ST (3) ST (3)+ ST (0) FADDP # ST (1) ST (1)+ ST (0) pop il destinatario, se non specificato è sempre in cima alla pila SUBTRACT1 intero:.long 1000 reale:.double 0.5 FISUBL intero # ST (0) ST (0) - intero FSUB % ST (1), % ST (0) # ST (0) ST (0) ST (1) FSUB %ST(0), %ST(1) # ST (1) ST (0) ST (1) FSUBP #cima alla pila ST(0)-ST(1) DIVIDE intero:.long 1000 reale:.double 0.5 FIDIVL intero # ST (0) ST (0) / intero FDIV % ST (1), % ST (0) # ST (0) ST (0) / ST (1) FDIV %ST(0), %ST(1) # ST (1) ST (0) / ST (1) FDIVP #cima alla pila ST(0) / ST(1) Esempio programma: (supponiamo A e B double) 1 FLDL A 2 FLDL B 2 FSUBRP 2 FLDL C 2 FLDLD 3 FADDP 4 FMULP

2 A A-B A-B (A-B)*C+D B C C+D D Esempio programma 2: (supponiamo A e B double) 1 FCOMPP 2 FSTSW 2 AND $0x4100, %AX 2 CMP $0x0000, %AX JE st_maggiore JNE min_uguale pila ZF CF 6 0 C3 C0 mi dicono la stessa cosa come quando faccio i conti con i naturali FCOMI(P) FCOMI %ST(1), %ST(0) JB min_uguale tutto ciò sostituisce l esempio di programma 2 di prima

3 Direttive FPU.FLOAT 1.3 #32 bit.double +15e-4 #64 bit 1.5*10^(-4).TFLOAT #80 bit NO!.QUAD #int su 64 bit NO! Debbuger: tutte le direttive su: info float x/nf g &indirizzo #f per i float, G=gigant 8 byte (64 bit) reale:.float 1.5 reale2:.double -32e+15 x/1fn &reale x/1fg &reale2 COSTANTI se metto le variabili nella parte text non possono essere riscritte.text diecicinque:.float 10.5 numerocinque:.double -5.0 FLDS diecicinque FLDL numerocinque solo per costanti intere posso usare la pila 10 FPU PUSHW $10 FILDS (%ESP) 5 PUSHW $5 FILDS (%ESP) #riporto lo stack com era prima ADD $4, %ESP SOTTOPROGRAMMI FPU sott: PUSH POP RET #ora ho le mie costanti che nessuno può toccare

4 convenzioni: 1) inizialmente la FPU è vuota 2) va lasciata vuota tranne che: 3) se il sottoprogramma ha valore di ritorno reale, ci deve essere un unico registro occupato che è ST(0), con il valore di ritorno supponiamo che alla fine di un programma siamo in questo stato ST(3) ST(2) ST(1) ST(0) risltato FXCH %ST(3) FCOMPP FCOMP ST(0) risltato chi chiama il sotto programma deve lasciare la pila libera, allora, dopo il sottoprogramma: CALL sottoprog FSTP ISTRRUZIONI DI CONFRONTO: F(I)COM(P) setta i bit c3_c0 e possono essere portati in AX con FSTSW e con delle AND si possono fare dei salti condizionati FCOMI setta il CF e lo ZF e consente di usare i salti condizionati come se dovessimo lavorare con interi Istruzione alternativa a queste: AH c3 c0 ZF CF F(I)COM(P) -> c3_c0 ->FSTSW -> SAHF -> Jcond Se a, b reali

5 if (a==b) if(fabs (a-b)<p*fabs(a)) // p fattore di precisione dell ordine è più prescisa EFFICIENZA: c++ algoritmi exe compilatore Assembler assemblatore Il codice che va in esecuzione è tanto efficiente quanto è efficiente il programma che li si da.. in c++ il compilatore ottimizza, in assembler non c è il compilatore che ottimizza Come ottimizzare: fase di FETCH operandi: - registri - memoria MOVL $0, %EAX // $0 è su 32 bit e prende tempo // 5 byte in memoria questa istruzione viene ottimizzata con: XOR %EAX, %EAX //1byte in memoria nei manuali si può trovare l informazione di quanto un istruzione si svolge in cicli di clock. Al processore costa a livello di ALU: - ist operative (costano poco 1-3, a accezione di moltiplicazioni e divisioni, che sono qualche decina di cicli di clock) - ist di controllo (JMP, CALL costano leggermente di più delle ist operative, costano molto di più in esecuzione) a livello di FPU: - ist aritmetiche (costano poco 1-3, a accezione di moltiplicazioni e divisioni, che costano molto, invece: radice quadrata, sin.. costano troppo (100 clock))

6 Non è possibile dalla lista del costo delle istruzioni desumere la durata di un programma Un programma è diverso da un processo!! Un programma è un foglio di testo, un processo è: - un programma - dati di ingresso - ambiente (hw/sw) - stato Non si può misurare un programma, si può misurare un processo in base all elenco di prima. Perché è difficile calcolare il tempo del processo: 1) multitasking 2) clock non ha velocità costante 3) memori cache 4) Il processore ha una coda di prefetch perché il processore non lavora come un entità unica ma è strutturato come una catena di montaggio, che coinvolgono strutture differenti che possono essere eseguite in parallelo. 5) l esecuzione è in genere non sequenziale Per ottimizzare: 1) allineamento dati e codice 0x 0 0x 1 0x 2 0x 3 0x 4 0x 5 0x 6 0x 7 x x x x byte consecutivi byte consecutivi MOVL $0, 0x.2 richiede 2 accessi alla memoria, anche se è possibile fare accessi alla memoria a 4 byte, infatti posso farlo a 4 byte solo se sono allineati a multipli di 2, 4 byte.data a:.byte 3 # k 16 b:.long 500 # k si dichiarano le variabili a seconda dell ordine di grandezza, prima tutti I long, poi tutti i word, infine tutti i byte.

7 oppure il modo furbo è:.balign N,F #è una direttiva con 2 parametr, Fè opzionale, messa #prima di una dichiarazione fa si che la #successiva variabile venga allineata a un multiplo di #N, in F c è il valore che voglio mettere dove vuoto.data a:.byte 3 # k 16.BALIGN 4,0 b:.long 500 # k x 0 a 0x 1 0 0x 2 0 0x 3 0 0x 4 0x 5 0x 6 b 0x 7 byte consecutivi byte consecutivi allineamento delle istruzioni: conviene allineare le istruzioni quando siamo sicuri che io da una istruzione all altra non ci posso passare.text Ist_1 # k 16 Ist_2 Ist_3 (RET /JMP).BALIGN 16,0 Ist_4 2) evitare MUL/DIV LEA disp(base, indice, scala), dest #sposta un indirizzo dentro un #destinatario dest= disp + base + indice * scala R32 I32 R32 R32 1,2,4,8 LEA dura un clock o poco più.. volendo calcolare Z=25X+3Y con Z, X e Y dei LONG ingegnere della strada: PUSH %EDX MOV Y, %EAX MOV $3, %EBX MUL %EBX #32

8 SUB $13500, %EAX MOV %EAX, Z #ho salvato in Z: 3Y MOV X, %EAX MOV $25, %EBX MUL %EBX ADD %EAX, Z POP %EDX sfruttando la LEA: MOV Y, %EAX LEA 13500(%EAX, %EAX,2), %EAX #ho salvato in Z: 3Y MOV X, %EAX LEA (%EBX,%EBX,4), %EBX # 5 LEA (%EBX,%EBX,4), %EBX # 5*5 ADD %EBX, %EAX MOV %EAX, Z è meglio usare poche SHL e LEA al posto di una MUL o una DIV 3) preferire istruzioni stringa quando ci sono vettori in memoria è estremamente più efficiente usare le operazioni stringa. 4) evitare salti condizionati ----non in sequenza---> costano molto Jcon ----in sequenza > costa poco, è meglio se va dritta (la JMP sia nulla) perché spende poco I salti condizionati fanno riferimento al reg dei flag. ADC e SBB usano il carry flag come operando comp: CMP $0, %EAX JE fine SHR %EAX ADC $0, %CL JMP comp al posto di ADC $0, %CL si poteva mettere JC /JNC ma costa molto di più Altre istruzioni: SETcon dest dest è un registro o una memoria a 8 bit, se con è vera dest vale 1, altrimenti vale 0.

9 CMOVcon src,dest src è un reg (16 o 32 bit) o una memoria (16 o 32 bit), il destinatario è un reg (16 o 32 bit) se la condizione è vera fa la MOV, altrimenti no. NON funziona su DoxBox. a = ( x > y )? x : y AX DX BX CMP %DX, %BX JA dopo MOV %DX, %AX JMP fine dopo: MOV %BX, %AX fine: si può scrivere: CMP %DX, %BX CMOVA %BX, %AX CMOVBE %DX, %AX Come si fanno un po di misure: TSC p un reg a 64 bit (rimesto counter) questo registro può essere letto con l istruzione: RDTSC che porta TSC in EDX_EAX Se si vuole misurare un pezzo di codice:.data ts_lo:.long 0 ts_hi:.long 0 RDTSC MOV %EDX, ts_hi MOV %EAX, ts_lo #CODICE da esaminare RDTSC SUB ts_lo, %EAX SBB ts_hi, %EDX in EAX_EDX c è il tempo del codice più le prime tre operazioni (effetto sonda) qword_output stampa il numero naturale dentro EAX_EDX (quanto c ha messo il processore a eseguire il codice)