Recap: Did you Read on

 Using C programming
 Creating a new process using fork()
system call
 CREATING multiple processes using fork
() and pipe()
 Demonstrate the concept of Orphan
Process.
 Using execv and execvp system calls

What did you find out?

ICS 2305 : SYSTEMS PROGRAMMING

MEMORY MANAGEMENT

Karanja Mwangi
Lesson objective

 At the end of this class you will

 Appreciate the concepts of Memory Management as used in
Operating systems
 Differentiate the roles of global, stack and heap memory in C
 Describe and implement dynamic and static Memory
allocation
 Explore the concept of releasing memory
Memory Management

 In previous studies of Operating systems , You learnt that

Memory management is the process of controlling and
coordinating the way a software application
access computer memory specifically the Random
Access Memory.
Hard disk drives have huge space and seemingly can be
added “infinitely”, but RAM is not infinite. If a program
keeps on consuming memory without freeing it, ultimately it
will run out of memory and crash itself or even worse crash
the operating system
Memory Management -2

 When a program runs on a target Operating system say

Linux it needs access to the computers RAM(Random-
access memory) to:
 load its own bytecode that needs to be executed
 store the data values and data structures used by the
program that is executed
 load any run-time systems that are required for the
program to execute
Variable Types and Memory Allocation-2

 We have different types of variables : Global or local

 The global variables ~ used throughout the program by
different functions and blocks.
 Hence memory area allocated to them needs to exist
throughout the program.
 Hence they get memory allocated at the internal memories of
the system, which are known as permanent storage area
or the Global Memory.
 Similarly the program and their statements also need to exist
throughout when system is on. Hence they also need to
occupy permanent storage area
Variable Types and Memory Allocation-3

 Local variables ~ exists in the particular block or

function where they are declared.
 If we store them in permanent storage area, it will be
waste of memory as we keep the memory allocate which
are not in use. Hence we use stack memory to store the
local variables and remove them from the stack as the use
of local variable is over.
 There is a free memory space between this stack memory
and permanent storage area called heap memory.
 This memory is flexible memory area and keeps changing
the size. Hence they are suitable for allocating the memory
during the execution of the program. That means
dynamic memory allocations use these heap memories.
Variable Types and Memory Allocation-4

 In Summary , C program stores all its memory data in

three different areas.
 Global Memory or permanent storage – stores data that
are present from the very beginning of a program until the
end of the execution.
 The stack -It is an area in which the variables appear and
disappear at a certain point during the execution of a
program. It is used mainly to store the variables local to a
function.
 The Heap. This area contains memory available to be
reserved and freed at any point during the execution of a
program. It is not reserved for local variable functions
as in the stack, but for memory known as “dynamic” for
data structures that are not known to be needed or even their
size until the program is being executed
Variable Types and Memory Allocation-5

 Note that only the global memory has a fixed size that is
known when the program starts execution. Both the stack
and the heap store data the size of which cannot be know
until the program is executing
Variable Types and Memory Allocation-6

 Trivial (Global, Stack or Heap)

 static variable is stored in ……….

 A parameter that is passed to a function is stored in……..
 A local variable is stored in …………..
Variable Types and Memory Allocation-7

 Trivial (Global, Stack or Heap)

 static variable is stored in ………. Global memory

 A parameter that is passed to a function is stored
in……..Stack Memory
 A local variable is stored in ………….. Stack Memory
Variable Types and Memory Allocation

 In C programming, variable type and the amount of

memory allocated are strongly linked
 int : integer number : 4-bytes
 short : integer number : 2-bytes
 long : integer number : 8-bytes
 char : character : 1-byte
 float : floating point number : 4-bytes
 double : floating point number : 8-bytes
 void * : pointers : 8-bytes on (64 bit machines)
Memory Allocation in C
Local Memory Allocation: Static Memory
Allocation-1

 The stack is used for static memory allocation

 last in first out(LIFO) stack…
• push : push an item on to the top of the stack
• pop : pop an item off the top of the stack
 Why the stack?
 stack is very fast as there is no lookup required, you just
store and retrieve data from the topmost block on it.
 stack has to be finite and static(The size of the data is
known at compile-time).
 The stack frame contains all the allocated memory from
variable deliberations as well as a pointer to the execution
point of the calling function is structured as a stack
 Multi-threaded applications can have a stack per thread.
 Memory management of the stack is simple and
straightforward and is done by the OS.
 Static Memory Allocation -3

 In the program below to add two integers

