Instructions

User Manual: Pdf

Open the PDF directly: View PDF .
Page Count: 8

Download
Open PDF In Browser	View PDF

‫שפת ‪ – C++‬תרגיל ‪3‬‬
‫‪Template class, exceptions, Move Semantics, STL and Multithreading‬‬
‫​ יום חמישי ‪ 10.09.15‬עד שעה ‪23:55‬‬
‫תאריך הגשה‪:‬‬
‫​ יום שישי ‪ 11.09.15‬עד שעה ‪12:55‬‬
‫הגשה מאוחרת )בהפחתת ‪ 10‬נקודות(‪:‬‬
‫​ יום חמישי ‪ 10.09.15‬עד שעה ‪23:55‬‬
‫תאריך ההגשה של הבוחן‪:‬‬
‫‪ .1‬הנחיות חשובות‪:‬‬
‫‪.1‬‬
‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬

‫‪.5‬‬
‫‪.6‬‬

‫בכל התרגילים יש לעמוד בהנחיות הגשת התרגילים וסגנון כתיבת הקוד‪ .‬שני המסמכים נמצאים באתר‬
‫הקורס – הניקוד יכלול גם עמידה בדרישות אלו‪.‬‬
‫בכל התרגילים עליכם לכתוב קוד ברור‪ .‬בכל מקרה בו הקוד שלכם אינו ברור מספיק עליכם להוסיף הערות‬
‫הסבר בגוף הקוד‪ .‬יש להקפיד על תיעוד )‪ (documentation‬הקוד ובפרט תיעוד של כל פונקציה‪.‬‬
‫במידה ואתם משתמשים בעיצוב מיוחד או משהו לא שגרתי‪ ,‬עליכם להוסיף הערות בקוד המסבירות את‬
‫העיצוב שלכם ומדוע בחרתם בו‪.‬‬
‫​חל איסור להגיש קובץ כלשהוא בלינק הרגיל‬
‫בכל התרגילים במידה ויש לכם הארכה ואתם משתמשים בה‪,‬‬
‫​מי שיגיש קבצים בשני הלינקים מסתכן בהורדת ציון‬
‫​‪.‬‬
‫)גם אם לינק ההגשה באיחור טרם נפתח(‬
‫משמעותית‪.‬‬
‫אין להגיש קבצים נוספים על אלו שתדרשו‪.‬‬
‫​ ‪ ­Wall‬ולוודא שהתוכנית מתקמפלת ללא אזהרות‪,‬‬
‫​‪­Wextra ­pthread ­Wvla‬‬
‫עליכם לקמפל עם הדגלים‬
‫​ למשל‪ ,‬בכדי ליצור תוכנית מקובץ מקור‬
‫תכנית שמתקמפלת עם אזהרות תגרור הורדה בציון התרגיל‪.‬‬
‫בשם ‪ ex1.c‬יש להריץ את הפקודה‪:‬‬
‫​‪g++ ­std=c++11 ­Wextra ­Wall ­pthread ­Wvla‬‬
‫​‬
‫‪ex1.cpp ­o ex1‬‬

‫‪ .7‬עליכם לוודא שהתרגילים שלכם תקינים ועומדים בכל דרישות הקימפול והריצה במחשבי בית הספר מבוססי‬
‫​חובה להריץ את התרגיל במחשבי בית הספר לפני‬
‫מעבדי ‪) bit­64‬מחשבי האקווריום‪ ,‬לוי‪ ,‬השרת ‪.(river‬‬
‫​”‬
‫​‪) .‬ניתן לוודא שהמחשב עליו אתם עובדים הנו בתצורת ‪ bit­64‬באמצעות הפקודה “‪uname ­a‬‬
‫ההגשה‬
‫ווידוא כי הארכיטקטורה היא ‪ ,64‬למשל אם כתוב ‪(x86_64‬‬
‫‪ .8‬לאחר ההגשה‪ ,‬בדקו הפלט המתקבל בקובץ ה­‪ PDF‬שנוצר מה ‪ presubmission script‬בזמן ההגשה‪ .‬באם‬
‫ישנן שגיאות‪ ,‬תקנו אותן על מנת שלא לאבד נקודות‪.‬‬
‫​ )הציון יתחיל מ­‪,50‬‬
‫שימו לב ! תרגיל שלא יעבור את ה ‪ presubmission script‬ציונו ירד משמעותית‬
‫​ולא יהיה ניתן לערער על כך‪.‬‬
‫ויוכל לרדת(‬
‫‪ .9‬בדיקת הקוד לפני ההגשה‪ ,‬גם על ידי קריאתו וגם על ידי כתיבת בדיקות אוטומטיות )‪ (tests‬עבורו היא‬
‫אחריותכם‪ .‬חישבו על מקרי קצה לבדיקת הקוד‪.‬‬
‫​לאחר מועד הגשת התרגיל ירוצו הבדיקות האוטמטיות ותקבלו פירוט על הטסטים בהם‬
‫‪ .10‬הגשה מתוקנת ­‬
‫נפלתם‪ .‬לשם שיפור הציון יהיה ניתן להגיש שוב את התרגיל לאחר תיקוני קוד קלים ולקבל בחזרה חלק‬
‫​‪.‬‬
‫​פרטים מלאים יפורסמו בפורום ואתר הקורס‬
‫מהנקודות ­‬

‫‪ .2‬הנחיות חשובות לכלל התרגילים בקורס ‪C++‬‬
‫‪.1‬‬

‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬
‫‪.5‬‬

‫‪.6‬‬
‫‪.7‬‬

‫הקפידו להשתמש בפונקציות ואובייקטים של ‪) C++‬למשל ‪ (new, delete, cout‬על פני פונקציות של ‪C‬‬
‫)למשל ‪ .(malloc, free, printf‬בפרט השתמשו במחלקה ‪) string‬ב­‪ (std::string‬ולא‬
‫​‪.‬‬
‫​ד‪C‬‬
‫במחרוזת של )* ‪(char‬‬
‫יש להשתמש בספריות סטדנרטיות של ‪ C++‬ולא של ‪ C‬אלא אם כן הדבר הכרחי )וגם אז עליכם להוסיף‬
‫הערה המסבירה את הסיבות לכך(‪.‬‬
‫הקפידו על עקרונות ‪ – Information Hiding‬לדוגמא‪ ,‬הקפידו כי משתני המחלקות שלכם מוגדרים כמשתנים‬
‫פרטיים )‪.(private‬‬
‫הקפידו לא להעתיק ‪ by value‬משתנים כבדים‪ ,‬אלא להעבירם )היכן שניתן( ‪.by reference‬‬
‫​ על שימוש במילה השמורה ‪ const‬בהגדרות הפונקציות והפרמטרים שהן מקבלות‪.‬‬
‫הקפידו מאוד‬
‫פונקציות שאינן משנות פרמטר מסויים – הוסיפו ‪ const‬לפני הגדרת הפרמטר‪.‬‬
‫מתודות של מחלקה שאינן משנות את משתני המחלקה – הוסיפו ‪ const‬להגדרת המתודה‪.‬‬
‫שימו לב‪ :‬הגדרת משתנים ‪ /‬מחלקות ב­ ‪ C++‬כקבועים הוא אחד העקרונות החשובים בשפה‪.‬‬
‫הקפידו על השימוש ב­ ‪ ,static‬במקומות המתאימים )הן במשתנים והן במתודות(‬
‫​השתמשו ב­‪ valgrind‬כדי לבדוק שאין לכם דליפות‬
‫הקפידו לשחרר את כל הזיכרון שאתם מקצים )‬
‫​(‪.‬‬
‫זיכרון‬

‫‪ .3‬מידע חשוב נוסף‪:‬‬
‫‪ .1‬ניתן להתחבר באמצעות ‪ SSH‬למחשבי בית הספר )למשל לשם בדיקת הקוד לפני הגשה מהבית(‬
‫‪http://wiki.cs.huji.ac.il/wiki/Connecting_from_outside‬‬
‫‪ .2‬עליכם להכיר את ספריית הקלט­פלט של שפת ‪ C‬ובייחוד את השימוש בפונקציות ‪ printf‬ו‪scanf‬‬
‫‪http://www.cplusplus.com/reference/clibrary/cstdio‬‬

‫‪ .1‬הנחיות ספציפיות לתרגיל זה‪:‬‬
‫‪.1‬‬
‫‪.2‬‬
‫‪.3‬‬
‫‪.4‬‬
‫‪.5‬‬

‫בתרגיל זה הינכם רשאים )ואף נדרשים( להשתמש ב ‪ ,STL‬לדוגמא ‪ vector‬יכול לעזור‪.‬‬
‫​‪.‬‬
‫​ו­ ‪delete‬‬
‫בתרגיל זה חל איסור על שימוש ב­ ‪new‬‬
‫​‬
‫עליכם להתמודד עם כישלון הקצאות זיכרו באמצעות מנגנון ה­‪ .exceptions‬החריגות שאתם זורקים‪ ,‬צריכות‬
‫לרשת מ­‪ std::exception‬ולהיות אינפורמטיביות‪.‬‬
‫הוסיפו לתיעוד כל פונקציה איזו שגיאה היא זורקת ובאילו מצבים‪ ,‬תעדו גם אם השגיאה עלולה להיזרק‬
‫מפונקציה מובנית או מספרייה שאתם משתמשים בה‪.‬‬
‫תרגיל זה הוא בעצם הרחבה ועדכון של תרגיל ‪ ,1‬ועל כן בכדי לחסוך בזמן פיתוח מומלץ להשתמש בקוד‬
‫​שימו לב שאתם לא גוררים טעויות מתרגיל ‪ 1‬לתרגיל‬
‫שכתבתם לתרגיל ‪ 1‬ולהרחיב‪/‬לעדכן אותו‪ .‬עם זאת‪,‬‬
‫​‪.‬‬
‫זה‬

‫​‪:‬‬
‫​ד‬
‫‪Matrix .4‬‬

‫‪ (1‬רקע‬
‫‪ (a‬מחלקה גנרית של מטריצה‪ ,‬כלומר איברי המטריצה הם מטיפוס גנרי‪ .‬המחלקה תוכל גם לשמש‬
‫כקונטיינר לכל טיפוס שהוא )בדומה ל ‪ std::vector‬ו ‪ std::list‬הגנריים המסוגלים להכיל איברים מכל‬
‫טיפוס שהוא( המייצג מספרים עם פעולות חשבון מוגדרות מראש‪ ,‬המחלקה תדע לבצע פעולות‬
‫חישוב של מטריצות‪ .‬עליכם לכתוב את הקובץ ‪ Matrix.hpp‬שיכיל את ההצהרה והמימוש של‬
‫המחלקה הגנרית ‪.Matrix‬‬
‫‪ (b‬ניתן ליצור מטריצה מכל טיפוס ‪ T‬אשר יש לו מימוש לאופרטורים​‪==,= ,* ,+= ,­= ,­ ,+‬‬
‫​‪ ,‬וכן מימוש של בנאי האפס )מקבל ‪ 0‬כארגומנט וייוצר את איבר האפס של המחלקה(‪ .‬למשל ‪int‬‬
‫​ <<‬
‫ו‬
‫או ‪ .double‬לכל טיפוס עשויה להיות דרך שונה לחישוב פעולות החשבון‪ ,‬לייצוג כמחרוזת‪ ,‬ואיבר אפס‬
‫משלו‪.‬‬

‫‪ (2‬יישום הממשק ‪Matrix‬‬
‫‪ (c‬בקובץ ‪ Matrix.hpp‬עליכם להגדיר את המחלקה ‪ ,Matrix‬שתתאר מטריצה גנרית‪ ,‬שאיבריה מטיפוס‬
‫כל שהוא )כפי שהוגדר לעיל(‪.‬‬
‫‪ (d‬המימושים לפונקציות המחלקה יהיו בקובץ ‪ .Matrix.hpp‬ויכללו את הפונקציות הבאות‪:‬‬
‫●‬

‫בנאי ברירת מחדל )ללא ארגומנטים( ­ המחזיר מטריצה ממימד ‪ 1x1‬המכילה את איבר ה­‪.0‬‬

‫●‬

‫בנאי המקבל את מימדי המטריצה‬

‫●‬

‫)‪Matrix(unsigned int rows, unsigned int cols‬‬
‫ומאתחל מטריצה בגודל הנתון המכילה את איברי האפס‪.‬‬
‫בנאי העתקה‪.‬‬

‫●‬

‫בנאי העברה )‪(move constructor‬‬

‫●‬

‫בנאי הממש את החתימה הבאה‪:‬‬

‫)‪Matrix(unsigned int rows, unsigned int cols, const vector& cells‬‬
‫ומאתחל מטריצה בגודל הנתון המכילה את איברי הוקטור הנתון‪ .‬סדר האיברים בווקטור‬
‫תואם את סדר המעבר על איברי המטריצה באמצעות האיטרטור )ראו להלן(‪.‬‬
‫●‬

‫‪.destructor‬‬

‫●‬

‫אופרטור השמה ) '='( לשם ביצוע פעולת השמת מטריצה‪ .‬אופרטור זה מאפשר שינוי של‬
‫המטריצה המיוצגת על ידי האובייקט שמשמאל לסימן ה­׳=׳‪ ,‬כך שתהייה זהה למטריצה‬
‫המיוצגת על ידי האובייקט המועבר כפרמטר )מימין לסימון ה­׳=׳(‪ .‬זכרו‪ :‬פעולת ההשמה‬
‫גורמת להיווצרות עותק זהה ובלתי תלוי‪.‬‬

‫‪1‬‬

‫●‬

‫אופרטור חיבור ) '‪ ('+‬לשם ביצוע פעולות חיבור מטריצות‪.‬‬

‫●‬

‫אופרטור חיסור ) '­'( לשם ביצוע פעולות חיסור מטריצות‪.‬‬
‫‪1‬‬

‫●‬

‫אופרטור כפל )'*'( לשם ביצוע פעולות כפל מטריצות ‪.‬‬

‫●‬

‫אופרטורי השוואה )'==' ו­ '!='( לשם ביצוע פעולת השוואת מטריצות‪.‬‬

‫חשבו למה הורדנו בתרגיל זה את הדרישה לממש את האופרטורים '=*'‪.'-=','+=',‬‬

‫●‬

‫פונקצית שחלוף בשם ‪ .trans‬הפונקציה אינה משנה את האובייקט עליו היא הופעלה‪ ,‬אלא‬
‫מחזירה אובייקט חדש‪.‬‬

‫●‬

‫פונקצית עקבה בשם ‪ trace‬המחזירה ערך מטיפוס המטריצה‪.‬‬

‫●‬

‫מימוש אופרטור '<<' לשם הדפסת המטריצה עם אובייקט ‪ ostream‬באופן הבא‪ :‬כל‬
‫שורת ערכים מודפסת בשורה נפרדת‪ ,‬ו ‪ tab‬מפריד בין הערכים‪ .‬ראו את הפלט לדוגמה‬
‫של פתרון בית הספר והשוו בעזרת ‪ diff‬כדי לוודא שהמחרוזת אותה אתם מדפיסים היא‬
‫נכונה‪.‬‬

‫●‬

‫אופרטור)( המקבל כפרמטרים )‪ (unsigned int,unsigned int‬ומחזיר את הערך בתא ]‬
‫‪ .[row,col‬יש לממש גרסאת ‪ const‬ו­‪ non­const‬לאופרטור זה )חישבו מה צריך להיות‬
‫ערך ההחזרה בכל אחד מהמקרים(‪.‬‬

‫●‬

‫איטרטורים‪ :‬עליכם לממש את הפונקציות ‪ begin‬ו­ ‪ end‬כך שהן יחזירו ערכים‬
‫​להיות ‪) const‬כלומר‬
‫המתאימים לאיטרטור העובר על כל המטריצה‪ .‬על איטרטור זה‬
‫​את ה ‪ concept‬של‬
‫ההוא איננו מאפשר לשנות את איברי המטריצה( ועליו לממש‬
‫‪) BidirectionalIterator‬חפשו באינטרנט את הממשק התואם לסטנדרט ‪.(c++11‬‬
‫כלומר‪ ,‬יש לממש את המתודות הבאות‪:‬‬
‫■‬

‫מתודה בשם )(‪ begin‬המחזירה איטרטור על כל תאי המטריצה לפי הסדר‬
‫הרגיל‪ ,‬המתחיל בתחילת המטריצה‪:‬‬

‫)‪(0,0)->(0,1)->...->(0,col-1)->(1,0)->....->(row-1,col-1‬‬
‫■‬

‫מתודה בשם )(‪ end‬המחזירה איטרטור המצביע לסוף המטריצה‬
‫כמקובל בסטדנדט‪.‬‬

‫●‬

‫פונקצית )(‪ rows‬ופונקציית )(‪ ,cols‬המחזירות בהתאם את מספר השורות והעמודות‬
‫במטריצה‪.‬‬

‫●‬

‫בנוסף תוכלו להוסיף עוד פונקציות ציבוריות או פרטיות כרצונכם‪ ,‬לפי מה שנראה לכם‬
‫שימושי למחלקה‪.‬‬

‫‪ (e‬טיפים והנחיות‪:‬‬
‫●‬

‫המימוש הפנימי של המטריצה ישפיע על מימוש הדרישות לעיל‪ ,‬ובחירה נכונה יכולה לחסוך‬
‫לכם מעט עבודה‪.‬‬

‫●‬

‫כל הפונקציות המתאימות מבצעות את הפעולה המתמטית המקבילה להגדרתם‪.‬‬

‫●‬

‫בכל מקרה בו לא ניתן לבצע את הפעולה עליכם לזרוק חריגה עם הסבר מתאים )למשל‬
‫קריאה לפונקציית ‪ trace‬כשהמטריצה אינה ריבועית(‬

‫●‬

‫באופרטור '=' מתבצע עדכון האובייקט השמאלי‪ .‬חישבו היטב מה קורה מבחינת הזכרון‬
‫כאשר המטריצה משנה את מימדיה עקב פעולה זו‪.‬‬

‫●‬

‫הממשק המדויק )החתימות של הפונקציות( לא מוכתב לכם ונתון להחלטתכם‪ ,‬אבל‬
‫ברוב המקרים ישנה דרך עיקרית אחת שהיא הטובה ביותר להגדרת הפונקציה‪ .‬חישבו‬
‫למשל על‪:‬‬
‫○‬

‫​ הפונקציה להיות מוגדרת כ ‪.const‬‬
‫האם על‬

‫○‬

‫האם הארגומנט צריך להיות מועבר ‪ by reference‬או ‪ ,by value‬או אולי כדאי‬
‫להשתמש במצביע‪ .‬האם האגרומנט צריך להיות מוגדר כ ‪?const‬‬

‫○‬

‫האם ערך ההחזרה צריך להיות מוגדר כ ‪ ,const‬והאם הוא מועבר ‪by‬‬
‫‪ reference‬או ‪.by value‬‬

‫○‬

‫חישבו איך האופרטור שאתם מממשים פועל על טיפוסים מובנים בשפה ונסו‬
‫להתחקות אחרי זה במימוש שלכם עבור המטריצה‪.‬‬
‫​‬

‫כמו‬

‫כן‪​ ,‬עליכם‬

‫לוודא‬

‫שהממשק‬

‫שלכם‬

‫תואם‬

‫את‬

‫הדרייבר‬

‫​‪ GenericMatrixDriver‬שמסופק לכם‪.‬‬
‫​‪.‬‬
‫‪cpp‬‬
‫‪ (3‬מימוש טיפוס ‪Complex‬‬
‫‪ (a‬מימשנו עבורכם את המחלקה ‪ Complex‬בקובץ ‪ Complex.cpp‬לפי הממשק הנתון בקובץ‬
‫‪ .Complex.h‬זוהי מחלקת מספרים מורכביםאשר תוכלו לבדוק באמצעותה את המימוש שלכם‬
‫למטריצה הגנרית‪.‬‬
‫‪ (b‬אין להגיש קבצים אלו‪.‬‬

‫‪ (4‬התמחות )‪.(specialization‬‬
‫‪ (a‬בנוסף למימוש הגנרי של המחלקה ‪ ,Matrix‬עליכם להוסיף לקובץ ‪ Matrix.hpp‬גם מימוש ספציפי‬
‫​‪ ,‬המחשבת את הצמוד ‪ 2‬של המטריצה )הכוונה למטריצה‬
‫​מימוש אלטרנטיבי לפונקציה ‪trans‬‬
‫אחד‪:‬‬
‫צמודה הרמטית ולא קלאסית(‪ ,‬עבור המקרה בו הטיפוס של האיברים הוא ‪.Complex‬‬

‫‪ (5‬תיכנות מקבילי‪:‬‬
‫‪ (a‬בתרגיל זה עליכם לספק מימוש מקבילי לאופרטורים ‪ +‬ו­ *‪.‬‬
‫‪ (b‬רקע ­ עיבוד מקבילי הוא עיבוד בו זמנית של מטלה מסוימת על ידי מספר מעבדים או מספר ליבות‪,‬‬
‫כאשר היא מפוצלת בהתאם‪ ,‬כדי להגיע לתוצאות מהר יותר משיטה של עיבוד טורי‪ .‬הרעיון מבוסס על‬
‫העובדה שניתן בדרך כלל לפצל את תהליך הפתרון של בעיה כלשהי למספר מטלות קטנות יותר‪,‬‬
‫שאותן ניתן לבצע בו­זמנית‪ ,‬עם מידה מסוימת של תיאום‪.‬‬
‫בתרגיל זה נתרגל מעט תיכנות מקבילי ונטעם על קצה המזלג את היתרונות והחסרונות שלו‪.‬‬
‫‪ (c‬עליכם להגדיר בקובץ ‪ Matrix.hpp‬מתודה סטטית בשם ‪ setParallel‬המקבלת ארגומנט מסוג ‪.bool‬‬
‫​ של‬
‫​פעולות הכפל‪/‬חיבור‬
‫​‪,‬‬
‫במידה והארגומנט הוא ‪ ,true‬לאחר הקריאה למתודה עם הערך ‪true‬‬
‫מטריצות יתבצעו באמצעות תכנות מקבילי‪ .‬קריאה למתודה עם ארגומנט ‪ false‬תחזיר את המחלקה‬
‫להתנהגות הדיפולטיבית שלה‪ ,‬בה יתבצעו פעולות כפל‪/‬חיבור באופן טורי )כרגיל(‪.‬‬
‫‪ (d‬בעקבות כל קריאה למתודה שמשנה את התנהגות המחלקה עליכם להדפיס את ההודעה הבאה‪:‬‬
‫‪Generic Matrix mode changed to (parallel|non­parallel) mode.‬‬
‫​ יחסית למצב הנוכחי‪.‬‬
‫ההודעה תודפס רק אם היה שינוי בהתנהגות המחלקה‬
‫‪2‬‬

‫‪https://en.wikipedia.org/wiki/Conjugate_transpose‬‬

‫‪ (e‬על מנת להקל עליכם ובכדי שהביצועים שלכם יהיו דומים‪ ,‬אתם נדרשים לשמור על הכללים הבאים‪:‬‬
‫●‬

‫המתודות אותן יש לממש גם במוד מקבילי‪ ,‬הן אופרטורי הכפל )*( והחיבור )‪ (+‬בלבד‪.‬‬

‫●‬

‫על מנת למנוע הסתבכויות מיותרות‪ ,‬עליכם להשתמש באלגוריתם הנאיבי של כפל מטריצות‬
‫‪3‬‬

‫­ ‪ , Iterative Algorithm‬גם למימוש הטורי )רגיל( וגם למימוש המקבילי‪.‬‬
‫●‬

‫בכל הפעולות הנ"ל על התכנות המקבילי להתבצע עבור כל שורה במטריצת התוצאה‬
‫במקביל )כלומר‪ ,‬שימוש ב ‪ thread‬נפרד לכל חישוב שורה במטריצת תוצאה(‪.‬‬

‫‪ (6‬השוואת עיבוד מקבילי וטורי‪:‬‬
‫‪ (a‬בחלק זה של התרגיל אנו נשווה את התנהגות של התכנות המקבילי אל התכנות הטורי‪ ,‬וננסה לזהות‬
‫חלק מהיתרונות והחסרונות שלהם‪.‬‬
‫‪ (b‬לשם כך מסופקים לכם‪:‬‬
‫●‬

‫קובץ בשם ‪ParllelChecker.cpp‬‬

‫●‬

‫‪ 2‬קבצי קלט המכילים נתונים באמצעותם תתבצע ההשוואה‪:‬‬

‫‪~slabcpp/www/sets/big.txt‬‬
‫‪~slabcpp/www/sets/small.txt‬‬
‫)‪ big.txt‬קובץ גדול ואנו מציעים לקרוא אותו ישירות מהנתיב המסופק(‬
‫‪ (c‬אנו נשתמש ב­ ‪ ParllelChecker‬על מנת להשוות את זמן הריצה במצב העיבוד הטורי אל מול מצב העיבוד‬
‫המקבילי‪ ,‬עבור כל אחד מקבצי הקלט‪.‬‬
‫‪ (d‬אנו נעשה את ההשוואה הזו על ‪ 2‬קבצי הנתונים וננסה להבין האם יש הבדלים בניהם ומהם הגורמים לכך‪.‬‬
‫​‪:‬‬
‫‪ (e‬הוראות שימוש‬
‫● בצעו קומפילציה ו­‪ linkage‬עם הדגלים '‪:'­O‬‬
‫​‪​++ ­std=c++11 ­Wextra ­Wall ­pthread ­Wvla‬‬
‫‪g‬‬
‫‪­O –DNDEBUG ParllelChecker.cpp Complex.cpp‬‬
‫‪­o ParllelChecker‬‬
‫הדגל ‪ ­O‬אומר לקומפיילר לבצע אופטימיזציות על הקוד כך שירוץ מהר יותר‪.‬‬
‫בדוגמא זו ביצענו את הקומפילציה וה­‪ linkage‬בשורה אחת‪ ,‬הדבר אינו הכרחי )אך מפשט‬
‫את החיים במקרה זה(‪.‬‬
‫●‬

‫הריצו את התכנית שנוצרה על ‪ 2‬הקבצים של הנתונים וודאו שהיא פועלת בצורה תקינה וכי‬
‫אתם מבינים כיצד להשתמש בה‪.‬‬

‫‪(f‬‬

‫סכמו את הערך המודפס עבור כל אחת מהפעולות בטבלה הבאה‪ ,‬בקובץ ה‪.README‬‬
‫‪small‬‬

‫‪+‬‬

‫*‬

‫‪big‬‬

‫‪+‬‬

‫*‬

‫מקבילי‬
‫‪3‬‬

‫‪https://en.wikipedia.org/wiki/Matrix_multiplication_algorithm#Iterative_algorithm‬‬
‫​‬

‫טורי‬
‫‪ (g‬ענו בקובץ ה ‪ README‬על השאלות הבאות‪:‬‬
‫‪(i‬‬

‫האם יש הבדל בין ‪ 2‬הסטים של הנתונים? באיזה מצב התכנית רצה מהר יותר? ממה נובע הבדל זה?‬

‫‪ (ii‬האם יש הבדל בין פעולות החיבור והחיסור‪ ,‬אל מול הכפל? ממה נובע הבדל זה?‬
‫​דרייבר ‪GenericMatrixDriver‬‬
‫‪ (7‬ה‬
‫​את המחלקה הגנרית‬
‫​באופן בסיסי‬
‫‪ (a‬לרשותכם דרייבר בשם ‪ GenericMatrixDriver.cpp‬שבודק‬
‫​‪.‬‬
‫שלכם‪ .‬אתם מוזמנים להשתמש בו ולשנותו כרצונכם‬
‫‪ (b‬אתם מוזמנים לקמפל ולהריץ אותו ביחד עם הספריה שלכם‪.‬‬
‫‪ (c‬אין להגיש קובץ זה‪.‬‬

‫‪ .5‬חומר עזר‪:‬‬
‫‪ .1‬את פתרון הבית ספר ניתן למצוא ב‪:‬‬
‫​‪~slabcpp/www/ex3/schoolSol.tar‬‬
‫הריצו אותו כדי לראות איך התכנית צריכה להתנהג‬
‫‪ .2‬את קבצי התרגיל ניתן למצוא ב‪:‬‬
‫​‪~slabcpp/www/ex3/ex3_files.tar‬‬
‫בדקו את תכניתכם וודאו שהפלטים שלכם זהים לאלה של פתרון בית הספר‪ .‬אתם יכולים לייצר‬
‫קבצי קלט רבים נוספים כדי לבדוק מקרים נוספים‪ ,‬ולהשוות את הפלט של התכנית שלכם עם פלטים‬
‫של תלמידים אחרים‪ ,‬או עם הפלט שנוצר כשאתם נותנים את הקלט הזה לקובץ הריצה של פתרון‬
‫בית הספר‪.‬‬
‫‪ .3‬ביצוע ‪ overloading‬ב­‪:++C‬‬

‫‪http://www.cprogramming.com/tutorial/operator_overloading.html‬‬
‫‪http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B‬‬
‫‪http://www.cplusplus.com/reference/set/set/operators/‬‬

‫‪ .6‬עבודה עם ‪:valgring‬‬
‫‪ .1‬ישנו מבחר די גדול של תוכנות בשוק שמטרתם לסייע באיתור בעיות זיכרון בקוד לפני שחרורו אל הלקוח‪ .‬אנו‬
‫נשתמש בתוכנת ‪ ,valgrind‬שיחסית לתוכנה חינמית‪ ,‬נותנת תוצאות מעולות‪.‬‬
‫‪ .2‬כדי להריץ את ‪ valgrind‬עליכם לבצע קומפילציה ו­‪ linkage‬לקוד שלכם עם הדגל '‪) '­g‬הן בשורת‬
‫הקומפילציה והן בשורת ה­‪ .(linkage‬לאחר מכן הריצו ‪:valgrind‬‬
‫‪> valgrind ­­leak­check=full ­­show­possibly­lost=yes‬‬
‫‪­­show­reachable=yes –undef­value­errors=yes GenericMatrixDriver‬‬
‫‪ .3‬אם קיבלתם הודעת שגיאה‪ ,‬יתכן שתצטרכו לבצע שינוי הרשאות‪:‬‬
‫‪> chmod 777 GenericMatrixDriver‬‬
‫‪ .4‬כמובן שאם ‪ valgrind‬דיווח על בעיות עם הקוד שלכם‪ ,‬עליכם לתקן אותן‪.‬‬
‫‪ .5‬היעזרו ב­‪ tutorial‬הקצרצר של ‪ valgrind‬שבאתר הקורס‪.‬‬

‫‪ .7‬הגשה‪:‬‬
‫‪ .1‬עליכם להגיש קובץ ‪ tar‬בשם ‪ ex3.tar‬המכיל את כל הקבצים הנמצאים בשימוש המחלקה שלכם ואת‬
‫הקבצים הבאים‪:‬‬
‫● ‪Matrix.hpp‬‬
‫●‬

‫קובץ ‪ Makefile‬התומך בפקודות הבאות‪:‬‬
‫○‬

‫‪ ­make Matrix‬יצירת ‪.Matrix.hpp.gch‬‬

‫○‬

‫‪ ­ make clean‬ניקוי כל הקבצים שנוצרו באמצעות פקודות ה­‪.makefile‬‬

‫○‬

‫הרצת ‪ make‬ללא פרמטרים תהיה שקולה לפקודה '‪.'make Matrix‬‬

‫●‬

‫‪ README‬עם התשובות לשאלות של העיבוד המקבילי‪.‬‬

‫●‬

‫​ במקרה שההגשה היא הגשה באיחור‪.‬‬
‫​רק‬
‫‪­ extension.pdf‬‬

‫אין להגיש את הקבצים הבאים‪:‬‬
‫‪Complex.h, Complex.cpp, GenericMatrixDriver.cpp, ParllelChecker.cpp‬‬
‫שימו לב! אל אף שאתם יכולים להוסיף קבצים נוספים כרצונכם‪ ,‬המנעו מהוספת קבצים לא רלוונטים )גם‬
‫​אנו נוריד נקודות למי שיגיש קבצים שאין בהם‬
‫בכדי להקל על הבודקים‪ ,‬וגם בכדי שציונכם לא יפגע מכך(‪.‬‬
‫​‪.‬‬
‫כל צורך‬
‫‪ .2‬ניתן ליצור קובץ ‪ tar‬כדרוש על ידי הפקודה‪:‬‬
‫>‪tar cvf  ‪~slabcpp/www/codingStyleCheck ‪ 
Source Exif Data: 
File Type                       : PDF
File Type Extension             : pdf
MIME Type                       : application/pdf
PDF Version                     : 1.4
Linearized                      : Yes
Page Count                      : 8

EXIF Metadata provided by EXIF.tools