אתגר:

[gilad_no]

אתגר:

בעקבות הודעה באחד הפורומים האחרים, החלטתי לקחת על עצמי אתגר. הסוס הטרויאני הקטן ביותר כיום תופס 3K. החלטתי לנסות ליצור סוס טרויאני שייתן גישה ברמת פקודות דוס אשר יהיה קטן יותר מהוירוס הנ"ל. אני רוצה לנסות להגיע ל1K. אם מישהו רוצה לנסות לעזור, שיפנה אלי. אני מניח שזה ברור מאליו שהכל חייב להתבצע באסמבלי.

 

[voguemaster]

לאיזו פלטפורמה ? WIN32 או UNIX ?

 

[gilad_no]

חלונות

אני מתכנן להתחיל ללמוד לינוקס בקרוב, אבל בינתיים אני עובד על חלונות. בנוסף, אני רוצה לכתוב מהדר בסיסי שממיר קובץ C לאסמבלי ע"מ להקל על פיתוח יישומים באסמבלי. הוא ייצור קוד באסמבלי ועליו אפשר יהיה להמשיך לעבוד

 

[voguemaster]

נשמע מעניין

COUNT ME IN. הבעיה היא שכבר הרבה זמן לא התעסקתי עם WIN32 ברמת האסמבלי... ד"א, יש סביבת פיתוח לאסמבלי, אם בא לך לבדוק אותה. נקראת VisualASM. אלי

 

[gilad_no]

בדקתי סביבות פיתוח כבר השבוע

מצאתי רק אחת שנראית טוב. הכוונה שלי זה לכתוב את היישום בשפה עילית (כגון C) ושהמהדר ימיר אותה לקוד מקור באסמבלי שאני אוכל לשלוט בדיוק בכל הדברים ולעשות אופטימיזציה ברמת האוגר הבסיסי. כך יהיה אפשר להרוויח מהירות וגודל. בניתי פעם משהו כזה בימי הדוס. גם אני כבר לא כ"כ מתעסק עם אסמבלי היום אבל מדגדג לי לחזור לזה קצת ... מי שרוצה, שייצור איתי קשר. יש לי כמה מדריכים טובים למהדרים ולאסמבלי של חלונות. גלעד - [email protected] ICQ - 27138646

 

[אביב ל]

אסמבלי

קיממת אפשרות ב VC++ ליצר אסמבלי. לך ל Project/Settings כנס ל טאב של C/C++ ןבקטגוריה בחר Listing Files ב Listing file types יש אפשרות ליצר קוד מקור באסמבלי. זאת יכולה להיות נקודת פתיחה טובה בשבילך

 

[gilad_no]

../images/Emo45.gif

ידעתי על הפונקציה הנ"ל בימי הדוס. לא ידעתי זה שזה קיים גם בVC. תודה

 

[galh]

סתם לידיעה...

המהדרים של היום (לפחות של אינטל ומיקרוסופט) מבצעים אופטימיזציה של הקוד ברמה שמנצלת את יכולת החישוב של המעבד עד למקסימום. כך שעדיף לך לכתוב את התוכנית שלך ב- C ולהשתמש ב- VTune (או משהו דומה) לאופטימיזציה.

 

[voguemaster]

חלילה וחס

ממש לא נכון! ראשית כל, האופטימיזציה היא מינימלית. כל אדם עם טיפה ניסיון ב-ASM יכול לכתוב אלגוריתם בצורה מהירה יותר. הבעיה היא סיבוכיות. יש אלגוריתמים לא נעימים ב-C, אז על אחת כמה וכמה ASM. ד"א, לכל מי שלא יודע, אותה אופטימיזציה שמנצלת את ה-PIPELINES השונים של ה-CPU הרבה פחות יעילה ממה שחושבים. בעיקרון רק אם פקודות לא תלויות בזו שאחריהן ולפניהן, הן יכולות לעבור ב-PIPELINE נפרד.. בכל מקרה, אף קומפיילר לא מנצל את היכולת המקסימלית של המעבד. הדרך היחידה בינתיים היא לכתוב ASM ישירות. אלי

 

[yuvalzr]

נשמע מענין

שמעו אני רק מתחיל (גם זה בקושי) אבל זה נשמע מענין ואני ישמח לקחת חלק בזה (שוב למרות שאני חושב שאני יוכל לעזור רק במעט) וגם עם לא אוכל לעזור אשמח אם תשתפו אותי בדרך העבודה וכאלה יובל

 

[galh]

כן נכון וכן נכון!