#include <stdio.h>
int main() {
int number1, number2, sum;
printf("Enter two integers: ");
scanf("%d %d", &number1, &number2);
// calculating sum
sum = number1 + number2;
printf("%d + %d = %d", number1, number2, sum);
return 0;
}
 The declaration of the integer number1, number2, sum will
allocate memory for the storage for an integer (4-bytes) to
each of the variable. At compile time itself we know that
there are 3 integer variables. Hence it is easy for the compiler
to reserve the memory for these variables.
 Such reserved variables will have same size and memory
address till the end of the program. There will not be any
change in size, type and memory location for those variables.
Static Memory Allocation -2

 In summary for Static Memory allocation

 There is no need to explicitly allocate memory to the
variables.
 When a function is called, memory is allocated for all of its
parameters and local variables.
 Each active function call has memory on the stack (with the
current function call on top)
 When a function call terminates,
the memory is deallocated (“freed up”)
 These variables can be local or global variables. But we need
to know in advance the size and type of the variable
 variables cannot store more than predefined size of data
Dynamic Memory Allocation -Problem with
Arrays 1

 Suppose we need to add any number of numbers that are

entered by the user. Here we are not sure about how
many numbers are entered by the user. We only know
that it he is entering only integers.
 In this case we cannot pre-assign any memory to the
variables. He can enter only 2 numbers or 100s of
numbers. If user enters less numbers then the program
should be flexible enough to assign to those less number
of numbers and as the numbers increase memory
allocation space also should increase. But this can be
determined only at the run time – depends on the user
who enters the value. Thus we need to allocate space at
the run time which is done by using dynamic memory
allocation methods.
Dynamic Memory Allocation -Problem with
Arrays 2

 Example: Search for an element in an array of N

elements
 One solution: find the maximum possible value of
N and allocate an array of N elements
 Wasteful of memory space, as N may be much
smaller in some executions
 Example: maximum value of N may be 10,000,
but a particular run may need to search only
among 100 elements
 Using array of size 10,000 always wastes memory in most cases
Better Solution

 Dynamic memory allocation

 Know how much memory is needed after the
program is run
• Example: ask the user to enter from keyboard
 Dynamically allocate only the amount of
memory needed
 The C programming language provides
several functions for memory allocation
and management. These functions can be
found in the <stdlib.h> header file.
 malloc, calloc, realloc, free
Memory Allocation Functions
 malloc
 Allocates requested number of bytes and
returns a pointer to the first byte of the
allocated space
 calloc
 Allocates space for an array of elements,
initializes them to zero and then returns a
pointer to the memory.
 free
 Frees previously allocated space.
 realloc
 Modifies the size of previously allocated
space.
Malloc: Allocating a Block of Memory

 A block of memory can be allocated using

the function malloc
 Reserves a block of memory of specified size and returns a
pointer of type void
 The return pointer can be type-casted to any pointer type

 General format:
type *p;
p = (type *) malloc (byte_size);
Example

p = (int *) malloc(100 * sizeof(int));

 A memory space equivalent to 100 times the size of an
int bytes is reserved
 The address of the first byte of the allocated memory is
assigned to the pointer p of type int

400 bytes of space

 Contd.

 cptr = (char *) malloc (20);

Allocates 20 bytes of space for the pointer cptr of type char

 sptr = (struct stud *)

malloc(10*sizeof(struct stud));
Allocates space for a structure array of 10 elements. sptr points
to a structure element of type struct stud
Notes on Malloc
 malloc always allocates a block of
contiguous bytes
 The allocation can fail if sufficient contiguous memory
space is not available
 If it fails, malloc returns NULL

if ((p = (int *) malloc(100 * sizeof(int))) ==

NULL)
{
printf (“\n Memory cannot be
allocated”);
exit();
}
Notes on Using the malloc on Array

 Once the memory is allocated, it can be used with

pointers, or with array notation
 Example:
int *p, n, i;
scanf(“%d”, &n);
p = (int *) malloc (n * sizeof(int));
for (i=0; i<n; ++i)
scanf(“%d”, &p[i]);

The n integers allocated can be accessed as *p,

*(p+1), *(p+2),…, *(p+n-1) or just as p[0], p[1],
p[2], …,p[n-1]
 Example: The n integers allocated can be
accessed as *p, *(p+1), *(p+2),…, *(p+n-1)
or just as p[0], p[1], p[2], …,p[n-1]

