Scribd
Upload
91 views

COMP 3355 Notes - Dynamic Memory Allocation

This document summarizes dynamic memory allocation. It discusses how programs can allocate and free memory from the heap at runtime rather than having fixed memory assignments. It describes different heap management strategies, like fixed and variable size block allocation, and issues like fragmentation. Common errors in dynamic allocation are also outlined. The storage classes in C/C++ that determine where a variable is allocated are described, including the static, heap dynamic, stack dynamic, and register classes.

Uploaded by

Michael Walker
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
91 views

COMP 3355 Notes - Dynamic Memory Allocation

This document summarizes dynamic memory allocation. It discusses how programs can allocate and free memory from the heap at runtime rather than having fixed memory assignments. It describes different heap management strategies, like fixed and variable size block allocation, and issues like fragmentation. Common errors in dynamic allocation are also outlined. The storage classes in C/C++ that determine where a variable is allocated are described, including the static, heap dynamic, stack dynamic, and register classes.

Uploaded by

Michael Walker
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

COMP 3355 Notes – Dynamic Memory Allocation

Reading: section 11.5

Plan

 Overview
 Run-Time Environments
 Heap Management
 Storage Classes

Overview

Recall:
 Static allocation of memory is when memory reservation requirements are
determined at compile- (or assemble-) time.
 Dynamic allocation of memory is when memory is acquired and released
throughout run-time, based on current need.

E.g. a statically allocated, singly linked list in asm:


data equ 0 ; node type for a list of words
next equ 2
NODE_SIZE equ 6

NULL equ 0 ; why zero for the NULL pointer?

head: dc.l node1

node1: dc.w 1
dc.l node2

... ; must the nodes be contiguous?

node2: dc.w 2 ; must the declaration order be fixed?


dc.l NULL

In order for data structures to grow (and shrink) at run-time, dynamic allocation of
memory must be possible.

Page 1 of 6
Run-Time Environments

A high-level language provides a run-time environment. It provides:


 initial program set up (i.e. before calling a “main” function)
 final program tear down (i.e. after “main” returns)
 a set of callable library functions

The run-time environment is responsible for maintaining a pool of available memory:


the heap, plus routines for allocating and deallocating blocks of memory.

E.g. C provides the standard library functions:


 void *malloc(size_t); allocates a block from the heap
 void free(void *) returns a block to the heap

E.g. C++ provides the operators:


 new calls malloc
 delete calls free

Asm programs have no default high-level run-time environment! They must create and
manage their own heaps (or link to an existing run-time environment such as libc).

Heap Management

Heap space must be set aside at the beginning of the program.

E.g.

heap: ds.b HEAP_SIZE

or, if only one type of node will ever be allocated:

heap: ds.b NUM_NODES*NODE_SIZE

Page 2 of 6
There are numerous heap management strategies. We consider only a few, briefly:

1. FIXED SIZE BLOCKS

a) one-time allocation:

allocation = if heap empty


then
set address = NULL
otherwise
set address = “next available”
increment “next available” pointer by block size

return address

deallocation = n/a

Discuss: pros & cons

b) reusable nodes:

maintain a free list of blocks: each free block points at next free block in heap

Diagram: draw initial free list (all free blocks are initially contiguous)

allocation = set address = free list head pointer


if address ≠ NULL then remove head block from free list
return address

deallocation = insert block back into free list at head

Exercise: given the node type from above and:

freep: dc.l heap


heap: ds.b NUM_NODES*NODE_SIZE

in asm, write:

void *malloc();
void free(void *);
void init_heap();

Page 3 of 6
2. VARIABLE SIZE BLOCKS

a) use method (1b) above, but with segregated free lists (“bins”) for each block
size

b) block subdivision (overview):

 Begin with one huge block in the free list.


 During allocation, subdivide when necessary.
 Can use a first fit strategy: use 1st block which has size ≥ requested.
 Can use a best fit strategy: search for smallest block which can satisfy the
request.
 If no “big enough” block is found, allocation request fails (or can request
another large block of memory from the O/S, and add it to free list).
 For deallocation, re-insert into free list
 During deallocation, coalesce with free neighbours when possible.

Diagram: picture of one free list node (w/ pointer, size & memory)

Diagram: picture of entire free list (w/ some blocks in use, others free)

Problem: fragmentation is the gradual loss of useful space. There are 2 kinds:

1. internal fragmentation: space is lost within an allocated block (because of


minimum block sizes)

2. external fragmentation: space is lost between allocated blocks

Diagram: an externally fragmented heap

Excessive fragmentation may result in a failed allocation request, even if enough total
memory is available!

Some solutions:
 implement compaction: a periodic defragmentation of the heap
 maintain multiple heaps, each for a different block size (e.g. glibc under
Linux)

Page 4 of 6
Common dynamic allocation errors:
 not checking “out of memory” condition
 memory leaks
 using memory once freed
 freeing memory twice
 overflowing an allocated block

Typically, when allocating memory dynamically, the request for more space is
ultimately made to the O/S.

Memory map for a Linux process:

HIGH MEMORY ?

stack
 stack top

(unallocated space)

 heap “break point”


heap

code & static data

LOW MEMORY ?

Requesting memory from the O/S is “expensive”.

Heap managers make large, infrequent requests from the O/S and then subdivide the
obtained block.

E.g. in Unix/Linux, C’s malloc library function makes infrequent calls to the brk
system call, which raises the “break point”.

Page 5 of 6
Storage Classes

The storage class of a variable refers to the region from where it is allocated. This also
relates to when it is allocated and deallocated (“lifetime”).

In C/C++ -like languages, the 4 typical storage classes are:


1. static
2. dynamic (“heap dynamic”)  run-time allocation from heap
3. automatic (“stack dynamic”)  run-time allocation on stack
4. register

This is distinct from variable “scope”, which refers to identifier visibility (e.g. global vs.
local variables).

Page 6 of 6

You might also like