Truputis susirinkimų

Rugpjūčio 29, 2009 prashant ·

Perskaičius šį straipsnį apie stabdžiu laisvų buferių ir matyti CAS naudoti, lyginti ir keistis), jaučiau kaip parašėte surinkimo kodą daryti tą patį. Naudokite bylą ten buvo parašyti gimtoji metodą ir jį vadiname iš Java (1,5, kai tuo pačiu metu duomenų struktūros Java buvo daugiau ar mažiau ne visai). Be tolesnio ceremonija, aš ant jūsų atskleisti kodą . Pirmasis yra CAS ir antra skaičiavimo GCD naudojant Euklido algoritmą galima rasti daugelyje vietų ir vadovėliai, taip pat tai vienas).

Sudaryti ir, paleisti instrukcijas gcc file_name.c ; ./a.out

Palyginti ir Swap

   # Include 
  # Include 
 / / Mainai - newvalue comperand metai / laukiama vertė
 / *
  * Funkcija iš tiesų šį dalyką - jei vertė yra lygi, į oldvalue tada pakeisti jį newvalue dar palikti jį nepakeistą * dest: padaryti visus šiuos atominių
  *
  * Yra du variantai sugrįžimo vertę
  * 1.is pradinė vertė * dest ir palikti kurios skambinama fxn, našta, palyginti ją su oldval
  * 2.  padaryti čia ir grąžina 0 arba 1, tai turėtų būti efektyvesnė
  ** /

 / * Vėliau pakeisti jį į makrokomandos * /
 LC 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 rezultatas = 1 ;/ * 1 rodo, kad cas pavyko ir 0 rodo, kad ji nesugebėjo * /
	 / * BTW reikia nustatyti kubinių centimetrų vėliava clobbering!  * /
	 __asm__ __ volatile__ (
			 "Movl% 2% EAX \ n \ t"
			 "Movl% 3%% ebx \ n \ t"
			 "Movl% 0%% ECX \ n \ t"
			 "UŽRAKTAS \ n \ t"
			 "CMPXCHG% ebx (% ECX), \ n \ t" / * LOCK būti toje pačioje eilutėje * /
			 "JZ PRIIMTA \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "Priimta: \ n \ t"
			 : "=" (DEST), "= g (rezultatas)
			 : G (oldvalue), "g" (newvalue), "M" (dest)
			 : "% EAX", "% ebx", "ECX", "CC"
			 );
	 printf ("(% d% d,% d)" * dest, oldvalue, newvalue),;
	 grįžti rezultatas;
 }

 / * TODO
  * Rašyti kitą ASM fxn, kuris ištaisytų virš fxn į while cikle ir nuolat bando, kol negalės * /

 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));
	 printf ("% d \ n", CAS (c,));
	 printf ("% d \ n", CAS (C, B, b));
	 * C = 6;
	 / * C = 5 * /
	 printf ("Kintantis vertė * 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));
	 grįžti 0;
 }

Formatavimo pažymi - atrodo kaip wp sintaksės žymėjimą didina galų gale, ignoruoti.

GCD

 # Include 
 LC gcd (int, int b) {
     LC rezultatas;
     / * Apskaičiuokite didžiausias bendras daliklis, Euklido "algoritmas * /
     __asm__ __ volatile__ ("movl% 1%% EAX;"
                           "Movl% 2% ebx;"
                           "CONTD: cmpl $ 0,%% ebx;"
                           "Je PADARYTA;"
                           "Xorl%% EDX,%% EDX;"
                           "Idivl% ebx;"
                           "Movl%% ebx,%% EAX;"
                           "Movl%% EDX, ebx%%;"
                           "JMP CONTD,;"
                           "Priimta: movl%% EAX,% 0;": "= g (rezultatas):" g "a" G "(b)
     );

     grįžti rezultatas;
 }

 int main () {
     int 1. antra;
     printf ("Įveskite du sveikieji skaičiai:");
     scanf ("% d% d", & pirma, ir antrasis);

     printf ("% d ir% d GCD yra% d \ n", pirma, antra, gcd (pirmas, antras));

     grįžti 0;
 }