Un po 'di assemblaggio

29 Agosto 2009 da Prashant ·

Dopo aver letto questo articolo su buffer di blocco libero e di vedere l'utilizzo di CAS (confrontare e swap), mi sentivo come inviando il codice assembly a fare lo stesso. Utilizzare caso oltre quello che c'era da scrivere un metodo nativo e chiamarlo da Java (di nuovo nella 1.5, quando concomitanti strutture dati in Java sono stati più o meno inesistente). Senza ulteriori indugi, farò scatenare il codice su di te . Il primo è per il CAS e la seconda è per il calcolo MCD utilizzando l'algoritmo di Euclide (questo può essere trovato in molti luoghi e tutorial pure).

Compilare ed eseguire istruzioni gcc file_name.c ; ./a.out

Confronta e Swap

   # Include 
  # Include 
 / / Scambio - nuovovalore, comperand è vecchio / valore atteso
 / *
  * Funzione fa effettivamente la cosa seguente - se il valore a * dest è pari a OldValue poi sostituirlo con altro nuovovalore lasciarlo invariato: fare tutte queste atomicamente
  *
  * Ci sono due opzioni per il valore di ritorno
  * 1.is valore iniziale di * dest e lasciare l'onere di chiamare FXN di confrontarla con oldval
  * 2.  farlo qui e restituire 0 o 1, questo dovrebbe essere più efficiente
  * * /

 / * Poi cambiarlo in macro * /
 cas int (int * dest, int OldValue, int newValue) {
	 printf ("% (d,% d,% d)", * dest, OldValue, newValue);
	 / * Int cas (int dest, int OldValue, int newValue) {* /
	 / * Int cas (int dest, int nuovovalore, int OldValue) {* /
	 int risultato = 1 / * 1 mostra che cas riuscito e 0 indica che non è riuscito * /
	 / * Btw necessario impostare cc per sovrascrivere bandiera!  * /
	 __asm__ __volatile__ (
			 "Movl% 2,%% eax \ n \ t"
			 "Movl% 3,%% ebx \ n \ t"
			 "0% movl,%% ecx \ n \ t"
			 "LOCK \ n \ t"
			 "Cmpxchg% ebx%, (%% ecx) \ n \ t" / * BLOCCO dovrebbe essere sulla stessa linea * /
			 "Jz FATTO \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "DONE: \ n \ t"
			 : "= M" (dest), "= g" (risultato)
			 : "G" (OldValue), "g" (newValue), "m" (dest)
			 : "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("% (d,% d,% d)", * dest, OldValue, newValue);
	 return risultato;
 }

 / * TODO
  * Scrivere un altro FXN asm che mette sopra FXN in un ciclo while e continuare a provare a meno che non riesca * /

 int main () {
	 int a = 5, b = 6;
	 int * c = (int *) malloc (sizeof (int));
	 * C = 6;
	 / * Int c = 6; * /
	 printf ("% d \ n", cas (c, b, b));
	 printf ("% d \ n", cas (c, b, a));
	 printf ("% d \ n", cas (c, a, a));
	 printf ("% d \ n", cas (c, b, b));
	 * C = 6;
	 / * C = 5; * /
	 printf ("cambiando il valore di c * a% d \ n", * c);
	 printf ("% d \ n", cas (c, b, b));
	 printf ("% d \ n", cas (c, b, a));
	 printf ("% d \ n", cas (c, a, a));
	 printf ("% d \ n", cas (c, a, b));
	 printf ("% d \ n", cas (c, b, a));
	 return 0;
 }

Note formattazione - sembra evidenziatore wp sintassi è aggiunta alla fine, ignorare questo.

GCD

 # Include 
 int gcd (int a, int b) {
     int risultato;
     / * Calcola massimo comun divisore con l'algoritmo di Euclide * /
     __asm__ __volatile__ ("movl% 1,%% eax;"
                           "Movl% 2,%% ebx;"
                           "Contd: cmpl $ 0,% ebx%;"
                           "Je FATTO;"
                           "Xorl%% edx,%% edx;"
                           "Idivl%% ebx;"
                           "Movl% ebx%,%% eax;"
                           "Movl%% edx,% ebx%;"
                           "Jmp cont;"
                           "DONE: movl%% eax,% 0;": "= g" (risultato): "g" (a), "g" (b)
     );

     return risultato;
 }

 int main () {
     int primo, secondo;
     printf ("Inserire due interi:");
     scanf ("% d% d", & primo, & secondo);

     printf ("MCD di d &%% d è% d \ n", primo, secondo, mcd (primo, secondo));

     return 0;
 }