תבדיל בין _אלגוריתם_ לבין _אומטימיזציה_ בתור התחלה! אלגוריתם יעיל נמדד ע"י הסיבוכיות שלו, כך שאם תשתמש באלגוריתם בעל סיבוכיות גבוהה, לא יעזור לך שום ידע באסמבלר כדי להאיץ את מהירות הריצה. האופטימיזציה של המהדרים היום לא רק מנצלות את ה- Pipe line של המעבד, אלא גם את ה- cache של L1 ו- L2, את העובדה שיש יחידות חישוב נפרדות למספרים שלמים ולנקודה צפה, את זמן העיבוד השונה של כל הוראות אסמבלר ועוד. תקמפל תוכנית ב- ++C בגרסת Release ותסתכל על הוראות האסמבלר, תגלה שחלק מהוראות נמצאות בסוף הפונקציה כביכול בלי קשר למימוש. בעבודה הקודמת שלי מישהו שמבין באסמבלר (ובאלגוריתם) ניסה לממש טרנספורמציה על תמונה ב- ++C, הוא לא היה מרוצה מהביצועים אז הוא מימש את הפרוצדורה באסמבלר. אחרי שהוא סיים, בחור אחר כתב לו בחמש דקות בדלפי את אותו קוד (לקח לו בערך 10 דקות לעומת כמה שעות) והתוצאה הייתה יותר מהירה. אני מוכן לנסות גם תחרות, אני אתן לך בעיה שתוכל לממש באסמבלר ונראה אצל מי הקוד ירוץ מהר יותר.

 

[gilad_no]

תבדוק שוב...

כבר יצא לי מספר פעמים לבדוק את קוד האסמבלי של יישום שכתבתי בVC וראיתי הרבה מקומות שהייתי יורה במתכנת אסמבלי אם הוא היה כותב כך. חלק מהדברים נעשים עקב שימוש במשתנים. כאשר אתה כותב באסמבלי, יש לך שליטה מלאה מה נמצא באיזה אוגר, אך כאשר המהדר מפיק קוד, הוא צריך לשמר אוגרים מסויימים, ולהעביר מידע ממקום למקום והוא לא עושה מעקב מלא אחרי כל ההגדרות. הוא שומר אוגרים ליתר ביטחון וזה גם ביזבוז של פקודות (לפעמים)

 

[galh]

אתה מוכן לאתגר?

אני דווקא מוכן לירות במי שיגיד לי לקרוא קוד אסמבלי.

אין לי סבלנות להתחיל עם ויכוח בצורה של כן עושה, לא עושה, אז נעשה את זה פשוט. אני אתן לך תוכנית שתכתוב באסמבלר, אני אכתוב את אותה תוכנית בשפה עילית (++C או דלפי) ונשווה את מהירות הריצה.

 

[gilad_no]

לא תמיד זה נמדד בעין

בו ניקח לדוגמא את הקוד הבא: 3*4 תרגום של הפקודה בC mov ax,3 mov dx,4 mul dx באסמבלי mov ax,3 shl ax,2 אז נכון שאם אני אשב עם טיימר ליד המחשב אני לא אראה הבדל בביצועים, אבל אני מדבר על תפיסה מסויימת. חוץ מזה שאני גם מדבר על גודל קוד. היישום הקטן ביותר שתכתוב בC יוצא בערך 4K אחרי אופטימיזציה. באסמבלי אתה יכול ליצור חלון ולהדפיס בו טקסט בקובץ הרצה של 400 בתים!!! השיקול הוא לאו דווקא של מהירות. חוץ מזה, הסיבה שאני רוצה לחזור לאסמבלי זה בשביל האתגר. ברור שאני יכול לעשות הכל בC. אני גם יכול לעשות דברים בצורה יותר קלה בVB, אבל אני נהנה מהאתגר של לכתוב דברים מאפס (ואני בטוח שישנם עוד אנשים כמוני). אני מדבר על הידיעה שהכלים העומדים לרשותך אלו רק האוגרים וגישה לזיכרון ועם אלו אתה צריך לעשות הכל. נ.ב. אם התבלבלתי בפקודות, אני מתנצל מראש. לא עבדתי עם אסמבלי כבר כמה שנים

 

[galh]

זה נמדד בזמנים, לא בעין

איזה תוכנית כתבת ב- C שהקומפלייר נתן לך תרגום כזה לאסמבלר?! אצלי הוא מיד המיר את זה מ- 3*4 ל- 12. יופי, אז אפשר לעשות חלון עם ה- "Hello World" הקלאסי ב- 400 בייטים בלבד. אבל מה עם להוסיף לחלון גם מנוע גרפי 3D שמציג פני שטח, שמיים וחמישה מטוסים? יחד עם לוח בקרה למשתמש ודוחות, וגרפים... גם את זה אתה יכול לכתוב באסמבלר? יכול להיות שבשבילך זה נורא כיף לכתוב מאפס באסמבלר, אבל הקומפלייר "יודע" אסמבלר ואופטימזציה קצת יותר טוב ממך.

 

