ובקשר לsizeof.. שמע sizeof מחזיר את הגודל של הסוג.. לדוגמא:

WCHAR* _FolderPath = (WCHAR*)calloc(MaxPathSize, sizeof(WCHAR));
	if (_FolderPath == NULL)
		throw "Allocation faild";
	_tprintf(TEXT("allocated: %d\n"), sizeof(_FolderPath));

עריכה: ברגע שאתה מגדיר את המערך סטטי (ככה):

char arr(1024)

sizeof(arr) * sizeof(char)

חוץ מזה שלא ממש הבנתי את השאלה שלך, מה הבעיה של free לדעת כמה לשחרר, אתה הרי מעביר לה ארגומנט לא?

אם אני עושה ככה:

char testingIt<1024>;
	char* testst = testingIt;
	_tprintf(TEXT("allocated: %d\n"), sizeof(testst));

אם אני עושה ככה:

char testingIt<1024>;
	char* testst = testingIt;
	_tprintf(TEXT("allocated: %d\n"), sizeof(testingIt));

עזוב את זה שCHAR הוא בית אחד (תמיד) אז לעשות פעולת כפל/חילוק בדוגמה שהצגת חסרת משמעות חחח..

סבבה זכרתי איזה משהו עם זה
ד"א זה עובד אותו הדבר בווינדוס ובלינוקס? או שאחרת? סה"כ זה כבר תלוי מערכת הפעלה...

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

זה לא מדוייק מה שרשמת.
במערכת 32 ביט כל תהליך מקבל 4GB זכרון.
כמובן שבמחשב אין לך כל-כך הרבה זכרון RAM, ולכן מערכת ההפעלה מדפדפת קטעי זכרון שפחות משתמשים בהם לדיסק הקשיח.
בדר"כ הוא מקצה אחוז מסויים של זכרון לתהליך ובמידת הצורת שואב עוד או מקצץ כשהשימוש יורד.
הטבלה הזו שקופה למשתמש (כלומר, לתהליך) והיא נמצאת בגרעין מערכת ההפעלה (ה-1GB התחתון שלא מדופדף לדיסק).
מה שקורה זה שהתוכנית שלך שולחת system call ל-free (או ליתר דיוק, ל-sys_free) על כתובת הזכרון שבקישת, היא ניגשת דרך הה-hash_table לטבלה שנראת ככה:

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

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

אם יש לך עוד מידע להוסיף או לתקן את מה שאמרתי (אני קצת חלוד..) אני ישמח

ד"א אם תוכל להעלות את המצגת / המצגות של השקופית שהבאת אני ישמח :P

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

