Een beetje van de montage

29 augustus 2009 door Prashant ·

Na het lezen van dit artikel over lock vrij buffers en het zien van het gebruik van CAS (vergelijk en swap), voelde ik me net als het plaatsen van de assembly code om hetzelfde te doen. Use case 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 op je los te laten . De eerste is voor de CAS en de tweede is voor het berekenen van GCD met behulp van het algoritme van Euclides (deze zijn te vinden in vele plaatsen en tutorials ook).

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

Vergelijk en Swap

   # Include 
  # Include 
 / / Ruil - newValue, comperand is oud / verwachte waarde
 / *
  * Functie doet eigenlijk het volgende ding - als de waarde van * dest gelijk is aan dan oldvalue te vervangen door newValue anders laat het onveranderd: al deze atomair
  *
  * Er zijn twee opties voor return waarde
  * 1.is initiële waarde van * dest en laat de last van roeping fxn om het te vergelijken met oldval
  * 2.  doe het hier over en weer 0 of 1, dient dit te worden 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 result = 1; / * 1 laat zien dat CAS geslaagd en 0 toont aan dat het * / is mislukt
	 / * Btw moeten cc set voor vlag beuken!  * /
	 __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 worden op dezelfde lijn * /
			 "JZ DONE \ 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);
	 return resultaat;
 }

 / * TODO
  * Schrijf een andere asm fxn, die boven fxn zet in een while-lus 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 notities - lijkt wp syntax markeerstift is het toevoegen van in het einde, negeren dat.

GCD

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

     return 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;
 }