Un po 'di assemblaggio

29 Agosto 2009 da Prashant
Archiviato in: Tecnologia

Dopo aver letto questo articolo su buffer Lock Free e vedere l'uso del CAS (confrontare e scambiare), mi sentivo come la pubblicazione del codice assembly a fare lo stesso. Utilizzare caso su quello che c'era da scrivere un metodo nativo e chiamare da Java (back in 1.5, quando concomitanti strutture dati in Java erano 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 e).

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

Confronta e Swap

   # Include 
  # Include 
 / / Exchange - newvalue, comperand è vecchio / valore atteso
 / *
  * Funzione realmente fa la seguente cosa - se il valore a * dest è pari a OldValue poi sostituirlo con altro newvalue lasciarlo invariato: non tutti questi atomicamente
  *
  * Ci sono due opzioni per il valore di ritorno
  * Valore iniziale di 1.is * dest e lasciare l'onere della FXN chiama a confronto con oldval
  * 2.  farlo qui e restituire 0 o 1, questo dovrebbe essere più efficiente
  ** /

 / * Successivamente modificare 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 newvalue, int OldValue) {* /
	 int risultato = 1 ;/ * 1 mostra che cas succeduti e 0 mostra di non aver * /
	 / * Btw necessario impostare cc per la bandiera sovrascrivere!  * /
	 __asm__ __ volatile__ (
			 "Movl% 2,%% eax \ n \ t"
			 "Movl% 3,%% ebx \ n \ t"
			 "Movl% 0,%% ecx \ n \ t"
			 "LOCK \ n \ t"
			 "Cmpxchg% ebx%, (%% ecx) \ n \ t" / * deve bloccare 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 al di sopra FXN in un ciclo while e continuare a provare 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 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 è l'aggiunta di alla fine, ignorarlo.

GCD

 # Include 
 int gcd (int a, int b) {
     int risultato;
     / * Calcola Massimo Comun utilizzando 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, gcd (primo, secondo));

     return 0;
 }