[gilad_no]

עניתי לך כבר ...

אבל אני אגיב בשביל כולם: כאשר דיברתי על המיספרים לא התכוונתי לאופטימיזציה בזמן קומפילציה אלא בזמן ריצה. אם יש לך משתנה נתון X ואתה רוצה להכפיל אותו ב4 בכל פעם, עדיף להכפיל אותו בצורת הזזת סיביות. בקשר לשאר הדברים: אני לא מתכוון לתכנת באסמבלי ולזנוח את C. זה בעיקר בשביל אתגר. אני לא מכריח אף אחד כמו שאני לא מכריח אף אדם לתכנת בC ולא בVB. כל אחד והעדפות שלו

 

[voguemaster]

נו באמת........

נתתי דוגמא ואמרתי שאלגוריתם עם סיבוכיות גדולה הוא קשה יותר להבנה בד"כ ולכן יש סיכוי טוב יותר שלא תוכל לבצע לו אופטימיזציה באסמבלי בכוחות עצמך, אלא אם כן אתה באמת תותח לא מהעולם הזה. איפה קראת בדיוק שהקומפיילר מנצל טוב יותר את ה-L1 וה-L2 ?? תגיד מאיפה אתה מביא את זה בדיוק ?? האלגוריתמים שמניעים את שני זיכרונות המטמון האלו לא נשלטים ע"י שום רכיב תוכנה אפשרי שקיים. אתה גם לא יכול "לסדר" כך שהמעבד יקרא פקודות מסוימות ל-L1 או ל-L2 יותר מהר. המקסימום שאפשר לעשות זה לכתוב את הקוד כך שיהיו כמה שפחות FLUSHים לתוכן הזכרון כך שלא יהיה בזבוז זמן בלקרוא אותם מחדש. נקודה נוספת היא שבדיוק כמו שאתה מסוגל להשתמש בקוד של ה-ALU ושל ה-FPU, כך הקומפיילר עושה את זה. תאמין לי, ראיתי הרבה תוכניות ברמת האסמבלר, והרבה פעמים אפשר להאיץ את התהליך. לך תמצא אופטימיזציות של אנשים באסמבלי כנגד אלגוריתמים ידועים של חישוב פרקטלים שקומפלו משפה עילית. אנשים מסוגלים להוריד כמה CLOCK CYCLES שלמים על כל איטרציה שהאלגוריתם מבוצע, והוא מבוצע הרבה פעמים! דווקא בחישובים של נקודה צפה יש לך אפשרות להכניס גורם טוב יותר של אופטימיזציה בעצמך. כבר עבדתי עם תוכניות באסמבלי שקימפלתי ל-RELEASE, ותאמין לי שההבדל לא כ"כ גדול מגרסת ה-DEBUG. קיים ולא טריוויאלי, אבל לא כזה ענק כמו שאתה מנסה לגרום לנו להאמין. רעיון התחרות היה נשמע מעניין, אילולא לא היה לי זמן בשבילו. מה לעשות אני עובד ולומד

לא שיש לי משהו להוכיח... אבל בכל זאת.. אלי

 

[galh]

אתה לא מדבר על מה שאני מדבר!

תבדיל בין סיבוכיות של אלגוריתם לבין ביצוע אופטימיזציה לקוד אסמבלי. סיבוכיות של אלגוריתם זה מושג שלא תלוי במחשב או בשפה ואתה משפר אותו ברמת האלגוריתם (לדוגמא, חיפוש טקסט מהיר יותר). אבל אחרי שיש לך את האלגוריתם היעיל ביותר לצורך המשימה, תכתוב אותו בשפה עילית ותן למהדר להתאים את המימוש למעבד. מה שאני אומר זה שלבצע אופטימיזציה נוספת לקוד באמסבלי זה דבר מיותר לחלוטין היום והיחס בין עלות-תועלת הוא עצום (כלומר תחסוך מאית שניה, אבל יקח לך שבוע עבודה של מתכנת). הטענות שלי לגבי יעילות המהדר באו מקבוצות דיון ב- usenet, מידע באתר של אינטל ויום עיון של אינטל בנושא VTune. שימוש באופציה של "אופטימיזציה לקוד קטן" מנצל בצורה טובה יותר את ה- caching של המעבד (כלומר L1 ו- L2). למעבד היום יש יכולת חיזוי של הפקודות הבאה עם מעל ל- 90% אחוזי הצלחה (נתון מאינטל), מה שאומר שאם אתה עובד עם קטעי קוד קטנים (הי, המהדר עושה את זה גם כן), אתה מנצל את ה- cache ומפחית את הזמן שבו המעבד לא עושה כלום ומחכה להוראות שיגיעו מהזכרון. כמו כן, אני לא מדבר על תוכניות קטנות שאתה כותב באסבלר, אלא על ישומים גדולים. לגבי התחרות, השאלה מוכנה. והיא מדגימה את שני העקרונות *השונים* שאני מדבר עליהם. הראשון, אם לא תשתמש באלגו´ (בקיצור) בשביל לא לבדוק את כל הערכים (יש הרבה ערכים אבל לא צריך לבדוק את כולם) לא יעזור לך ה- CPU הכי מהיר שתוכל להשתמש. והשני, מימוש האלגו´ באסמלר לא לא ירוץ יותר מהר מהתוכנית ב- C שאני אכתוב.

 

