Ein bisschen Montage

29. August 2009 von prashant
Filed under: Technik

Nach dem Lesen dieses Artikels über lock freien Puffer und sehen den Einsatz von CAS (zu vergleichen und Swap), fühlte Ich mag die Buchung der Assembler-Code, um das gleiche zu tun. Use Case über gab es eine native Methode schreiben und nennen es aus Java (zurück in 1,5, wenn gleichzeitige Datenstrukturen in Java mehr oder weniger nicht existent waren). Ohne weitere Umschweife, werde ich den Code auf Sie zu entfesseln . Zunächst ist für CAS und zweite ist für die Berechnung GCD mit Euklids Algorithmus (dies kann man an vielen Orten und Tutorials sowie zu finden).

Kompilieren und starten Sie Anweisungen gcc file_name.c ; ./a.out

Vergleichen und Swap

   # Include 
  # Include 
 / / Tauschen - newvalue ist comperand alt / Erwartungswert
 / *
  * Funktion tatsächlich die folgenden Sache - wenn der Wert an * dest entspricht dann OldValue ersetzen Sie ihn durch newvalue sonst lässt sie unverändert: all diese atomar
  *
  * Es gibt zwei Optionen für Rückgabewert
  * 1.is Anfangswert * dest und lassen die Last der Berufung FXN es mit oldval vergleichen
  * 2.  do it over hier und return 0 oder 1, sollte dies effizienter sein
  * * /

 / * Später ändern sie in 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 result = 1; / * 1 zeigt, dass cas gelungen und 0 zeigt, dass es * / nicht bestanden
	 / * Btw müssen cc für flag clobbering gesetzt!  * /
	 __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" / * sollte auf der gleichen Linie LOCK * /
			 "Jz DONE \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "DONE: \ n \ t"
			 : "= M" (dest), "= g" (Ergebnis)
			 : "G" (OldValue), "g" (newvalue), "m" (dest)
			 : "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("(% d,% d,% d)", * dest, OldValue, newvalue);
	 return result;
 }

 / * TODO
  * Write anderen asm FXN die oben FXN stellt in einer while-Schleife und immer wieder versuchen, wenn es * / Nachfolge

 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 ("changing Wert von * c% 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;
 }

Formatieren von Notes - scheint wie wp Syntax-Highlighter ist das Hinzufügen von am Ende ignorieren.

GCD

 # Include 
 int gcd (int a, int b) {
     int result;
     / * Berechne Größter gemeinsamer Teiler mit Euklids Algorithmus * /
     __asm__ __volatile__ ("movl% 1,%% eax;"
                           "Movl% 2,%% ebx;"
                           "Forts.: kpl $ 0,%% ebx;"
                           "Je DONE;"
                           "Xorl%% edx,%% edx;"
                           "Idivl%% ebx;"
                           "Movl%% ebx,%% eax;"
                           "Movl%% edx,%% ebx;"
                           "Jmp Forts.;"
                           "DONE: movl%% eax,% 0;": "= g" (Ergebnis): "g" (a), "g" (b)
     );

     return result;
 }

 int main () {
     int erste, zweite;
     printf ("Geben Sie zwei Zahlen:");
     scanf ("% d% d", & erste & zweite);

     printf ("GCD von% d &% d ist% d \ n", erste, zweite, gcd (erste, zweite));

     return 0;
 }