![Page 1: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/1.jpg)
1
Dynamic Memory
Management
Princeton UniversityComputer Science 217: Introduction to Programming Systems
![Page 2: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/2.jpg)
Goals of this Lecture
Help you learn about:• The need for dynamic* memory mgmt (DMM)
• Implementing DMM using the heap section
• Implementing DMM using virtual memory
* During program execution
2
![Page 3: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/3.jpg)
System-Level Functions Covered
As noted in the Exceptions and Processes lecture…
Linux system-level functions for dynamic memory
management (DMM)
3
Number Function Description
12 brk() Move the program break, thus changing the
amount of memory allocated to the HEAP
12 sbrk() (Variant of previous)
9 mmap() Map a virtual memory page
11 munmap() Unmap a virtual memory page
![Page 4: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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 · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/5.jpg)
Agenda
The 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 · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/6.jpg)
Why Allocate Memory Dynamically?
Why allocate memory dynamically?
Problem• Number of objects needed not known in advance
(e.g., how many elements of linked list or tree?)
• Unknown object size
(e.g., how large should the array be, in hash table?)
How much memory to allocate?
Solution 1• Guess!
Solution 2• Allocate memory dynamically
6
![Page 7: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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 · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/8.jpg)
Option 1: Automatic Freeing
Run-time system frees unneeded memory• Java, Python, …
• Garbage collection
Pros:• Easy for programmer
• Fewer bugs
• Simpler interfaces between modules
• Fewer bugs
Cons:• Performed constantly ⇒ overhead
• Performed periodically ⇒ unexpected pauses(these days, high-performance garbage collectors minimize overhead and pause latency)
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 · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/9.jpg)
Option 2: Manual Freeing
Programmer frees unneeded memory• C, C++, Objective-C, …
Pros• Less overhead
• No unexpected pauses
Cons• More complex for programmer
• Opens possibility of memory-related bugs
• Dereferences of dangling pointers, double frees, memory leaks
9
![Page 10: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/10.jpg)
Conclusion:
Program in a safe,
garbage-collected
language!
(not in C)
Use unsafe languages with
manual memory
management (such as C)
only for low-level programs
where the overhead or
latency of garbage collection
is intolerable
such as: OS kernels,
device drivers,
garbage collectors,
memory managers
10
All right then, let’s see how manual memory
management works in C
![Page 11: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/11.jpg)
C memory allocation library
Standard C dynamic-memory-management functions:
Collectively define a dynamic memory manager (DMMgr)
We’ll focus on malloc() and free()
11
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 12: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/12.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)
12
![Page 13: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/13.jpg)
Agenda
The 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 13
![Page 14: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/14.jpg)
The Heap Section of Memory
14
Supported by Unix/Linux, MS Windows, …
Heap start is stable
Program break points to end
At process start-up, heap start == program break
Can grow dynamically
By moving program break to higher address
Thereby (indirectly) mapping pages of virtual mem
Can shrink dynamically
By moving program break to lower address
Thereby (indirectly) unmapping pages of virtual mem
Heap start Program break
Low
memory
High
memory
![Page 15: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/15.jpg)
Unix Heap Management
Unix 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
• Return previous break if successful and (void*)-1 otherwise• [therefore] If n is 0, return the current location of the program break
• Beware: On Linux has a known bug (overflow not handled);
should call only with argument 0.
Note: minimal interface (good!)
15
![Page 16: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/16.jpg)
Agenda
The 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 16
![Page 17: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/17.jpg)
Minimal Impl
Data structures• One word: remember the current value of program break
Algorithms (by examples)…
17
![Page 18: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/18.jpg)
Minimal Impl malloc(n) Example
18
p
Remember the current program break (p) (initialize using sbrk(0))
p
n bytes
Call brk(p+n) to increase heap size
return
n bytes
Return p, remember new p = p+n
p
![Page 19: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/19.jpg)
Minimal Impl free(p) Example
19
Do nothing!
p
![Page 20: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/20.jpg)
Minimal Impl
Algorithms
20
static void *current_break;
void *malloc(size_t n)
{ char *p = current_break;
if (!p) p=(char *)sbrk(0);
if (brk(p+n) == -1)
return NULL;
current_break = p+n;
return (void*)p;
}
void free(void *p)
{
}
![Page 21: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/21.jpg)
Minimal Impl Performance
Performance (general case)• Time: bad
• One system call per malloc()
• Space: bad
• Each call of malloc() extends heap size
• No reuse of freed chunks
21
![Page 22: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/22.jpg)
What’s Wrong?
Problem• malloc() executes a system call every time
Solution• Redesign malloc() so it does fewer system calls
• Maintain a pad at the end of the heap…
22
![Page 23: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/23.jpg)
Agenda
The 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 23
![Page 24: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/24.jpg)
Pad Impl
Data structures
• pBrk: address of end of heap (i.e. the program break)
• pPad: address of beginning of pad
Algorithms (by examples)…
24
inuse
pPad
pad
pBrk
char *pPad = NULL;
char *pBrk = NULL;
![Page 25: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/25.jpg)
Pad lmpl malloc(n) Example 1
25
Are there at least n bytes between pPad and pBrk? Yes!
Save pPad as p; add n to pPad
pPad
≥ n bytes
pBrk
Return p
p pBrk
n bytes
pPad
p pBrk
n bytes
pPad
![Page 26: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/26.jpg)
Pad lmpl malloc(n) Example 2
26
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 27: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/27.jpg)
Pad Impl free(p) Example
27
Do nothing!
![Page 28: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/28.jpg)
Pad Impl
Algorithms
28
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 29: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/29.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
29
![Page 30: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/30.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
30
![Page 31: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/31.jpg)
Agenda
The 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 31
![Page 32: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/32.jpg)
Fragmentation
32
DMMgr must be concerned about fragmentation…
inuse free
At any given time, some heap memory chunks are
in use, some are marked “free”
![Page 33: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/33.jpg)
Internal Fragmentation
33
Internal fragmentation: waste within chunks
Example
Generally
Program asks for n bytes
DMMgr provides chunk of size n+Δ bytes
Δ bytes wasted
Space efficiency ⇒DMMgr should reduce internal fragmentation
100 bytes
Client asks for 90 bytes
DMMgr provides chunk of size 100 bytes
10 bytes wasted
![Page 34: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/34.jpg)
External Fragmentation
34
External fragmentation: waste between chunks
Example
Generally
Program asks for n bytes
n bytes are available, but not contiguously
DMMgr must extend size of heap to satisfy request
Space efficiency ⇒DMMgr should reduce external fragmentation
100 bytes
Client asks for 150 bytes
150 bytes are available, but not contiguously
DMMgr must extend size of heap
50 bytes
![Page 35: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/35.jpg)
DMMgr Desired Behavior Demo
35
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 36: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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
![Page 37: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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
p2
![Page 38: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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
![Page 39: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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
External fragmentation occurred
![Page 40: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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
![Page 41: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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
p2p3
p4
DMMgr coalesced two free chunks
![Page 42: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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
DMMgr reused previously freed chunk
![Page 43: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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 · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/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 · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/45.jpg)
DMMgr Desired Behavior Demo
45
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 46: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/46.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
46
![Page 47: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/47.jpg)
Agenda
The 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 47
![Page 48: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/48.jpg)
List Impl
Data structures
Algorithms (by examples)… 48
Free list contains all free chunks
In order by mem addr
Each chunk contains header & payload
Payload is used by client
Header contains chunk size & (if free) addr of next chunk in free list
size
header
chunk
Next chunk in free list
payload
Free list
![Page 49: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/49.jpg)
List Impl: malloc(n) Example 1
49
Search list for big-enough chunk
Note: first-fit (not best-fit) strategy
Found & reasonable size ⇒Remove from list and return payload
< n >= n
too small reasonable
Free list
< n >= n
return this
Free list
![Page 50: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/50.jpg)
List Impl: malloc(n) Example 2
50
Search list for big-enough chunk
Found & too big ⇒Split chunk, return payload of tail end
Note: Need not change links
< n >> n
too small too big
Free list
< n n
return this
Free list
![Page 51: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/51.jpg)
List Impl: free(p) Example
51
Search list for proper insertion spot
Insert chunk into list
(Not finished yet!)
free this
Free list
Free list
![Page 52: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/52.jpg)
List Impl: free(p) Example (cont.)
52
Look at current chunk
Next chunk in memory == next chunk in list ⇒Remove both chunks from list
Coalesce
Insert chunk into list
(Not finished yet!)
current
chunk
Free list
Free list
next chunk
In list
coalesced chunk
![Page 53: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/53.jpg)
List Impl: free(p) Example (cont.)
53
Look at prev chunk in list
Next in memory == next in list ⇒Remove both chunks from list
Coalesce
Insert chunk into list
(Finished!)
prev chunk
in list
Free list
Free list
current chunk
coalesced chunk
![Page 54: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/54.jpg)
List Impl: malloc(n) Example 3
54
Search list for big-enough chunk
None found ⇒Call brk() to increase heap size
Insert new chunk at end of list
(Not finished yet!)
too small too small
Free list
≥ n
new large
chunk
Free list
too small
![Page 55: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/55.jpg)
List Impl: malloc(n) Example 3 (cont.)
55
Look at prev chunk in list
Next chunk memory == next chunk in list ⇒Remove both chunks from list
Coalesce
Insert chunk into list
Then proceed to use the new chunk, as before
(Finished!)
prev chunk
In list
≥ n
new large
chunk
Free list
≥ n
new large
chunk
Free list
![Page 56: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/56.jpg)
List Impl
Algorithms (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
56
![Page 57: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/57.jpg)
List Impl Performance
Space• 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
57
![Page 58: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/58.jpg)
58
Dynamic Memory
Management,
continued
Princeton UniversityComputer Science 217: Introduction to Programming Systems
![Page 59: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/59.jpg)
Minimal Impl Performance
Performance (general case)• Time: bad
• One system call per malloc()
• Space: bad
• Each call of malloc() extends heap size
• No reuse of freed chunks
59
![Page 60: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/60.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
60
![Page 61: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/61.jpg)
Unsorted-list-no-coalesce performance
61
Space
Time: malloc()
Time: free()
![Page 62: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/62.jpg)
List Impl Performance
Space• 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
62
![Page 63: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/63.jpg)
What’s Wrong?
Problem• free() must traverse (long) free list, so can be (very) slow
Solution• Use a doubly linked list…
63
![Page 64: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/64.jpg)
Agenda
The 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 64
![Page 65: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/65.jpg)
doubly linked List Impl
Data structures
65
Free list is doubly linked
Each chunk contains header, payload, footer
Payload is used by client
Header contains status bit, chunk size, & (if free) addr of next chunk in list
Footer contains redundant chunk size & (if free) addr of prev chunk in list
Free list is unordered
1
size
header
chunk
Next chunk in free list
payload
size
Prev chunk in free list
footer
Status bit:
0 ⇒ free
1 ⇒ in use
![Page 66: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/66.jpg)
doubly linked List Impl
Typical heap during program execution:
66
Free list
![Page 67: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/67.jpg)
doubly linked List Impl
Algorithms (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
67
![Page 68: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/68.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
68
![Page 69: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/69.jpg)
doubly linked List Impl Performance
Consider 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
69
![Page 70: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/70.jpg)
doubly linked List Impl Performance
Consider 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
70
current next
Use current chunk’s size to find next chunk
Examine status bit in next chunk’s header
Free list
![Page 71: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/71.jpg)
doubly linked List Impl Performance
Consider 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
71
currentprev
Fetch prev chunk’s size from its footer
Do ptr arith to find prev chunk’s header
Examine status bit in prev chunk’s header
Free list
![Page 72: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/72.jpg)
Using payload space for managementor, only free chunks need to be in the free-list
72
1
size
header
Next chunk in free list
payload
size
Prev chunk in free list
footer
Status
1
size
header payload
size
footer
Status
1
size
header
Next chunk in free list
payload
size
Prev chunk in free list
footer
Status
This trick is NOT part of assignment 6!
![Page 73: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/73.jpg)
Another use for the extra size field: error checking
73
1
size
header payload
size
footer
Status
char *s = (char *)malloc(32);
. . .
strcpy(s, "The rain in Spain is mainly in the plain.");
. . .
printf("%s\n", s);
free(s);
The rain in Spain is mainly in the plain
![Page 74: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/74.jpg)
doubly linked List Impl Performance
Observation:• All sub-algorithms of free() are fast
• free() is fast!
74
![Page 75: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/75.jpg)
doubly linked List Impl Performance
Space• 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
75
![Page 76: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/76.jpg)
doubly linked List Impl Performancewith use-payload-space-for-management
Space• 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
76
![Page 77: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/77.jpg)
What’s Wrong?
Problem• malloc() must traverse doubly linked list, so can be slow
Solution• Use multiple doubly linked lists (bins)…
77
![Page 78: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/78.jpg)
Agenda
The 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 78
![Page 79: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/79.jpg)
Data structures
Bins Impl
79
Use an array; each element is a bin
Each bin is a doubly linked list of free chunks
As in previous implementation
bin[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 80: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/80.jpg)
Bins Impl
Algorithms (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, insert80
![Page 81: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/81.jpg)
Bins Impl Performance
Space• 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: very good: O(1)
Time: free()
• Very good: O(1)81
![Page 82: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/82.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
List
Good Malloc: Bad (but could be OK)
Free: Good
(5) Bins Good Malloc: Good
Free: Good
82
Assignment 6: Given (3), compose (4) and (5)
![Page 83: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/83.jpg)
Agenda
The 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 83
![Page 84: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/84.jpg)
Unix VM Mapping Functions
Unix allows application programs to map/unmap VM
explicitly
void *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
84
![Page 85: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/85.jpg)
85
Unix VM Mapping Functions
Typical call of mmap() for allocating memoryp = 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 86: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/86.jpg)
Agenda
The 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 86
![Page 87: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/87.jpg)
VM Mapping Impl
Data structures
87
size
header
chunk
payload
Each chunk consists of a header and payload
Each header contains size
![Page 88: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/88.jpg)
VM Mapping Impl
Algorithms
88
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 89: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/89.jpg)
VM Mapping Impl Performance
Space• 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: bad
• For large chunks
• free() unmaps (large) chunks of memory, and so shrinks page
table
• Overall: good
89
![Page 90: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/90.jpg)
The GNU Implementation
Observation• 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())
90
![Page 91: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/91.jpg)
Segregated metadata
91
2
4
6
Data layout: no “size” field, no header at all!
Malloc: look up in bins array, use first element of linked list
Free: find size (somehow), put back at head of that bin’s list
contiguous
![Page 92: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/92.jpg)
How free() finds the size
92
↓006FA8B0000 ↓006FA8BFFFF
↓00381940000 ↓0038194FFFF
Hash table:006FA8B → 2
0038194 → 4
0058217 → 6
etc.
006FA8B0080
“page” number offset in page
![Page 93: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/93.jpg)
Segregated metadata performance
Space• No overhead for header: very very good, O(1)
• No coalescing, fragmentation may occur, possibly bad
Time• malloc: very very good, O(1)
• free: hash-table lookup, good, O(1)
93
![Page 94: Dynamic Memory Management · PDF file · 2017-11-22• Time efficiency • Allocating and freeing memory should be fast ... Run-time system frees unneeded memory ... At process start-up,](https://reader036.vdocument.in/reader036/viewer/2022062504/5aad1e147f8b9a693f8dec95/html5/thumbnails/94.jpg)
Summary
The need for dynamic memory management• 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/refinements
94