קצת הרכבה

29 אוגוסט 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

אחרי שקראתי את הכתבה על מאגרים נעילת בחינם ולראות את השימוש CAS (להשוואה, להחליף), הרגשתי כמו פרסום קוד הרכבה לעשות את אותו הדבר. השתמש במקרה שם היה לכתוב שיטה מקורית ולקרוא אותו Java (בחזרה 1.5, כאשר במקביל מבני נתונים ב-Java היו פחות או יותר לא קיימת). בלי שהיות, אני לשחרר את הקוד אל לך :) . הראשון הוא על CAS ואת השני הוא מחשוב GCD באמצעות האלגוריתם של אוקלידס (את זה אפשר למצוא במקומות ומדריכים רבים גם כן).

לקמפל ולהריץ הוראות gcc file_name.c ; ./a.out

השווה והחלף 

   # Include 
  # Include 
 / / Exchange - newvalue, comperand ישן / הערך הצפוי
 / *
  פונקציה * באמת עושה את הדבר הבא - אם הערך ב * dest שווה oldvalue מכן להחליף אותו על ידי newvalue אחר להשאיר אותו ללא שינוי: האם כל אלה אטומית
  *
  * יש שתי אפשרויות עבור ערך ההחזרה
  * הערך הראשוני של 1.is * dest ולהשאיר את נטל fxn קורא להשוות את זה עם oldval
  * 2.  לעשות את זה כאן ולחזור 0 או 1, זה אמור להיות יעיל יותר
  ** /

 / * לאחר מכן לשנות את זה לתוך מאקרו * /
 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 התוצאה = 1 ;/ * 1 מראה כי הצליחו CAS ו 0 מראה שהוא נכשל * /
	 / * אגב צריך להגדיר סמ"ק עבור הדגל מחץ!  * /
	 __ __asm__ volatile__ (
			 "Movl% 2,%% EAX \ n \ t"
			 "Movl% 3,%% EBX \ n \ t"
			 "0% movl,%% ECX \ n \ t"
			 "LOCK \ n \ t"
			 "CMPXCHG%% EBX, (%% ECX) \ n \ t" / * לנעול להיות באותה שורה * /
			 "סיימנו JZ \ n \ t"
			 "Movl 0 $,% 1 \ n \ t"
			 "מה נעשה: \ n \ t"
			 : "= M" (dest), "= g" (תוצאה)
			 : "ז" (oldvalue), "G" (newvalue), "M" (dest)
			 : "% EAX", "% EBX", "ECX", "cc"
			 );
	 printf ("(% d,% d,% d)", * dest, oldvalue, newvalue);
	 להחזיר את התוצאה;
 }

 / * TODO
  * לכתוב עוד fxn ASM אשר מעמידה מעל fxn בלולאה תוך ולשמור מנסה אלא אם כן הוא מצליח * /

 int main () {
	 int = 5, b = 6;
	 int * c = (int *) malloc (sizeof (int));
	 * C = 6;
	 / * Int c = 6; * /
	 printf ("% d \ n", CAS (ג, ב, ב));
	 printf ("% d \ n", CAS (ג, ב, א));
	 printf ("% d \ n", CAS (ג,,));
	 printf ("% d \ n", CAS (ג, ב, ב));
	 * C = 6;
	 / * C = 5, * /
	 printf ("ערך המשתנה של * ג ל% d \ n", * ג);
	 printf ("% d \ n", CAS (ג, ב, ב));
	 printf ("% d \ n", CAS (ג, ב, א));
	 printf ("% d \ n", CAS (ג,,));
	 printf ("% d \ n", CAS (ג, א, ב));
	 printf ("% d \ n", CAS (ג, ב, א));
	 התשואה 0;
 }

הערות עיצוב - נראה כמו סימון תחביר wp מוסיפה בסופו של דבר, להתעלם מזה.

GCD 

 # Include 
 GCD int (int, int b) {
     int התוצאה;
     / * Compute מחלק משותף גדול ביותר באמצעות אלגוריתם של אוקלידס * /
     __ volatile__ __asm__ ("movl% 1,%% EAX;"
                           "Movl% 2,%% EBX;"
                           "CONTD: cmpl 0 $,%% EBX;"
                           "Je נעשה;"
                           "Xorl%% edx, edx%%;"
                           "Idivl%% EBX;"
                           "% Movl EBX%%% EAX;"
                           "Movl%% edx, EBX%%;"
                           "JMP CONTD;"
                           "מה נעשה: movl%% EAX, 0%;": "= g" (תוצאה): "G" (א), "G" (ב)
     );

     להחזיר את התוצאה;
 }

 int main () {
     int 1, 2;
     printf ("הכנס שני מספרים שלמים:");
     scanf ("% d% d", & 1, & 2);

     printf ("GCD של D & D%% הוא% d \ n", 1, 2, GCD (1, 2));

     התשואה 0;
 }

תגיות: , , , ,