[voguemaster]

טוב, לא רציתי להגיב, אבל

זו כבר הפעם השלישית שאני אומר חד משמעית שאין קשר בין סיבוכיות לאופטימיזציה, אל תהיה נודניק בחייך.. כל הטענה הייתה שלאלגוריתמים עם סיבוכיות גדולה קשה לבצע אופטימיזציה. לא תמיד, אבל לפעמים זה מאוד קשה, מה לעשות. שנית, לא באתי וטענתי שאופטימיזציה באסמבלי תהיה תמיד יותר יעילה וזה דבר שווה. בד"כ זה לא שווה, אז מה ? רק טענתי שזה אפשרי. הוצאת את כל העניין מהקשר. מידע באתר של אינטל ? יום עיון באינטל ? תרשה לי בבקשה. גם אני הייתי בימי עיון, ואני יודע בדיוק באיזו צורה הם מנוהלים ולאיזה רמה טכנית הם מגיעים. זה לא מרשים אותי במיוחד. כמו שיש קבוצות דיון שבהם הדעה הרווחת היא שלא שווה ליישם באסמבלי, כך תמצא מקורות ברשת שיטענו אחרת. בתור דוגמא נתתי אופטימיזציה לחישוב פרקטלים שקראתי עליה פעם.. התוצאה הייתה הורדה של כמה CLOCK CYCLES בכל איטרציה של הסט (נניח MANDELBROT), ואם אתה יודע משהו על פרקטלים, תדע שיש המון איטרציות. מה ז"א, אינסוף בעיקרון... אתה צודק לגבי אופטימיזציה של קוד קטן. מצד שני, גם בנאדם יכול לכתוב כך, וד"א, אלו שבאמת צריכים לעשות את זה, לרוב עושים את זה טוב יותר ממהדר. אני מדבר על אותם ה-GURUים... וד"א, לא תמיד ניתן לכתוב כך כל הזמן. בד"כ אפשר ליישם את זה רק לחלקים. מה שעוד יותר בעייתי לקוד קטן הוא קוד 32 ביט, שהוא מעצם הגדרתו לא קוד קטן (ברובו לפחות). תשמע, גם קראתי על כל ה-PIPELINE המדהים שיש לפנטיום 4, ובכל זאת הוא עדיין לא מספיק טוב, ול-AMD יש פתרונות שמתמודדים כנגדו ממש יופי. אולי זה ייראה כמו זלזול במה שאינטל עשו, אבל לא כך הדבר. אלי

 

[anigno]

עצבים?

כמה עצבים אתם מוציאים על שאלה? מה הקשר בין סיבוכיות שמתארת תפיסת מקום או זמן יחסי ובין אופטימיזציה. אין אפשרות לשפר סיבוכיות באמצעות אופטימיזציה !!! אין שום קשר בינהם וגם לא למהירות המעבד או לקצב העברת הנתונים במערכת. חיסכון בזמן אמיתי, זמן ריצה לביצוע פעולות = אופטימיזציה. מי שראה קוד אסמבלי של תוכנית עלית יודע שזוהי פעולה מתישה מאוד ולא כדאית בדרך כלל. רוצים לחסוך זמן וותרו על OOP וותרו על פונקציות (רק ONLINE) השתמשו במשתנים מדוייקים. רוצים לחסוך מקום נהלו נתונים בצורה יעילה. אבל להתעסק עם אסמבלי כדי לחסוך מליוניות שניה בקוד בעל מחזור טיפוסי של עשיריות שניה ואפילו פחות מזה? טוב אם משעמם לכם בהצלחה רוני