विधानसभा की एक बिट

29 अगस्त, 2009 के द्वारा प्रशांत · टिप्पणियाँ
: के तहत दायर की प्रौद्योगिकी

पढ़ने के बाद यह ताला मुक्त buffers के बारे में लेख और कैस के उपयोग (तुलना और स्वैप) देख, मैं विधानसभा कोड पोस्ट करने के लिए भी ऐसा ही लगा. मामले का प्रयोग करें वहाँ एक देशी विधि लिखने के लिए और यह जावा (1.5 में वापस आ गया, जब जावा में समवर्ती डेटा संरचनाओं और अधिक या कम गैर विद्यमान थे) से फोन किया गया था. आगे की हलचल के बिना, मैं आप पर कोड दिलाने हूँ :) . पहले कैस के लिए और 2 के लिए कंप्यूटिंग GCD यूक्लिड के एल्गोरिथ्म (यह एक कई स्थानों और ट्यूटोरियल के रूप में अच्छी तरह से में पाया जा सकता है) का उपयोग.

संकलित करें और चलाने के निर्देश gcc file_name.c ; ./a.out

तुलना करें और स्वैप 

   # शामिल 
  # शामिल 
 / / विनिमय - टिप्पणी परिवर्तन, comperand पुराने / उम्मीद मूल्य है
 / *
  * समारोह वास्तव में निम्नलिखित बात करता है - अगर * गंतव्य पर मूल्य के बराबर है तो यह और टिप्पणी परिवर्तन यह अपरिवर्तित छोड़ द्वारा प्रतिस्थापित oldvalue: atomically इन सभी करते हैं
  *
  * मान के लिए दो विकल्प हैं
  * * गंतव्य के 1.is प्रारंभिक मूल्य और को बुला fxn के बोझ को छोड़ने के लिए यह oldval साथ तुलना
  * 2.  ऐसा करने पर यहाँ और लौटने 0 या 1, यह और अधिक कुशल होना चाहिए
  / **

 / * बाद में यह मैक्रो में परिवर्तन * /
 int कैस (int गंतव्य * int oldvalue, int टिप्पणी परिवर्तन)
	 printf ("(% d,% d,% d)" * गंतव्य, oldvalue, टिप्पणी परिवर्तन);
	 * / Int (int के गंतव्य, oldvalue int, int टिप्पणी परिवर्तन) कैस {* /
	 * / Int (int गंतव्य, int टिप्पणी परिवर्तन, int oldvalue) कैस {* /
	 int परिणाम = 1, "* 1 से पता चलता है कि कैस सफल और 0 से पता चलता है कि यह विफल रहा है * /
	 / * Btw झंडा clobbering के लिए सीसी सेट की जरूरत है!  * /
	 __asm__ __ volatile__ (
			 "Movl 2%,% EAX \ n \ t"
			 "Movl 3%,% EBX \ n \ t"
			 "Movl% 0% ECX \ n \ t"
			 "ताला \ n \ t"
			 "% EBX, CMPXCHG (% ECX) \ n \ t" / * एक ही पंक्ति पर बंद कर देना चाहिए * /
			 "Jz \ \ n किया
			 "Movl $ 0, 1% \ n \ t"
			 ": \ N \ t किया"
			 "= मीटर (गंतव्य)," = छ "(परिणाम)
			 (Oldvalue) "जी", "जी" (टिप्पणी परिवर्तन), "मीटर" (गंतव्य)
			 EAX% ","% EBX "," ECX "," सीसी "
			 );
	 printf ("(% d,% d,% d)" * गंतव्य, oldvalue, टिप्पणी परिवर्तन);
	 परिणाम वापसी;
 }

 / * TODO
  * एक और asm fxn है जो थोड़ी देर के पाश में fxn ऊपर डालता है लिखने के लिए और कोशिश कर रहा है जब तक यह * / सफल रहते हैं

 int मुख्य () {
	 int एक = 5, ख = 6;
	 int * ग = (int *) malloc (sizeof (int));
	 * ग = 6;
	 * / Int ग = 6; / *
	 printf ("% d \ n", कैस (ग, ख ख));
	 printf ("% d \ n", कैस (ग, ख, एक));
	 printf ("% d \ n" ", कैस (ग,,) एक);
	 printf ("% d \ n", कैस (ग, ख ख));
	 * ग = 6;
	 / * ग = 5; * /
	 printf ("* का बदल रहा है मूल्य ग% s \ n", * ग);
	 printf ("% d \ n", कैस (ग, ख ख));
	 printf ("% d \ n", कैस (ग, ख, एक));
	 printf ("% d \ n" ", कैस (ग,,) एक);
	 printf ("% d \ n", कैस (ग, ए, बी));
	 printf ("% d \ n", कैस (ग, ख, एक));
	 0 वापसी;
 }

स्वरूपण नोट - wp वाक्यविन्यास हाइलाइटर की तरह लगता है जोड़ने का है अंत में, कि उपेक्षा.

GCD 

 # शामिल 
 int gcd (int एक, int ख) {
     int के परिणाम;
     / * कंप्यूट महानतम यूक्लिड एल्गोरिथ्म का उपयोग करते हुए आम भाजक / *
     __asm__ __ volatile__ ("movl 1%,% EAX;"
                           "Movl% 2% EBX;"
                           "जारी: cmpl $ 0% EBX;"
                           जेई किया;
                           "Xorl% edx,% edx;"
                           "Idivl% EBX;"
                           "Movl% EBX,% EAX;"
                           "Movl% edx,% EBX;"
                           Jmp जारी;
                           "ठीक है: movl% EAX, 0%," "= छ" (परिणाम): "जी" (एक), "जी" (ख)
     );

     परिणाम वापसी;
 }

 int मुख्य () {
     प्रथम, द्वितीय लिए int;
     printf ("दो integers दर्ज करें:");
     scanf ("% d घ" और पहली, दूसरी और);

     printf ("% और% d d की GCD% d \ n" ", पहली, दूसरी, gcd (प्रथम, द्वितीय));

     0 वापसी;
 }

टैग: , , , ,