A bit ng pagpupulong

Agosto 29, 2009 sa pamamagitan ng prashant ·

Pagkatapos ng pagbabasa ng artikulong ito tungkol sa lock libreng buffers at makita ang paggamit ng Cas (ihambing at magpalitan), ako nadama tulad ng pag-post ng pagpupulong code upang gawin ang parehong. Gamitin ang kaso sa nagkaroon na magsulat ng isang katutubong paraan at tawagan ang mga ito mula sa Java (pabalik sa 1.5, kapag kasabay data na istraktura sa Java ay higit pa o mas mababa hindi umiiral). Nang walang karagdagang linggal, kukunin ko na mapalabas ang code papunta sa iyo . Ang una ay para sa Cas at pangalawa ay para sa computing GCD gamit Euclid ng algorithm (isa na ito ay matatagpuan sa maraming lugar at mga tutorial pati na rin).

Itala at patakbuhin ang tagubilin gcc file_name.c ; ./a.out

Ihambing at magpalitan

   # Include 
  # Include 
 / / Palitan - newvalue, comperand lumang / inaasahang halaga
 / *
  * Ang function na talaga ang mga sumusunod na bagay - kung ang halaga sa * Dest ay katumbas sa oldvalue ang pagkatapos ay palitan ito sa pamamagitan ng newvalue ibang iwanan ito hindi nagbabago: ang lahat ng mga atomically
  *
  * Mayroong dalawang mga pagpipilian para sa halaga ng pagbabalik
  * 1.is paunang halaga ng * Dest at iwanan ang pasanin ng pagtawag fxn upang ihambing ang mga ito sa oldval
  * 2.  gawin ito sa dito at bumalik ng 0 o 1, ito ay dapat na maging mas episyente
  ** /

 / * Mamaya baguhin ang mga ito sa macro * /
 int Cas (int * Dest, ang int oldvalue, int newvalue) {
	 printf ("(% d,% d,% d)", ang * Dest, oldvalue, newvalue);
	 / * Int Cas (ang int Dest, int oldvalue, ang int newvalue) {* /
	 / * Int Cas (ang int Dest, int newvalue, ang int oldvalue) {* /
	 int resulta = 1 ;/ * 1 nagpapakita na ang Cas nagtagumpay at 0 mga palabas na ito nabigo * /
	 / * Btw kailangan upang itakda ang cc para sa bandila clobbering!  * /
	 __asm__ na __ volatile__ (
			 Sa "movl% 2,%% eax \ n \ t"
			 "Movl% 3,%% ebx \ n \ t"
			 Sa "movl% 0,%% ecx \ n \ t"
			 "Lock \ n \ t"
			 "CMPXCHG%% ebx, (%% ecx) \ n \ t" / * ay dapat i-lock sa parehong linya * /
			 "Jz DONE \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "DONE: \ n \ t"
			 : "= M" (Dest), "= g" (resulta)
			 : "G" (oldvalue), "g" (newvalue), "m" (Dest)
			 : "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("(% d,% d,% d)", ang * Dest, oldvalue, newvalue);
	 bumalik resulta;
 }

 / * TODO
  * Magsulat ng isa pang asm fxn kung saan naglalagay sa itaas fxn sa isang habang loop at panatilihing sinusubukan maliban kung ito succeeds * /

 int pangunahing () {
	 int a = 5, b = 6;
	 int * c = (int *) malloc (sizeof ang (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));
	 printf ("% d \ n", Cas (c, b, b));
	 * C = 6;
	 / * C = 5; * /
	 printf ("pagbabago ng halaga ng * c sa% d \ n", * c);
	 printf ("% d \ n", Cas (c, b, b));
	 printf ("% d \ n", Cas (c, b, a));
	 printf ("% d \ n", Cas (c,, a));
	 printf ("% d \ n", Cas (c, a, b));
	 printf ("% d \ n", Cas (c, b, a));
	 bumalik 0;
 }

Tala ng format - tila wp syntax highlighter ay pagdaragdag sa katapusan, huwag pansinin na.

GCD

 # Include 
 sa int gcd (int a, int b) {
     int resulta;
     / * Compute pinakamalaking Karaniwang na panghati gamit Euclid ng algorithm * /
     __asm__ __ volatile__ (sa "movl% 1,%% eax;"
                           Sa "movl% 2,%% ebx;"
                           "CONTD: cmpl $ 0,%% ebx;"
                           "Je DONE;"
                           Ang "xorl%% edx,%% edx;"
                           Sa "idivl%% ebx;"
                           Ang "movl%% ebx,%% eax;"
                           Ang "movl%% edx, ebx ng%%;"
                           "Jmp CONTD;"
                           "DONE: movl%% eax,% 0;": "= g" (resulta): "g" (a), "g" (b)
     );

     bumalik resulta;
 }

 int pangunahing () {
     int una, pangalawa;
     printf ("Ipasok ang dalawang integers:");
     scanf ("% d% d", & unang, at segundo);

     printf ("GCD ng% d at% d ay% d \ n", una, pangalawa, gcd (una, ikalawa));

     bumalik 0;
 }