Hieman kokoonpano

29 elokuu 2009 by Prashant ·

Kun olet lukenut tämän artikkelin lukko vapaita puskureita ja nähdä käyttöön CAS (vertaa ja vaihtaa), tunsin itseni lähettämistä assembly tekemään samoin. Käytä tapauksessa tuolla oli kirjoittaa natiivi menetelmä ja kutsuvat sitä Java (takaisin 1,5, kun samanaikaisesti tietorakenteita Java olivat enemmän tai vähemmän olematon). Pitemmittä puheitta, minä valloilleen koodia sinuun . Ensimmäinen on CAS ja toinen on tietotekniikan GCD käyttää Eukleideen algoritmi (tämä löytyy monin paikoin ja tutorials samoin).

Käännä ja suorita ohjeet gcc file_name.c ; ./a.out

Vertaa ja Swap

   # Include 
  # Include 
 / / Vaihto - newvalue, comperand on vanha / odotusarvo
 / *
  * Toiminto itse asiassa tekee seuraavat asia - jos arvo * dest on sama oldvalue sitten korvata newvalue muuten jätä se ennallaan: eivät kaikki nämä atomisesti
  *
  * On kaksi vaihtoehtoa paluuarvon
  * 1.is alkuarvo * dest ja jättää taakan kutsuvan fxn verrata sitä oldval
  * 2.  tekevät sen tänne ja palauttaa 0 tai 1, tämä olisi tehokkaampaa
  ** /

 / * Myöhemmin vaihtaa sen 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 tulos = 1 ;/ * 1 osoittaa, että CAS onnistunut ja 0 osoittaa, että se epäonnistui * /
	 / * Btw tarvitse asettaa CC lippu 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" / * pitäisi lukita olla samalla rivillä * /
			 "JZ DONE \ n \ t"
			 "Movl 0 dollaria,% 1 \ n \ t"
			 "DONE: \ n \ t"
			 : "= M" (dest), "= g" (tulos)
			 : "G" (oldvalue), "g" (newvalue), "m" (dest)
			 : "% EAX", "% EBX", "ECx", "CC"
			 );
	 printf ("(% d,% d,% d)", * DEST, oldvalue, newvalue);
	 palata tulos;
 }

 / * TODO
  * Kirjoittaa toisen asm fxn joka asettaa edellä fxn ja while-silmukka ja pitää yrittää jos se onnistuu * /

 int main () {
	 int = 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));
	 printf ("% d \ n", CAS (C,,));
	 printf ("% d \ n", CAS (c, b, b));
	 * C = 6;
	 / * C = 5; * /
	 printf ("muuttaminen arvo * c% d \ n", * c);
	 printf ("% d \ n", CAS (c, b, b));
	 printf ("% d \ n", CAS (C, B));
	 printf ("% d \ n", CAS (C,,));
	 printf ("% d \ n", CAS (C,, b));
	 printf ("% d \ n", CAS (C, B));
	 return 0;
 }

Muotoilu toteaa - näyttää wp syntaksin korostus on lisätä lopulta sivuuttaa sitä.

GCD

 # Include 
 int syt (int, int b) {
     int tulos;
     / * Lasketaan Suurin yhteinen tekijä käyttää Eukleideen algoritmi * /
     __asm__ __ volatile__ ("movl% 1,%% EAX;"
                           "Movl% 2,%% EBX;"
                           "CONTD: CMPL 0 dollaria,%% EBX;"
                           "Je tehty;"
                           "Xorl%% EDX,%% EDX;"
                           "Idivl%% EBX;"
                           "Movl%% EBX,%% EAX;"
                           "Movl%% EDX,%% EBX;"
                           "JMP CONTD;"
                           "DONE: movl%% EAX,% 0," "= g" (tulos): "g" (), "g" (b)
     );

     palata tulos;
 }

 int main () {
     int ensimmäinen, toinen;
     printf ("Anna kaksi kokonaislukua:");
     scanf ("% d% d", ja ensimmäinen, ja toinen);

     printf ("GCD% d-% d ovat% d \ n", ensimmäinen, toinen, syt (ensimmäinen, toinen));

     return 0;
 }