Malo montažo

29. avgust, 2009 z Prashant ·

Po branju tega članka o prostih rezerv za zaklepanje in videnje uporabe CAS (primerjati in swap), sem se počutil kot objavo montažo kodo, da storijo enako. Uporabite primer več kot je bilo, da bi napisal izvirni način in jo pokličite s Java (nazaj na 1,5, ko so bili sočasno podatkovne strukture v Javi več ali manj ni). Brez odlašanja, se bom sprostil kodo na vas . Prvi je na CAS in drugo, je za računalniške GCD pomočjo Evklidovega algoritma (ta je mogoče najti v številnih krajih in vajah, pa tudi).

Pripravijo in vodijo navodila gcc file_name.c ; ./a.out

Primerjati in Swap

   # Include 
  # Include 
 / / Izmenjave - newvalue, comperand je star / pričakovana vrednost
 / *
  * Funkcija v resnici počne to stvar - če je vrednost v * destilirano vodo, je enako potem oldvalue jo nadomestiti s newvalue pa pustimo nespremenjena: vse to ne atomically
  *
  * Na voljo sta dve možnosti za vrnitev vrednosti
  * 1.is začetno vrednost * Podrobnosti destilirano vodo in pustite breme kliče fxn, da ga primerjajo z oldval
  * 2.  to storite tukaj in se vrnil 0 ali 1, bi to moralo biti bolj učinkovito
  ** /

 / * Kasneje spremenite v makro * /
 int cas (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 rezultat = 1 ;/ * 1 kaže, da je cas uspelo in 0 kaže, da ni * /
	 / * Btw morali nastaviti cc za zastava clobbering!  * /
	 __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" bi / * LOCK biti v isti vrstici * /
			 "JZ poteka \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "Sestavljeno: \ n \ t"
			 : "= M" (dest), "= g '(rezultat)
			 : "G" (oldvalue), "g" (newvalue), "M" (dest)
			 : "% EAX", "% ebx", "ECx", "cc"
			 );
	 printf ("(% d,% d,% d)", * dest, oldvalue, newvalue);
	 vrne rezultat;
 }

 / * TODO
  * Napisati še eno ASM fxn ki postavlja nad fxn v nekaj časa zanke in poskušati, če ne uspe * /

 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,,));
	 printf ("% d \ n", cas (c, b, b));
	 * C = 6;
	 / * C = 5; * /
	 printf ("spreminja vrednost * c na% d \ n", * c);
	 printf ("% d \ n", cas (c, b, b));
	 printf ("% d \ n", cas (c, b, a));
	 printf ("% d \ n", cas (c,,));
	 printf ("% d \ n", cas (c, a, b));
	 printf ("% d \ n", cas (c, b, a));
	 return 0;
 }

Oblikovanje ugotavlja - se zdi, kot wp sintakso označevalnik je dodal na koncu, da ne upoštevajo.

GCD

 # Include 
 int gcd (int a, int b) {
     int rezultat;
     / * Compute Največji skupni delitelj pomočjo Evklidovega algoritma * /
     __asm__ __ volatile__ ("movl% 1,%% EAX;"
                           "Movl% 2,%% ebx;"
                           "Nadalj.: cmpl $ 0,%% ebx;"
                           "JE SESTAVLJENO;"
                           "Xorl%% EDX, EDX%%;"
                           "Idivl%% ebx;"
                           "Movl%% ebx,%% EAX;"
                           "Movl%% EDX,%% ebx;"
                           "JMP nadalj.;"
                           "Sestavljeno: movl%% EAX,% 0;": "= g '(rezultat):" g "(a)," g "(b)
     );

     vrne rezultat;
 }

 int main () {
     int prvi, drugi;
     printf ("Vnesite dve celi števili:");
     scanf ("% d% d", & prvi, in drugo);

     printf ("GCD od% d &% d je% d \ n", prva, druga, gcd (prvi, drugi));

     return 0;
 }