Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by...
Transcript of Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by...
![Page 1: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/1.jpg)
1
Dynamic MemoryManagement
![Page 2: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/2.jpg)
Goals of this Lecture
Help you learn about:• The need for dynamic* memory management (DMM)• Implementing DMM using the heap section• Implementing DMM using virtual memory
* During program execution
2
![Page 3: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/3.jpg)
System-Level Functions CoveredAs noted in the Exceptions and Processes lecture…
Linux system-level functions for dynamic memory management (DMM)
3
Number Function Description12 brk() Move the program break, thus changing the
amount of memory allocated to the HEAP12 sbrk() (Variant of previous)
9 mmap() Map a virtual memory page
11 munmap() Unmap a virtual memory page
![Page 4: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/4.jpg)
Goals for DMM
Goals for effective DMM:• Time efficiency
• Allocating and freeing memory should be fast• Space efficiency
• Pgm should use little memory
Note• Easy to reduce time or space• Hard to reduce time and space
4
![Page 5: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/5.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 5
![Page 6: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/6.jpg)
Why Allocate Memory Dynamically?
Why allocate memory dynamically?
Problem• Unknown object size
• E.g. unknown element count in array• E.g. unknown node count in linked list or tree
• How much memory to allocate?
Solution 1• Guess!
Solution 2• Allocate memory dynamically
6
![Page 7: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/7.jpg)
Why Free Memory Dynamically?
Why free memory dynamically?
Problem• Pgm should use little memory, i.e.• Pgm should map few pages of virtual memory
• Mapping unnecessary VM pages bloats page tables, wastes memory/disk space
Solution• Free dynamically allocated memory that is no longer
needed
7
![Page 8: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/8.jpg)
Option 1: Automatic Freeing
Run-time system frees unneeded memory• Java, Python, …• Garbage collection
Pros:• Easy for programmer
Cons:• Performed constantly => overhead• Performed periodically => unexpected pauses
8
Car c;Plane p;...c = new Car();p = new Plane();...c = new Car();...
Original Car object can’t be accessed
![Page 9: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/9.jpg)
Option 2: Manual Freeing
Programmer frees unneeded memory• C, C++, Objective-C, …
Pros• No overhead• No unexpected pauses
Cons• More complex for programmer• Opens possibility of memory-related bugs
• Dereferences of dangling pointers, double frees, memory leaks
We’ll focus on manual freeing9
![Page 10: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/10.jpg)
Standard C DMM Functions
Standard C DMM functions:
Collectively define a dynamic memory manager (DMMgr)
We’ll focus on malloc() and free()
10
void *malloc(size_t size);void free(void *ptr);void *calloc(size_t nmemb, size_t size);void *realloc(void *ptr, size_t size);
![Page 11: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/11.jpg)
Implementing malloc() and free()
Question:• How to implement malloc() and free()?• How to implement a DMMgr?
Answer 1:• Use the heap section of memory
Answer 2:• (Later in this lecture)
11
![Page 12: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/12.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 12
![Page 13: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/13.jpg)
The Heap Section of Memory
13
Supported by Unix/Linux, MS Windows, …
Heap start is stableProgram break points to endAt process start-up, heap start == program breakCan grow dynamically
By moving program break to higher addressThereby (indirectly) mapping pages of virtual mem
Can shrink dynamicallyBy moving program break to lower addressThereby (indirectly) unmapping pages of virtual mem
Heap start Program break
Lowmemory
Highmemory
![Page 14: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/14.jpg)
Unix Heap ManagementUnix system-level functions for heap mgmt:
int brk(void *p);• Move the program break to address p• Return 0 if successful and -1 otherwise
void *sbrk(intptr_t n);• Increment the program break by n bytes• If n is 0, then return the current location of the program break• Return 0 if successful and (void*)-1 otherwise• Beware: On Linux has a known bug (overflow not handled);
should call only with argument 0.
Note: minimal interface (good!)14
![Page 15: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/15.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 15
![Page 16: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/16.jpg)
Minimal Impl
Data structures• None!
Algorithms (by examples)…
16
![Page 17: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/17.jpg)
Minimal Impl malloc(n) Example
17
p
Call sbrk(0) to determine current program break (p)
p
n bytes
Call brk(p+n) to increase heap size
p
n bytes
Return p
![Page 18: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/18.jpg)
Minimal Impl free(p) Example
18
Do nothing!
![Page 19: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/19.jpg)
Minimal Impl
Algorithms
19
void *malloc(size_t n)
{ char *p = sbrk(0);
if (brk(p + n) == -1)
return NULL;
return p;
}
void free(void *p)
{
}
![Page 20: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/20.jpg)
Minimal Impl Performance
Performance (general case)• Time: bad
• Two system calls per malloc()• Space: bad
• Each call of malloc() extends heap size• No reuse of freed chunks
20
![Page 21: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/21.jpg)
What’s Wrong?
Problem•malloc() executes two system calls
Solution• Redesign malloc() so it does fewer system calls• Maintain a pad at the end of the heap…
21
![Page 22: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/22.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 22
![Page 23: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/23.jpg)
Pad ImplData structures
•pBrk: address of end of heap (i.e. the program break)•pPad: address of beginning of pad
Algorithms (by examples)…23
inuse
pPad
pad
pBrk
char *pPad = NULL;
char *pBrk = NULL;
![Page 24: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/24.jpg)
Pad lmpl malloc(n) Example 1
24
Are there at least n bytes between pPad and pBrk? Yes!Save pPad as p; add n to pPad
pPad
≥ n bytes
pBrk
Return pp pBrk
n bytes
pPad
p pBrk
n bytes
pPad
![Page 25: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/25.jpg)
Pad lmpl malloc(n) Example 2
25
Are there at least n bytes between pPad and pBrk? No!Call brk() to allocate (more than) enough additional memory
pPad
< n bytes
pBrk
Set pBrk to new program break
pBrk
≥ n bytes
pPad
Proceed as previously!
pBrk
≥ n bytes
pPad
![Page 26: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/26.jpg)
Pad Impl free(p) Example
26
Do nothing!
![Page 27: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/27.jpg)
Pad Impl
Algorithms
27
inuse
pPad
pad
pBrk
void *malloc(size_t n)
{ enum {MIN_ALLOC = 8192};
char *p;
char *pNewBrk;
if (pBrk == NULL)
{ pBrk = sbrk(0);
pPad = pBrk;
}
if (pPad + n > pBrk) /* move pBrk */
{ pNewBrk =
max(pPad + n, pBrk + MIN_ALLOC);
if (brk(pNewBrk) == -1) return NULL;
pBrk = pNewBrk;
}
p = pPad;
pPad += n;
return p;
}
void free(void *p)
{
}
![Page 28: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/28.jpg)
Pad Impl Performance
Performance (general case)• Time: good• malloc() calls sbrk() initially• malloc() calls brk() infrequently thereafter
• Space: bad• No reuse of freed chunks
28
![Page 29: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/29.jpg)
What’s Wrong?
Problem•malloc() doesn’t reuse freed chunks
Solution•free() marks freed chunks as “free”•malloc() uses marked chunks whenever possible•malloc() extends size of heap only when necessary
29
![Page 30: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/30.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 30
![Page 31: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/31.jpg)
Fragmentation
31
DMMgr must be concerned about fragmentation…
inuse free
At any given time, some heap memory chunks arein use, some are marked “free”
![Page 32: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/32.jpg)
Internal Fragmentation
32
Internal fragmentation: waste within chunksExample
GenerallyProgram asks for n bytesDMMgr provides chunk of size n+Δ bytesΔ bytes wasted
Space efficiency =>DMMgr should reduce internal fragmentation
100 bytes
Client asks for 90 bytesDMMgr provides chunk of size 100 bytes10 bytes wasted
![Page 33: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/33.jpg)
External Fragmentation
33
External fragmentation: waste between chunksExample
GenerallyProgram asks for n bytesn bytes are available, but not contiguouslyDMMgr must extend size of heap to satisfy request
Space efficiency =>DMMgr should reduce external fragmentation
100 bytes
Client asks for 150 bytes150 bytes are available, but not contiguouslyDMMgr must extend size of heap
50 bytes
![Page 34: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/34.jpg)
DMMgr Desired Behavior Demo
34
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
![Page 35: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/35.jpg)
DMMgr Desired Behavior Demo
35
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
![Page 36: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/36.jpg)
DMMgr Desired Behavior Demo
36
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p2
![Page 37: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/37.jpg)
DMMgr Desired Behavior Demo
37
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p2p3
![Page 38: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/38.jpg)
DMMgr Desired Behavior Demo
38
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p2p3
External fragmentation occurred
![Page 39: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/39.jpg)
DMMgr Desired Behavior Demo
39
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p2p3
p4
![Page 40: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/40.jpg)
DMMgr Desired Behavior Demo
40
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p2p3
p4
DMMgr coalesced two free chunks
![Page 41: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/41.jpg)
DMMgr Desired Behavior Demo
41
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p5, p2p3
p4
DMMgr reused previously freed chunk
![Page 42: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/42.jpg)
DMMgr Desired Behavior Demo
42
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p5, p2p3
p4
![Page 43: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/43.jpg)
DMMgr Desired Behavior Demo
43
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p5, p2p3
p4
![Page 44: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/44.jpg)
DMMgr Desired Behavior Demo
44
0
0xffffffff
Stack
}Heap
Heap
char *p1 = malloc(3);char *p2 = malloc(1);char *p3 = malloc(4);free(p2);char *p4 = malloc(6);free(p3);char *p5 = malloc(2);free(p1);free(p4);free(p5);
p1
p5, p2p3
p4
![Page 45: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/45.jpg)
DMMgr Desired Behavior Demo
DMMgr cannot:• Reorder requests
• Client may allocate & free in arbitrary order• Any allocation may request arbitrary number of bytes
• Move memory chunks to improve performance• Client stores addresses• Moving a memory chunk would invalidate client
pointer!
Some external fragmentation is unavoidable
45
![Page 46: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/46.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 46
![Page 47: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/47.jpg)
List ImplData structures
Algorithms (by examples)… 47
Free list contains all free chunksIn order by mem addr
Each chunk contains header & payloadPayload is used by clientHeader contains chunk size & (if free) addr of next chunk in free list
size
header
chunk
Next chunk in free list
payload
Free list
![Page 48: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/48.jpg)
List Impl: malloc(n) Example 1
48
Search list for big-enough chunkNote: first-fit (not best-fit) strategy
Found & reasonable size =>Remove from list and return payload
< n >= ntoo small reasonable
Free list
< n >= nreturn this
Free list
![Page 49: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/49.jpg)
List Impl: malloc(n) Example 2
49
Search list for big-enough chunkFound & too big =>
Split chunk, return payload of tail endNote: Need not change links
< n >> ntoo small too big
Free list
< n nreturn this
Free list
![Page 50: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/50.jpg)
List Impl: free(p) Example
50
Search list for proper insertion spotInsert chunk into list(Not finished yet!)
free this
Free list
Free list
![Page 51: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/51.jpg)
List Impl: free(p) Example (cont.)
51
Look at current chunkNext chunk in memory == next chunk in list =>
Remove both chunks from listCoalesceInsert chunk into list
(Not finished yet!)
currentchunk
Free list
Free list
next chunk In list
coalesced chunk
![Page 52: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/52.jpg)
List Impl: free(p) Example (cont.)
52
Look at prev chunk in listNext in memory == next in list =>
Remove both chunks from listCoalesceInsert chunk into list
(Finished!)
prev chunkin list
Free list
Free list
current chunk
coalesced chunk
![Page 53: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/53.jpg)
List Impl: malloc(n) Example 3
53
Search list for big-enough chunkNone found =>
Call brk() to increase heap sizeInsert new chunk at end of list
(Not finished yet!)
too small too small
Free list
≥ nnew large chunk
Free listtoo small
![Page 54: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/54.jpg)
List Impl: malloc(n) Example 3 (cont.)
54
Look at prev chunk in listNext chunk memory == next chunk in list =>
Remove both chunks from listCoalesceInsert chunk into list
Then proceed to use the new chunk, as before(Finished!)
prev chunkIn list
≥ nnew large chunk
Free list
≥ nnew large chunk
Free list
![Page 55: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/55.jpg)
List ImplAlgorithms (see precepts for more precision)
malloc(n)• Search free list for big-enough chunk• Chunk found & reasonable size => remove, use• Chunk found & too big => split, use tail end• Chunk not found => increase heap size, create new chunk• New chunk reasonable size => remove, use• New chunk too big => split, use tail end
free(p)• Search free list for proper insertion spot• Insert chunk into free list• Next chunk in memory also free => remove both, coalesce, insert• Prev chunk in memory free => remove both, coalesce, insert
55
![Page 56: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/56.jpg)
List Impl PerformanceSpace
• Some internal & external fragmentation is unavoidable• Headers are overhead• Overall: good
Time: malloc()• Must search free list for big-enough chunk• Bad: O(n)• But often acceptable
Time: free()• Must search free list for insertion spot• Bad: O(n)• Often very bad 56
![Page 57: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/57.jpg)
What’s Wrong?
Problem•free() must traverse (long) free list, so can be (very)
slow
Solution• Use a doubly-linked list…
57
![Page 58: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/58.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 58
![Page 59: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/59.jpg)
Doubly-Linked List ImplData structures
59
Free list is doubly-linkedEach chunk contains header, payload, footerPayload is used by clientHeader contains status bit, chunk size, & (if free) addr of next chunk in listFooter contains redundant chunk size & (if free) addr of prev chunk in listFree list is unordered
1size
header
chunk
Next chunk in free list
payload
size
Prev chunk in free list
footer
Status bit:0 => free1 => in use
![Page 60: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/60.jpg)
Doubly-Linked List Impl
Typical heap during program execution:
60
Free list
![Page 61: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/61.jpg)
Doubly-Linked List ImplAlgorithms (see precepts for more precision)
malloc(n)• Search free list for big-enough chunk• Chunk found & reasonable size => remove, set status, use• Chunk found & too big => remove, split, insert tail, set status, use
front• Chunk not found => increase heap size, create new chunk, insert• New chunk reasonable size => remove, set status, use• New chunk too big => remove, split, insert tail, set status, use front
61
![Page 62: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/62.jpg)
Doubly-Linked List Impl
Algorithms (see precepts for more precision)
free(p)• Set status• Search free list for proper insertion spot• Insert chunk into free list• Next chunk in memory also free => remove both, coalesce, insert• Prev chunk in memory free => remove both, coalesce, insert
62
![Page 63: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/63.jpg)
Doubly-Linked List Impl PerformanceConsider sub-algorithms of free()…
Insert chunk into free list• Linked list version: slow
• Traverse list to find proper spot• Doubly-linked list version: fast
• Insert at front!
Remove chunk from free list• Linked list version: slow
• Traverse list to find prev chunk in list• Doubly-linked list version: fast
• Use backward pointer of current chunk to find prev chunk in list 63
![Page 64: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/64.jpg)
Doubly-Linked List Impl PerformanceConsider sub-algorithms of free()…
Determine if next chunk in memory is free• Linked list version: slow
• Traverse free list to see if next chunk in memory is in list• Doubly-linked list version: fast
64
current next
Use current chunk’s size to find next chunkExamine status bit in next chunk’s header
Free list
![Page 65: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/65.jpg)
Doubly-Linked List Impl PerformanceConsider sub-algorithms of free()…
Determine if prev chunk in memory is free• Linked list version: slow
• Traverse free list to see if prev chunk in memory is in list• Doubly-linked list version: fast
65
currentprev
Fetch prev chunk’s size from its footerDo ptr arith to find prev chunk’s headerExamine status bit in prev chunk’s header
Free list
![Page 66: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/66.jpg)
Doubly-Linked List Impl Performance
Observation:• All sub-algorithms of free() are fast•free() is fast!
66
![Page 67: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/67.jpg)
Doubly-Linked List Impl PerformanceSpace
• Some internal & external fragmentation is unavoidable• Headers & footers are overhead• Overall: Good
Time: free()• All steps are fast• Good: O(1)
Time: malloc()• Must search free list for big-enough chunk• Bad: O(n)• Often acceptable• Subject to bad worst-case behavior
• E.g. long free list with big chunks at end
67
![Page 68: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/68.jpg)
What’s Wrong?
Problem•malloc() must traverse doubly-linked list, so can be
slow
Solution• Use multiple doubly-linked lists (bins)…
68
![Page 69: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/69.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 69
![Page 70: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/70.jpg)
Data structures
Bins Impl
70
Use an array; each element is a binEach bin is a doubly-linked list of free chunks
As in previous implementationbin[i] contains free chunks of size i
Exception: Final bin contains chunks of size MAX_BIN or larger
(More elaborate binning schemes are common)
Doubly-linked list containing free chunks of size 10
…
…
Doubly-linked list containing free chunks of size 11
Doubly-linked list containing free chunks of size 12
10
11
12
MAX_BIN Doubly-linked list containing free chunks of size >= MAX_BIN
…
![Page 71: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/71.jpg)
Bins ImplAlgorithms (see precepts for more precision)
malloc(n)• Search free list proper bin(s) for big-enough chunk• Chunk found & reasonable size => remove, set status, use• Chunk found & too big => remove, split, insert tail, set status, use
front• Chunk not found => increase heap size, create new chunk• New chunk reasonable size => remove, set status, use• New chunk too big => remove, split, insert tail, set status, use front
free(p)• Set status• Insert chunk into free list proper bin • Next chunk in memory also free => remove both, coalesce, insert• Prev chunk in memory free => remove both, coalesce, insert
71
![Page 72: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/72.jpg)
Bins Impl PerformanceSpace
• Pro: For small chunks, uses best-fit (not first-fit) strategy• Could decrease internal fragmentation and splitting
• Con: Some internal & external fragmentation is unavoidable• Con: Headers, footers, bin array are overhead• Overall: good
Time: malloc()• Pro: Binning limits list searching
• Search for chunk of size i begins at bin i and proceeds downward• Con: Could be bad for large chunks (i.e. those in final bin)
• Performance degrades to that of list version• Overall: good O(1)
Time: free()• Good: O(1)
72
![Page 73: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/73.jpg)
DMMgr Impl Summary (so far)
Implementation Space Time(1) Minimal Bad Malloc: Bad
Free: Good(2) Pad Bad Malloc: Good
Free: Good(3) List Good Malloc: Bad (but could be OK)
Free: Bad(4) Doubly-Linked
ListGood Malloc: Bad (but could be OK)
Free: Good(5) Bins Good Malloc: Good
Free: Good
73
Assignment 6: Given (3), compose (4) and (5)
![Page 74: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/74.jpg)
74
What’s Wrong?Observations
• Heap mgr might want to free memory chunks by unmapping them rather than marking them• Minimizes virtual page count
• Heap mgr can call brk(pBrk–n) to decrease heap size• And thereby unmap heap memory
• But often memory to be unmapped is not at high end of heap!
Problem• How can heap mgr unmap memory effectively?
Solution• Don’t use the heap!
![Page 75: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/75.jpg)
75
What’s Wrong?Reprising a previous slide…
Question:• How to implement malloc() and free()?• How to implement a DMMgr?
Answer 1:• Use the heap section of memory
Answer 2:• Make use of virtual memory concept…
![Page 76: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/76.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 76
![Page 77: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/77.jpg)
Unix VM Mapping FunctionsUnix allows application programs to map/unmap VM
explicitlyvoid *mmap(void *p, size_t n, int prot, int flags, int fd, off_t offset);• Creates a new mapping in the virtual address space of the calling
process• p: the starting address for the new mapping• n: the length of the mapping• If p is NULL, then the kernel chooses the address at which to create
the mapping; this is the most portable method of creating a new mapping
• On success, returns address of the mapped area
int munmap(void *p, size_t n);• Deletes the mappings for the specified address range
77
![Page 78: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/78.jpg)
78
Unix VM Mapping FunctionsTypical call of mmap() for allocating memory
p = mmap(NULL, n, PROT_READ|PROT_WRITE,MAP_PRIVATE|MAP_ANON, 0, 0);
• Asks OS to map a new read/write area of virtual memory containing n bytes
• Returns the virtual address of the new area on success, (void*)-1 on failure
Typical call of munmap()status = munmap(p, n);• Unmaps the area of virtual memory at virtual address p consisting of n bytes
• Returns 0 on success, -1 on failure
See Bryant & O’Hallaron book and man pages for details
![Page 79: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/79.jpg)
AgendaThe need for DMM
DMM using the heap section
DMMgr 1: Minimal implementation
DMMgr 2: Pad implementation
Fragmentation
DMMgr 3: List implementation
DMMgr 4: Doubly-linked list implementation
DMMgr 5: Bins implementation
DMM using virtual memory
DMMgr 6: VM implementation 79
![Page 80: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/80.jpg)
VM Mapping ImplData structures
80
size
header
chunk
payload
Each chunk consists of a header and payloadEach header contains size
![Page 81: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/81.jpg)
VM Mapping ImplAlgorithms
81
void *malloc(size_t n)
{ size_t *p;
if (n == 0) return NULL;
p = mmap(NULL, n + sizeof(size_t), PROT_READ|PROT_WRITE,
MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
if (p == (void*)-1) return NULL;
*p = n + sizeof(size_t); /* Store size in header */
p++; /* Move forward from header to payload */
return p;
}
void free(void *p)
{ if (p == NULL) return;
p--; /* Move backward from payload to header */
munmap(p, *p);
}
![Page 82: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/82.jpg)
VM Mapping Impl PerformanceSpace
• Fragmentation problem is delegated to OS• Overall: Depends on OS
Time• For small chunks
• One system call (mmap()) per call of malloc()• One system call (munmap()) per call of free()• Overall: poor
• For large chunks• free() unmaps (large) chunks of memory, and so
shrinks page table• Overall: maybe good!
82
![Page 83: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/83.jpg)
The GNU ImplementationObservation•malloc() and free() on CourseLab are from the
GNU (the GNU Software Foundation)
Question• How are GNU malloc() and free() implemented?
Answer• For small chunks
• Use heap (sbrk() and brk())• Use bins implementation
• For large chunks• Use VM directly (mmap() and munmap())
83
![Page 84: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/84.jpg)
SummaryThe need for DMM
• Unknown object size
DMM using the heap section• On Unix: sbrk() and brk()• Complicated data structures and algorithms• Good for managing small memory chunks
DMM using virtual memory• On Unix: mmap() and munmap()• Good for managing large memory chunks
See Appendix for additional approaches/refinements84
![Page 85: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/85.jpg)
Appendix: Additional Approaches
Some additional approaches to dynamic memory mgmt…
85
![Page 86: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/86.jpg)
Selective Splitting
Observation• In previous implementations, malloc() splits whenever
chosen chunk is too big
Alternative: selective splitting• Split only when remainder is above some threshold
Pro• Reduces external fragmentation
Con• Increases internal fragmentation
86
Inuse
Inuse
![Page 87: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/87.jpg)
Deferred Coalescing
Observation• Previous implementations do coalescing whenever
possible
Alternative: deferred coalescing• Wait, and coalesce many chunks at a later time
Pro• Handles malloc(n);free();malloc(n) sequences
well
Con• Complicates algorithms
87
Inuse
Inuse
![Page 88: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/88.jpg)
88
Segregated Data
Observation• Splitting and coalescing consume lots of overhead
Problem• How to eliminate that overhead?
Solution: segregated data• Make use of the virtual memory concept…• Use bins• Store each bin’s chunks in a distinct (segregated) virtual
memory page• Elaboration…
![Page 89: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/89.jpg)
89
Segregated Data
Segregated data• Each bin contains chunks of fixed sizes
• E.g. 32, 64, 128, …• All chunks within a bin are from same virtual memory
page•malloc() never splits! Examples:• malloc(32) => provide 32• malloc(5) => provide 32• malloc(100) => provide 128
•free() never coalesces!• Free block => examine address, infer virtual memory
page, infer bin, insert into that bin
![Page 90: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/90.jpg)
Segregated Data
Pros• Eliminates splitting and coalescing overhead• Eliminates most meta-data; only forward links required
• No backward links, sizes, status bits, footers
Con• Some usage patterns cause excessive external
fragmentation• E.g. Only one malloc(32) wastes all but 32 bytes of
one virtual page
90
![Page 91: Dynamic Memory Management - cs.princeton.edu€¦ · The Heap Section of Memory 13 Supported by Unix/Linux, MS Windows, … Heap start is stable Program break points to end At process](https://reader035.fdocuments.us/reader035/viewer/2022071006/5fc3a2db00d7882c03228374/html5/thumbnails/91.jpg)
91
Segregated Meta-DataObservations
• Meta-data (chunk sizes, status flags, links, etc.) are scattered across the heap, interspersed with user data
• Heap mgr often must traverse meta-data
Problem 1• User error easily can corrupt meta-data
Problem 2• Frequent traversal of meta-data can cause excessive page faults
(poor locality)
Solution: segregated meta-data• Make use of the virtual memory concept…• Store meta-data in a distinct (segregated) virtual memory page from
user data