Een beetje van vergadering

29 augustus 2009 door Prashant ·

Na het lezen van dit artikel over lock vrij buffers en het zien van het gebruik van CAS (te vergelijken en te wisselen), voelde ik me net als het plaatsen van de assemblage-code om hetzelfde te doen. Gebruik geval daar was om een eigen methode te schrijven en het noemen van Java (terug in 1.5, wanneer gelijktijdige datastructuren in Java waren min of meer ontbreekt). Zonder verdere omhaal, ik zal de code los te laten op je . De eerste is voor de CAS en de tweede is voor het berekenen van GCD met behulp van het algoritme van Euclides (deze is te vinden op vele plaatsen en tutorials ook).

Compileer en uitvoeren instructies gcc file_name.c ; ./a.out

Vergelijk en Swap

   # Include 
  # Include 
 / / Uitwisseling - newValue, comperand is oud / verwachte waarde
 / *
  * Functie doet eigenlijk het volgende ding - als de waarde op * dest is gelijk aan dan oldvalue te vervangen door newValue anders laat het onveranderd: niet al deze atomair
  *
  * Er zijn twee opties voor de return waarde
  * 1.is initiële waarde van * dest en laat de last van de oproep FXN te vergelijken met oldval
  * 2.  doen het hier over en weer 0 of 1, moet dit efficiënter
  ** /

 / * Later veranderen in macro * /
 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 resultaat = 1 ;/ * 1 laat zien dat cas geslaagd en 0 geeft aan dat het * niet /
	 / * Btw moeten cc voor vlag verpesten!  * /
	 __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" / * moet LOCK op dezelfde lijn * /
			 "JZ GEDAAN \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "DONE: \ n \ t"
			 : "= M" (DEST), "= g" (resultaat)
			 : "G" (oldvalue), "G" (newValue), "m" (DEST)
			 "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("(% d,% d,% d)", * DEST, oldvalue, newValue);
	 terug te keren resultaat;
 }

 / * TODO
  * Schrijf een andere asm FXN die hierboven FXN zet in de zoveel tijd loop en blijf proberen, tenzij het lukt * /

 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 ("veranderende waarde van * c om% 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;
 }

Opmaak van nota's - lijkt wp syntax highlighter is het toevoegen van op het einde, negeren dat.

GCD

 # Include 
 int ggd (int a, int b) {
     int resultaat;
     / * Compute Grootste gemene deler met behulp van het algoritme van Euclides * /
     __asm__ __ volatile__ ("movl% 1,%% eax;"
                           "Movl% 2,%% ebx;"
                           "Vervolg: cmpl $ 0,%% ebx;"
                           "Je gedaan;"
                           "Xorl%% edx,%% edx;"
                           "Idivl%% ebx;"
                           "Movl%% ebx,%% eax;"
                           "Movl%% edx,%% ebx;"
                           "Jmp Vervolg;"
                           "DONE: movl%% eax,% 0;": "= g" (resultaat): "g" (a), "G" (b)
     );

     terug te keren resultaat;
 }

 int main () {
     int eerste, tweede;
     printf ("Geef twee gehele getallen:");
     scanf ("% d% d", & eerste en tweede);

     printf ("GCD van% d &% d is% d \ n", eerste, tweede, ggd (eerste, tweede));

     return 0;
 }