int main() printf("Input heights for %d

{ students \n",N);
int i,N; for (i=0; i<N; i++)
float *height; scanf ("%f", &height[i]);
float sum=0,avg;
for(i=0;i<N;i++)
printf("Input no. of students\n"); sum += height[i];
scanf("%d", &N);
avg = sum / (float) N;
height = (float *)
malloc(N * sizeof(float)); printf("Average height = %f \n",
avg);
free (height);
return 0;
}
 Free: Releasing the
Allocated Space:
 An allocated block can be returned to the
system for future use by using the free
function
 General syntax:
free (ptr);
where ptr is a pointer to a memory block
which has been previously created using
malloc
 Note that no size needs to be mentioned
for the allocated block, the system
remembers it for each pointer returned
Can we allocate only arrays?

 malloc can be used to allocate memory for single variables

also
 p = (int *) malloc (sizeof(int));
 Allocates space for a single int, which can be accessed as *p
 Single variable allocations are just special case of array
allocations
 Array with only one element
Pointers to Pointers
 Pointers are also variables (storing
addresses), so they have a memory
location, so they also have an address
 Pointer to pointer – stores the address of
a pointer variable

int x = 10, *p, **q;

p = &x;
q = &p;
printf(“%d %d %d”, x, *p, *(*q));

will print 10 10 10 (since *q = p)

Allocating Pointer to Pointer

int **p;
p = (int **) malloc(3 * sizeof(int *));

p[0]
p int ** int *
p[1] int *
p[2] int *
Dynamic Allocation of 2-d
Arrays
 Recall that address of [i][j]-th element is found
by first finding the address of first element of i-
th row, then adding j to it
 Now think of a 2-d array of dimension [M][N] as
M 1-d arrays, each with N elements, such that
the starting address of the M arrays are
contiguous (so the starting address of k-th row
can be found by adding 1 to the starting address
of (k-1)-th row)
 This is done by allocating an array p of M
pointers, the pointer p[k] to store the starting
address of the k-th row
Contd.

 Now, allocate the M arrays, each of N elements, with p[k]

holding the pointer for the k-th row array
 Now p can be subscripted and used as a 2-d array
 Address of p[i][j] = *(p+i) + j (note that *(p+i) is a
pointer itself, and p is a pointer to a pointer)
 Dynamic Memory Allocation Summary

 Heap-allocated memory
 This is used for persistent data, that must survive beyond the
lifetime of a function call
• global variables
• dynamically allocated memory – C statements can create new
heap data
• Heap memory is allocated in a more complex way than stack
memory
 Like stack-allocated memory, the OS determines where to get
more memory – the programmer doesn‟t have to search for
free memory space!
Dynamic Memory Vs. Static Allocation

 Static memory assignment is at compilation time while

the dynamic can be assigned only at the run time.
 We can refer to memory allocated in the heap only
through a pointer.
 Using a pointer after its memory has been released is a
common programming error. Guard against it by clearing
the pointer. ( see examples
http://www.cs.ecu.edu/karl/3300/spr16/Notes/C/Memory/
dangling.html
 The pointer used to free memory must be of the same
type as the pointer used to allocate the memory.
Summary
 Tools for analyzing memory management

 Purify: runtime analysis for finding memory errors

 dynamic analysis tool:
collects information on memory
management while program runs
 contrast with static analysis tool
like lint, which analyzes source
code without compiling, executing it
 Further Reading and Reference

 Read about Functions and Pointers in C

 Parameter Passing in C : What do we mean when we say : call
by value and call by reference?
 S.C. Gupta and S. Sreenivasamurthy. “Navigating „C‟ in a
„leaky‟ boat? Try Purify”.
http://www.ibm.com/developerworks/rational/library/06/08
22_satish-giridhar/
 https://ocw.mit.edu/courses/electrical-engineering-and-
computer-science/6-s096-introduction-to-c-and-c-january-
iap-2013/lectures-and-assignments/c-memory-
management/
Exercises -1

Attempt the C programming Exercise

https://disalw3.epfl.ch/teaching/signals_instruments_systems/ay_20
09-10/exercises/hwk01/SIS_09-10_hwk01_assignment.pdf
 Exercises -2

 Exercise 1 : Call by reference vs call by value

#include <stdio.h>
void square(int num) {
num = num * num;
}
int main() {
int x = 4;
square(x);
printf("%d\n", x);
return 0;
}
What does this program Print?
 Exercises -2 – answer

 Exercise 1 : Call by reference vs call by value

#include <stdio.h>
void square(int num) {
num = num * num;
}
int main() {
int x = 4;
square(x);
printf("%d\n", x);
return 0;
}
This program prints 4 : why function variables are passed by
value, not reference