Un po 'di montaggio

29 Agosto 2009 da Prashant
Archiviato in: tecnologia

Dopo aver letto questo articolo su blocco buffer libero e vedere l'uso della CAS (confronta e swap), mi sentivo come la pubblicazione del codice assembly a fare lo stesso. caso d'uso laggiù era quello di scrivere un metodo nativo e chiamare da Java (torna in 1.5, quando concomitanti structures data in Java sono stati more o meno non esiste). Senza ulteriori indugi, farò scatenare il codice su di te . La prima è per i CAS e il secondo è per il calcolo del MCD con l'algoritmo di Euclide (questo può essere trovato in molti luoghi e tutorial oltre).

ed eseguire le istruzioni di compilazione gcc file_name.c ; ./a.out

Confronta e Swap

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

 / * Poi si trasformano in macro * /
 cas int (int * dest, int oldValue, nuovo_valore int) (
	 printf ("(% d,% d,% d)", * dest, oldValue, newValue);
	 / * Int cas (DEST int, int oldValue, nuovo_valore int) (* /
	 / * Int cas (DEST int, int nuovo_valore, oldValue int) (* /
	 int risultato = 1; / * 1 mostra che cas riuscito e 0 indica che non è riuscito * /
	 / * BTW necessità di impostare cc per sovrascrivere bandiera!  * /
	 __asm__ __volatile__ (
			 "Movl% 2,%% eax \ t \ n"
			 "Movl% 3,%% ebx \ t \ n"
			 "Movl% 0,%% ecx \ t \ n"
			 "LOCK \ n \ t"
			 "Cmpxchg% ebx%, (% ecx%) \ n \ t" / * dovrebbe bloccare essere sulla stessa linea * /
			 "JZ FATTO \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "FATTO: \ n \ t"
			 : "= M" (DEST), "= g" (risultato)
			 : "G" (oldValue), "g" (nuovo_valore), "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 ("valore di cambio della 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;
 )

Formattazione osserva - sembra evidenziatore wp sintassi è l'aggiunta di alla fine, ignorare questo.

GCD

 # Include 
 int MCD (int a, int b) (
     int risultato;
     / * Calcolare il massimo comune 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%;"
                           "Ebx movl%%,% eax%;"
                           "Movl%% edx,% ebx%;"
                           "Jmp CONTD;"
                           "FATTO: movl% eax%,% 0;": "= g" (risultato): "g" (a), "g" (b)
     );

     return risultato;
 )

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

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

     return 0;
 )