מדוע ההקצאה הראשונה של C++ (m) היא תמיד 72 KB?

המסתורין מאחורי הקצאת C++ הראשונה שלך

אתה כותב תוכנית C++ פשוטה. אינט חדש יחיד. ארבעה בתים. אתה מפעיל את ה-strace או את פרופיל הזיכרון המועדף עליך, והנה זה - התהליך שלך רק ביקש בערך 72 KB ממערכת ההפעלה. לא 4 בתים. לא 64 בתים. 72 קילו-בייט מלאים. אם אי פעם בהית במספר הזה ותהית אם כלי העבודה שלך שיקר לך, אתה לא לבד. ההתנהגות המוזרה לכאורה הזו היא אחת השאלות הנפוצות ביותר בקרב מפתחי C++ החופרים לראשונה בפנימיות הזיכרון, והתשובה לוקחת אותנו למסע מרתק בין השכבות שיושבות בין הקוד שלך לחומרה בפועל.

מה קורה כשאתה מתקשר חדש

כדי להבין את הנתון של 72 KB, עליך לעקוב אחר שרשרת ההקצאה המלאה. כאשר קוד ה-C++ שלך מבצע int חדש, המהדר מתרגם את זה לקריאה למפעיל חדש, שברוב מערכות לינוקס מעביר ל-malloc מ-glibc. אבל malloc לא מבקש ישירות מהקרנל 4 בתים של זיכרון. הליבה פועלת בדפים - בדרך כלל 4 KB ב-x86_64 - והעלות של קריאת מערכת היא עצומה ביחס לגישה פשוטה לזיכרון. קריאה ל-brk() או mmap() עבור כל הקצאה בודדת תגרום לכל תוכנית לא טריוויאלית להיפסק.

במקום זאת, מקצה הזיכרון של glibc - מימוש שנקרא ptmalloc2, בעצמו צאצא מה-dlmalloc הקלאסי של דאג ליאה - פועל כמתווך. הוא מבקש בלוקים גדולים של זיכרון מהקרנל מראש, ואז חוצב אותם לחתיכות קטנות יותר ככל שהתוכנית שלך זקוקה להם. זו הסיבה הבסיסית שהקצאת 4 בתים הראשונה שלך מפעילה בקשה גדולה בהרבה למערכת ההפעלה. המחלק לא מבזבז. זה להיות אסטרטגי.

ניתוח ה-72 KB: לאן הולכים הבייטים

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

ראשית, malloc של glibc מאתחל את הזירה הראשית - מבנה הנהלת החשבונות הראשי שעוקב אחר כל ההקצאות בשרשור הראשי. זירה זו כוללת מטא נתונים עבור הערימה, מצביעי רשימה חופשית ומבני פח עבור גדלי הקצאה שונים. המקצה מרחיב את הפסקת התוכנית באמצעות sbrk(), וההרחבה הראשונית נשלטת על ידי פרמטר פנימי בשם M_TOP_PAD, שברירת המחדל היא 128 KB של ריפוד. עם זאת, הבקשה הראשונית בפועל מותאמת ליישור העמוד ולמיקום הפסקה הקיים, מה שלעתים קרובות מביא לבקשה ראשונה קטנה יותר - בדרך כלל נוחתת בסמוך לנתון של 72 KB בתהליך שהתחיל טרי.

שנית, מאז glibc 2.26, המקצה מאתחל מטמון מקומי של thread (tcache) בשימוש הראשון. ה-tcache מכיל 64 פחים (אחד לכל מחלקת גודל הקצאה קטנה), כל אחד מסוגל להכיל עד 7 נתחים מאוחסנים. ה-tcache_perthread_struct עצמו צורך בסביבות 1 KB, אך פעולת האתחול שלו מפעילה את הגדרת הזירה הרחבה יותר. שלישית, זמן הריצה של C++ כבר ביצע הקצאות לפני שה-main() שלך בכלל רץ - בנאים סטטיים, אתחול מאגר iostream עבור std::cout ו-Friends, והגדרות מקומיות כולם תורמים לטביעת הרגל הראשונית של הערימה.

מערכת הזירה ומדוע הקצאה מראש חכמה

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

שקול תוכנית שמבצעת 10,000 הקצאות קטנות במהלך האתחול. ללא הקצאה מראש, המשמעות היא 10,000 שיחות מערכת, בעלות של כ-1-2 אלפיות שנייה של תקורה טהורה. עם מקצה מבוסס זירה, ההקצאה הראשונה טריג

Related Posts

• משרות טכניות נהרסות בדרכים שלא נראו מאז 2008
• הצג HN: בניתי בסיס ידע של 55K מילים שיווק בדוא"ל ומיומנות קלוד קוד
• קבל בחינם את Claude max 20x למתחמי קוד פתוח
• Kyber (YC W23) מגייסת מנהל חשבון ארגוני

Frequently Asked Questions