אז אני לומד קצת WINAPI ככה בשביל להשתפשף עם ווינדוס (סה"כ עד עכשיו כל התיכנותים ש"קשורים למערכת הפעלה" שעשיתי היו בלינוקס.. הרבה יותר נוח שם ת'אמת :P )
אחרי שקצת השתפשפתי עם OLLYDBG ככה בקטנה..

ושוב, זה בדיוק מה שאני רשמתי.
מערכת ההפעלה היא זו שאחראית להקצת זכרון ולשחרורו "בזמנה החופשי" (תהליך ה-idle בעיקר אחראי על זה).
אתה יכול לקרוא לקריאת מערכת והיא תכניס את זה לתור בקשות.
אני עדיין לא רואה איך התשובה שלך שונה משלי.
או שאתה לא הבנת אותי, או שאתה לא הבנת את החומר נכון

בהזדמנות, כשיהיה לי זמן לנשום, אני אעלה את קטעי הקוד מגרעין מ-red hat 8 שאחראים על האלוקציה והשחרור של זכרון.
אני מאמין שיהיה לי הרבה יותר קל להסביר כשיש לי קוד להציג.

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

המערכת הפעלה אכן אחראית לאלקוץ זכרון בשביל תהליכים, אבל זה נושא אחר לחלוטין שקשור לזכרון וירטואלי בכלל, לא לHeap של הC Runtime.

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

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

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

בסה"כ, כל תהליך, מקבל מרחב מסגרות שלא מיודע לשאר מערכת ההפעלה ובטוח שיש לו 4GB זכרון (במערך 32 ביט).

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

אתה מערבב פה בין 2 נושאים לא רלוונטים וזה סתם מטעה...

המנגנון Heap שמוכר למתכנתים דרך ממשקי malloc וfree הוא מנגנון Heap פרטי, יוזר-מודי של הC Runtime.
הHeapים שאתה מדבר עליהם הם Heapים של מערכת ההפעלה, שבוינדוס נגישים דרך HeapAlloc וVirtualAlloc (ההבדל הוא בגרנולריות ובמאפיינים).
שאתה עושה malloc וfree, המבנים היחידים שמשונים הם המבנים הפרטיים של הC Runtime בפרוסס הזה. רק שנגמר המקום בHeap הפרטי הזה, הRuntime פונה לHeapAlloc כדי להגדיל את הHeap שלו.
malloc וfree *לא* מתייחסים לפייג'ים. זה לא פונקציות מערכת, גם אם הם היו רוצות, הן *לא* יכולות.

ל-Process שמורץ יש זכרון שמוקצה משלו שמנוהל על ידי מנגנון פרטי של שפת C. במהלך הידור של תוכנית C לכל פקודה יש כתובת אבסולוטית. במהלך הרצה, בשילוב עם ה-MMU נקבעת לכל פקודה כתובת עם היסט כלשהו למקום המתאים בזכרון. בצורה הזאת C יכולה לנהל את הזכרון בעצמה, ולמעשה לא צריכה להתעסק יותר מידי עם ה-MMU, בטח שלא ב-WINDOWS.

עוד דברים -
קודם כל, malloc זאת הקצאה דינמית. אין שום ספק בכלל שהיא מוקצית על ה-heap. הקצאה דינמית אף פעם לא תוקצה על ה-STACK !
sizeof - זאת פונקציה עם חתימה פשוטה. היא מחזירה את מספר הבתים של הטיפוס/struct אותו היא מקבלת.
malloc/free עובדים יחדיו בעזרת מבנה נתונים פנימי שדואג לנהל את ההצבעות בעזרת העובדה שניתנות לכל הפקודות כתובות אבסולוטיות ובעת ההרצה, הם מקבלים כתובות אמיתיות (היסט של PC ושל ה-BS עבור ה-STACK למשל). בעת free כל מה שנעשה הוא חיפוש אחר המשתנה במבנה הנתונים ומחיקתו מהזכרון של ה-PROCESS.

זה באופן כללי.

במערכת לינוקס יש קריאות ל-MMAP, MPROTECT ול-brk(), אני לא אמשיך לרמת הקרנל שבסוף קוראת ל-FS; בכל מקרה זה לא קשור לשפת C. לכל PROCESS יש בלוק זכרון ו-C עושה עליו הקצאות בסיסיות, אם תעשה strace על תכנית קצרה של הקצאה לא תקבל קוד מפוצץ.

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

ואתה מוזמן לעיין בקוד הבא שממש את malloc ו-free במציאות:
https://rotter.name/User_files/nor/4b7433f6368c8bc7.txt

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

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

ד"א אין לי מושג בC אני מדי פעם מדבר עם אייל על זה והוא מסביר לי דברים שקשורים קצת לlow level.

אבל אתה כול שניה סותר את עצמך, מקודם אמרת שחשבת שהם התכוונו לkfree וkmalloc ועכשיו אתה שוב אומר שהתשובה שלך עדיין נכונה.

ולא יודע אם בכלל הסתכלת על מה שהבאת, אבל הוא מממש שם את sys_alloc בעזרת קריאות מערכת, ואז קורא לו. זאת לא קריאת מערכת אפילו לפי המקורות שלך.
אני לא מבין הרבה בלינוקס ולכן לא התווכחתי איתך על זה קודם, אבל כל מי ששאלתי אותו על sys_alloc אמר שזה הנפצה, אין דבר כזה, ושmalloc משתמש בBRK בלבד כדי להגדיל את הHeap הפרטי, היוזר-מודי שלו.
והנה עוד כמה מקורות לעובדה שsys_alloc זה לא קריאת מערכת בכלל
http://bluemaster.iu.hio.no/edu/oca/lin-asm/syscalls.html
http://www.kernel.org/doc/man-pages/online/dir_section_2.html
http://www.digilife.be/quickreferences/QRC/LINUX%20System%20Call%20Quick%20Reference.pdf

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

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

תקרא את האשכול הזה, קראתי אותו אולי 10 פעמים בגלל שאני מעריך אותך, ויודע מה אתה יודע.

אבל סתרת את עצמך 30000 פעם באשכול אחד.

#include <stdlib.h>
#include <stdio.h>
int main(void)
{
        char * blah = 0;
        char * blah2 = 0;
        int i = 0;
        blah = malloc(30);
        printf("first malloc address %08x\n", blah);
        free(blah);
        blah = malloc(30);
        printf("second malloc address %08x\n", blah);
        free(blah);
        blah2 = malloc(300);
        printf("third malloc address %08x\n", blah2);
        free(blah2);
        for ( i = 0 ; i < 30 ; ++i ) {
                blah2 = malloc(i);
                printf("third malloc address %08x\n", blah2);
        }
        return 0;
}

והנה האאוטפוט של strace (כלי לtracing של קריאות מערכת).

execve("./malloc_test", , ) = 0
brk(0)                                  = 0x804a000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
mmap2(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fb9000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
open("/etc/ld.so.cache", O_RDONLY)      = 3
fstat64(3, {st_mode=S_IFREG|0644, st_size=49632, ...}) = 0
mmap2(NULL, 49632, PROT_READ, MAP_PRIVATE, 3, 0) = 0xb7fac000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
open("/lib/tls/i686/cmov/libc.so.6", O_RDONLY) = 3
read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0\260e\1"..., 512) = 512
fstat64(3, {st_mode=S_IFREG|0755, st_size=1364388, ...}) = 0
mmap2(NULL, 1369712, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xb7e5d000
mmap2(0xb7fa6000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x149) = 0xb7fa6000
mmap2(0xb7fa9000, 9840, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xb7fa9000
close(3)                                = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7e5c000
set_thread_area({entry_number:-1 -> 6, base_addr:0xb7e5c6b0, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
mprotect(0xb7fa6000, 4096, PROT_READ)   = 0
munmap(0xb7fac000, 49632)               = 0
brk(0)                                  = 0x804a000
brk(0x806b000)                          = 0x806b000
fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 1), ...}) = 0
mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xb7fb8000
write(1, "first malloc address 0804a008\n", 30first malloc address 0804a008
) = 30
write(1, "second malloc address 0804a008\n", 31second malloc address 0804a008
) = 31
write(1, "third malloc address 0804a030\n", 30third malloc address 0804a030
) = 30
write(1, "third malloc address 0804a008\n", 30third malloc address 0804a008
) = 30
write(1, "third malloc address 0804a018\n", 30third malloc address 0804a018
) = 30
write(1, "third malloc address 0804a028\n", 30third malloc address 0804a028
) = 30
write(1, "third malloc address 0804a038\n", 30third malloc address 0804a038
) = 30
write(1, "third malloc address 0804a048\n", 30third malloc address 0804a048
) = 30
write(1, "third malloc address 0804a058\n", 30third malloc address 0804a058
) = 30
write(1, "third malloc address 0804a068\n", 30third malloc address 0804a068
) = 30
write(1, "third malloc address 0804a078\n", 30third malloc address 0804a078
) = 30
write(1, "third malloc address 0804a088\n", 30third malloc address 0804a088
) = 30
write(1, "third malloc address 0804a098\n", 30third malloc address 0804a098
) = 30
write(1, "third malloc address 0804a0a8\n", 30third malloc address 0804a0a8
) = 30
write(1, "third malloc address 0804a0b8\n", 30third malloc address 0804a0b8
) = 30
write(1, "third malloc address 0804a0c8\n", 30third malloc address 0804a0c8
) = 30
write(1, "third malloc address 0804a0d8\n", 30third malloc address 0804a0d8
) = 30
write(1, "third malloc address 0804a0f0\n", 30third malloc address 0804a0f0
) = 30
write(1, "third malloc address 0804a108\n", 30third malloc address 0804a108
) = 30
write(1, "third malloc address 0804a120\n", 30third malloc address 0804a120
) = 30
write(1, "third malloc address 0804a138\n", 30third malloc address 0804a138
) = 30
write(1, "third malloc address 0804a150\n", 30third malloc address 0804a150
) = 30
write(1, "third malloc address 0804a168\n", 30third malloc address 0804a168
) = 30
write(1, "third malloc address 0804a180\n", 30third malloc address 0804a180
) = 30
write(1, "third malloc address 0804a198\n", 30third malloc address 0804a198
) = 30
write(1, "third malloc address 0804a1b8\n", 30third malloc address 0804a1b8
) = 30
write(1, "third malloc address 0804a1d8\n", 30third malloc address 0804a1d8
) = 30
write(1, "third malloc address 0804a1f8\n", 30third malloc address 0804a1f8
) = 30
write(1, "third malloc address 0804a218\n", 30third malloc address 0804a218
) = 30
write(1, "third malloc address 0804a238\n", 30third malloc address 0804a238
) = 30
write(1, "third malloc address 0804a258\n", 30third malloc address 0804a258
) = 30
write(1, "third malloc address 0804a278\n", 30third malloc address 0804a278
) = 30
write(1, "third malloc address 0804a298\n", 30third malloc address 0804a298
) = 30
exit_group(0)                           = ?

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

בוא נסכם ככה: התוכנית מקצה זכרון מסויים בגודל התחלתי, משחקתי איתו באמצעות המנגנוניים הידועים ב-CRT
אבל לא! זה בלתי נמנע שכל הזמן באופן דינמי מערכת ההפעלה תשחרר ותקצה זכרון נוסף בשביל התוכנית - אחרת מערכת ההפעלה הייתה מתפוצצת מדליפות זכרון.

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

התופעה שתיארתי.
ואיך אתה חושב שהיא קרתה בדיוק? מהאוויר?
לא! תתעמק עוד טיפה בקוד, גם ב-malloc שאתה העלת, ותראה שיש באופן ישיר קריאה בסופו של דבר ל-mmap כשצריך.
אני לא מבין בכלל על מה הויכוח פה בנושא.

לך עכשיו תשווה את זה לשטויות שאמרת במהלך האשכול הזה.
שמערכת ההפעלה מטפלת בfree? זה לא נכון בשום מצב.
"מה שקורה זה שהתוכנית שלך שולחת system call ל-free (או ליתר דיוק, ל-sys_free) על כתובת הזכרון שבקישת, היא ניגשת דרך הה-hash_table לטבלה שנראת ככה:" - לא נכון גם על פי אמות המידה שלך
"(בדר"כ, היא פשוט מסמנת אותו בביט מסויים שאומר שאפשר לכתוב עליהם מחדש במקום לפנות אותם פיזית)." - קשור לPaging בכלל, איך הגעת לזה
"הם לא מאלקצים שום דבר, אם המסגרת לא קיימת הם מעלים page fault שגורם למערכת לדפדפף דף למסגרת כשצריך." - הא?
"בנוסף, ה-free כן מסמן את הבלוקים שאתה רוצה למחוק (pg_dirty)." - ללא ספק האמירה הכי שגויה באשכול הזה, pg_dirty זה בכלל הדגל בpage header שמסמן אם הpage שונה וצריך לכתוב אותו לדיסק שוב
"תראו ש-90% מהעבודה שלו זו קריאה ל-sys_free ו-sys_alloc." - עוד אמירה מנצחת, גם אין כזה דבר sys_alloc וגם בערך אחוז מהעבודה של malloc זה קריאות מערכת.

ברצינות, אתה לא רוצה להודות שטעית, אל תודה, אבל למה אתה ממשיך?

ציטוטים:
"הפונקציה free ב-99 אחוז מהקריאות לא תגרום אפילו לשימוש בWinAPI. למעשה, זה אפילו לא יעבור לקוד קרנלי"
רחוק מלהיות נכון. אתה נראה לי הוכחת את הסתירה הזו לעצמך בטרייס הנ"ל.

"אתה התחלת לדבר על נושא של Virtual Memory בכלל, שזה קשור באופן קלוש ביותר לשאלה"
* שיעול שיעול *

הכל מתחיל ומתסיים בזכרון וירטואלי, נקודה!
אם זה לא היה מתחיל ומסתיים שם, מערכת ההפעלה הייתה מפוצצת את כל הזכרון במחשב שלך בתוך 10 דק'.
כל פרוסס לא יכול להחליט כמה זכרון פיזי שהוא רוצה לקחת באופן שרירותי (אחרת לא היו מתאמצים כל-כך לעבוד על מנגנונים מתוחכמים כמו של טבלת המסגרות, שלא להזכיר את החלק של ההגנה).
מערכת ההפעלה חייבת לנהל את זה באופן שותף (נעשה ע"י הוספת הנתונים לטבלת המסגרות באמצעות ה-mmap ותהליך ה-idle שאחראי לנהל את הטבלה הזו באופן שותף).
התשובה שלך הייתה נכונה במקרה ואתה מדבר על ה-DOS (לא MS-DOS) הקדום והמיושן, ששם כל תוכנית בהחלט מדברת כמעט וישירות עם זכרון המחשב.

ונעבור לציטוט הראשון שנכון במאה אחוז, ואמנם malloc יכול לגרום לקריאה לbrk או HeapAlloc/VirtualAlloc בוינדוס, free לא יקרא לאף קריאת מערכת.
אולי אולי אולי אולי בשביל הקטנת הHeap ועניינים של פרגמנטציה.
בטח לא בשביל לסמן pg_dirty
זאת בדיחה חבר

תודה

שורה תחתונה free לא עושה שום syscall? אז בתאכלס אם תקצה גודל ענקי (4כמעט גיגה.. אנערף) ואז תשחרר אותו (בעזרת free) בסופו של דבר המערכת הפעלה תשים את הדפים שלו על הHD או שהיא גם תידע לשחרר את אותו הזכרון לגמריי? ואז בזמן הMALLOC הבא יהיה PAGEFAULT (כי לפי מה שהבנתי ממכם CRT נשאר "אחראי" על הזכרון ולא "משחרר אותו למערכת הפעלה"..) ואז מן הסתם המערכת הפעלה תטען את אותם הדפים ויוקצה עליהם הזכרון החדש שאתה צריך? (כאילו הCRT יחליט ש-כתובות מפה עד לפה עכשיו יהיו שייכות ל... אחרי שהמערכת הפעלה תחזיר את הדפים לזכרון אחרי הPAGE FAULT)
לא יודע נשמע לי קצת הזוי שברגע שאתה עושה free אתה לא מסמן כלום למערכת הפעלה שתידע שאם היא באמת צריכה את הזכרון הזה היא יכולה לקחת...?