Ein bisschen Montage

29. August 2009 von Prashant ·

Nach dem Lesen dieses Artikels über Lock freien Puffern und sehen den Einsatz von CAS (vergleichen und Swap), fühlte ich mich wie die Buchung der Assembler-Code, um das Gleiche zu tun. Verwenden Sie bei drüben war 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 zur Berechnung von ggT mit Euklidischen Algorithmus (dies kann man an vielen Orten und Tutorien sowie zu finden).

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

Vergleichen und Tauschen

   # Include 
  # Include 
 / / Austausch - newvalue ist comperand alt / Erwartungswert
 / *
  * Funktion tatsächlich die folgende Sache - wenn der Wert an * dest gleich OldValue dann ersetzen Sie ihn durch newvalue sonst lässt sie unverändert: Sie alle diese atomar
  *
  * Es gibt zwei Optionen für Rückgabewert
  * 1.is Anfangswert * dest und lassen Sie die Last der Aufruf FXN, um es mit oldval vergleichen
  * 2.  tun es hier und kehren 0 oder 1, sollte dies effizienter sein
  ** /

 / * Später ändern sie in Makros * /
 CAS int (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 fehlgeschlagen * /
	 / * Btw müssen ccm für Flagge 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 \ n \ t FERTIG"
			 "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 ergebnis;
 }

 / * TODO
  * Schreiben Sie einen anderen asm FXN die über FXN bringt eine 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 ("wechselnden Wert von * C bis% 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 am Ende ignorieren.

GCD

 # Include 
 int ggT (int a, int b) {
     int result;
     / * Berechne Größter gemeinsamer Teiler mit Euklidischen 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 ergebnis;
 }

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

     printf ("ggT von% d &% d ist% d \ n", erste, zweite, ggT (erster, zweiter));

     return 0;
 }