En smule samling

August 29, 2009 ved Prashant ·

Efter at have læst denne artikel om lock gratis buffere og se brugen af CAS (sammenlign og bytte), følte jeg at udgive en samling kode til at gøre det samme. Brug sag, der var at skrive en indfødt metode og kalder den fra Java (tilbage i 1,5, når samtidige datastrukturer i Java var mere eller mindre ikke eksisterende). Uden videre, vil jeg frigøre koden på dig . Først er for CAS, og andet er for computing GCD bruge Euklids algoritme (denne kan findes mange steder og selvstudier såvel).

Kompiler og kør instruktioner gcc file_name.c ; ./a.out

Sammenlign og Swap

   # Include 
  # Include 
 / / Ombytning - newvalue, comperand er gammel / forventet værdi
 / *
  * Funktion faktisk gør følgende ting - hvis den værdi * dest er lig med oldvalue derefter erstatte det med newvalue ellers lade det være uændret: ikke alle disse atomically
  *
  * Der er to muligheder for returværdi
  * 1.is oprindelige værdi af * dest og overlade den byrde at kalde fxn at sammenligne det med oldval
  * 2.  gøre det her over og returnere 0 eller 1, bør dette være mere effektive
  ** /

 / * Senere ændre det til 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 resultat = 1 ;/ * 1 viser, at CAS lykkedes og 0 viser, at det mislykkede * /
	 / * Btw nødt til at indstille cc for flag 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" / * skal låsen på samme linje * /
			 "Jz FÆRDIG \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "FÆRDIG: \ n \ t"
			 : "= M" (DEST), "= g" (resultat)
			 : "G" (oldvalue), "g" (newvalue), "m" (DEST)
			 : "% Eax", "% EBX", "ECx", "cc"
			 );
	 printf ("(% d,% d,% d)", * dest, oldvalue, newvalue);
	 tilbage resultat;
 }

 / * TODO
  * Skrive en anden asm fxn, der sætter over fxn i en while-løkke og holde prøver, medmindre det lykkes * /

 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 ("at ændre værdien af * C til% 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;
 }

Formatering noter - synes ligesom WP syntaks highlighter tilføjer i sidste ende, ignorere det.

GCD

 # Include 
 int gcd (int a, int b) {
     int resultat;
     / * Compute største fælles divisor med Euklids algoritme * /
     __asm__ __ volatile__ ("movl% 1,%% EAX;"
                           "Movl% 2%% EBX"
                           "CONTD: cmpl $ 0,%% EBX;"
                           "Je FÆRDIG;"
                           "Xorl%% EDX,%% EDX"
                           "Idivl%% EBX"
                           "Movl%% EBX,%% EAX"
                           "Movl%% EDX,%% EBX"
                           "Jmp CONTD;"
                           "FÆRDIG: movl%% eax,% 0": "= g" (resultat): "g" (a), "g" (b)
     );

     tilbage resultat;
 }

 int main () {
     int første, andet;
     printf ("Indtast to heltal:");
     scanf ("% d% d", og første, og anden);

     printf ("GCD af% d &% d er% d \ n", første, andet, GCD (første, andet));

     return 0;
 }