LOÏC CAPPANERA. 1. Memory management The variables involved in a C program can be stored either statically or dynamically.

Transcription

1 C PROGRAMMING LANGUAGE. MEMORY MANAGEMENT. APPLICATION TO ARRAYS. CAAM 519, CHAPTER 7 This chapter aims to describe how a programmer manages the allocation of memory associated to the various variables used by a C program. This chapter also presents how to allocate dynamic memory when working with (multidimensional) arrays. 1. Memory management The variables involved in a C program can be stored either statically or dynamically Static memory. Variables and functions can be saved with static memory so that their lifespan is the same as the lifetime of the program. The memory size required to store a static variable or function is determined and allocated when the program starts. It can not be changed later in the execution of the program. Static memory allocation is mainly used when a programmer wants to work with the same variable on multiple functions or source files. Global variables, variables defined outside functions, are automatically stored as static variable. Developers can also tell the program to store a variable or a function with static memory by using the attribute static or extern during its declaration. We remind that a variable defined with the static attribute in a function keeps its value between the invocations of the function. When a global variable or a function is declared as static, it restricts its scope to the source file it is declared in Dynamic memory. Variable can also be saved dynamically meaning their lifespan is smaller than the lifetime of the executable. Such memory allocation is either done automatically or manually Automatic memory allocation on the Stack. When declaring a local variable without the attribute static or extern, the variable is automatically stored with dynamic memory on a memory region of the RAM called Stack. The memory used to store the variable is free as soon as the function where it is defined ends. Memory allocated in the Stack is done in a LIFO (Last In First Out) order. Although access to variables stored in the Stack is very fast, this memory region does not allow to store large data as its size is around 10 Mo. Moreover, the programmer can not manage memory allocated in the Stack. It means that a pointers or an array defined in a function and stored on the Stack can not be used outside the function. To face these issues, the C language allows the programmer to do dynamical memory allocation manually on a region called the Heap. This feature is described in the following section Dynamical memory allocation on the Heap. Programmers can manage manually the dynamical memory allocation of variables. The memory is then allocated on a region of the RAM called Heap. Unlike the Stack, the memory size used by the HEAP is only limited by the size of virtual memory (RAM). In addition, the size of a memory s block associated to a variable (pointer) can be 1

2 2 reallocated if a larger or smaller size is needed. However, access to data is a little slower as variable can be stored anywhere in the virtual memory of the computer. In C, doing a dynamical memory allocation of a variable manually is referred as dynamical memory allocation. This feature can be used in many situations such as (non exhaustive list): Memory to allocate is too large to be stored on the Stack. Return pointer with functions. Need to change the size of the block of memory associated to a pointer. The following section shows how to manage dynamical memory allocation of variables on the Heap Manage manual dynamic allocation on the heap. This feature of C mainly involves four functions respectively named malloc, calloc, realloc and free. These functions are part of the library stdlib.h. The first two functions, malloc and calloc, allow to allocate the required memory associated to a pointer on the Heap. It is then possible to reallocate (change the size) an allocated pointer with realloc and to deallocate the memory associated to a pointer with the function free malloc. Allocate a block of memory and return a pointer that contains the memory address of the first element allocated. The general structure of a call of malloc is the following: type_ pointer * pointer_ name ; pointer_ name = ( type_ pointer *) malloc ( nb_ bytes ); where pointer name is the name of the pointer, type pointer is the type of elements pointed to by the pointer and nb bytes is the number of bytes that are allocated. This number of bytes should be equal to the number of elements stored times the size in bytes of an element. The initial data contains by the pointer can be anything as malloc does not initialize the bytes allocated calloc. Allocate a block of memory and return a pointer that contains the memory address of the first element allocated. Unlike malloc, the function calloc initializes the allocated memory to zero (in terms of bytes). The arguments of this function are the number of elements to allocate and the number of bytes used to store one element. It is called as follows. type_ pointer * ptr ; ptr = ( type_ pointer *) calloc ( nb_ele, bytes_ per_ ele ); The number bytes per ele should be the number of bytes of type pointer. It can be evaluated with sizeof(type pointer) realloc. Resize the length of a block of memory pointed to by a pointer previously allocated with the functions malloc or calloc. The function takes a pointer and a number of bytes as argument. Its structure is the following. type_ pointer * ptr ; ptr = ( type_ pointer *) malloc ( nb_ bytes ); ptr = ( type_ pointer *) realloc ( ptr, new_ nb_ bytes );

3 C PROGRAMMING LANGUAGE: MEMORY MANAGEMENT AND ARRAY free. Deallocate (free) a block of memory that was previously allocated by a call to malloc, calloc or realloc. You can use this function as follows: type_ pointer * ptr ; ptr = ( type_ pointer *) malloc ( nb_ bytes ); free ( ptr ); It is important to always deallocate pointers that are not used anymore in your code. Failing to do so may lead your program to generate memory leak or use too much memory. Remark: When using dynamical memory allocation, a programmer should be cautious with the following four issues. Uninitialized memory. It can happens when using a pointer allocated with the function malloc. Memory overwrite. C does not forbid to access data that are written in the following bytes associated to a pointer. For instance in the following example, we are going to overwritte on four bytes that could be used by other variables or programs. int * ptr ; ptr = ( int *) malloc (2* sizeof ( int )); ptr [3]=4; // overwrite Memory overread. This issue has similar consequence as uninitialized memory: the data read by the program are not relevant as they are not part of a block of memory the programmer allocated to a pointer. Here is an example of overread issue. int * ptr ; ptr = ( int *) malloc (2* sizeof ( int )); int a= ptr [3]; // overread Memory leak. This issue concerns block of memory, previously allocated to a pointer, that are made inaccessible before being free. For instance, it can happens when a programmer redefines the address of a pointer before freeing the memory associated to the pointer. Same problem can arise when declaring a pointer with dynamic memory allocation in a function without returning the pointer or freeing the pointer in the function. It is possible to fix the memory leak of a program using the software valgrind. We will describe later in the course how to use valgrind and a C debugger called gdb. We refer to the example provided on CAAM519 course webpage for more information on how to use the above functions. The next section focuses on allocating array with dynamical memory. 2. Array and dynamic memory allocation 2.1. Storage of array in a C program. We remind that a one dimensional array can be defined by using a square bracket during its declaration as follows: int tab [ 4]; // Array of 4 integers while a multidimensional array is declared with multiple square brackets to respect the following structure. int tab [4][3]; // Matrix 4x3 of integers

4 4 The memory allocated to declare array is automatically done on the Stack. Meaning that the array, and the pointers associated to the memory address of the first element of the array, only lives in the function where it is declared/defined. Regarding multidimensional array, it is important to note that C uses a row major indexation (versus column major for Fortran). Moreover, all the values of the array s element are stored in a continuous large block of memory. It means that the first blocks of memory used to store the array contains information on the value of the elements of the first row of the array. Then the following blocks of memory contains information on the elements of the array s second row, and so on. Here is an example of code that show various way of accessing the value of an element of a two dimensional array. int M [4][3]; int i,j,k; for (i =0; i <4; i ++){ for (j =0; j <3; j ++){ k = 3*i+j; // Arrray notation M[i][j]=k; // Equivalent notation with pointers *(M[i]+j)=k; *(M [0]+ k )=4; M [0][ k]=k; (*M)[k]=k; *((* M)+k)=k; Note that it is also possible to define a multidimensional array as a one dimensional array of length equal to the product of the dimensions of the array. It terms of memory storage, the memory allocated to the array presents the same structure. However the access to the array s elements will differ Dynamical memory allocation of array. The previous declaration of arrays does not allow the programmer to manage the memory associated to this array. To face this, we can use dynamical memory allocation of pointers with the functions malloc and calloc. The allocated pointers can be used to represent arrays. In addition to be able to manage the pointer s lifetime, such declaration also allows to reallocate the size of the memory block associated to the pointer. The following sections show how a developer can use the functions malloc and calloc to declare pointer associated to a one and multidimensional array One dimensional array. Use of malloc to create a pointer of an array of a various length. int * M; int length =4; // Create pointer to an array of four integers M = ( int *) malloc ( length * sizeof ( int )); Similar declaration can be done with the function calloc.

5 C PROGRAMMING LANGUAGE: MEMORY MANAGEMENT AND ARRAY Multidimensional array. There is multiple ways of declaring multidimensional array with pointer that are allocated with a dynamic memory on the heap. In this section we focus on working with 2D arrays that have the following dimensions: int rows = 3; int columns = 4; The allocation of an array of dimension (rows, columns) can be done with the following methods. Use one pointer. The memory allocated has to be equal to the size of the array, i.e. the number of rows times the number of columns time the size in bytes of each element of the array. It can be done as follows. int *pt = ( int *) malloc ( rows * columns * sizeof ( int )); To access the element of the array, one needs to navigate with the address contains in the pointer as shown here: for ( int j =0; j< columns ; j ++){ // Set the value of the element ( i, j) *( pt + i* columns + j) = 1; // pt[i* columns + j] = 1; The memory can be free with the command free (pt ); Use a pointer to a pointer. The structure of such allocation is the following: int ** pt = ( int **) malloc ( rows * sizeof ( int *)); pt[i] = ( int *) malloc ( columns * sizeof ( int )); The first line allocates a pointer that contains address of other pointers that represent the rows of the array. In the loop for, a block of memory that fits the size of a column is allocated and its address is given to pt[i]. The element of the array can they be accessed as follows: for ( int j =0; j< columns ; j ++){ // Set the value of the element ( i, j) pt[i][j] = 1; // *(*( pt+i)+j) = 1; Note that to free the allocated memory, the following command has to be performed:

6 6 free (pt[i ]); // Free a block of a column size. free ( pt ); // Free the memory of the pointer to pointer. Use a pointer to a pointer with contiguous memory. int ** pt = ( int **) malloc ( rows * sizeof ( int *)); // Allocate a memory block that can contains the 2 D array pt [0] = ( int *) malloc ( rows * columns * sizeof ( int )); for ( int i =1; i< rows ; i ++){ // Set correct memory address for each rows pt[i] = pt [0] + columns *i; The element can be accessed the same way than the previous method. The advantage of this method is that the memory blocks that contains the information on the array s element are contiguous. The memory can be free as follows: free (pt [0]); free (pt ); In general, we will prefer the last method as it is the more efficient. Moreover, it allows to access the elements of the matrix in a standard way (i.e. using [i][j]). Note that each call of malloc or calloc requires a call to free to deallocate the memory blocks that were requested. Remark on 3D matrix. One can use dynamic memory on the heap to allocate 3D (or larger) matrix using the previous methods. Here is an example that consider the allocation of a 3D matrix of dimensions (dim1, dim2, dim3) using pointer of pointer with contiguous memory. int *** pt = ( int ***) malloc ( dim1 * sizeof ( int **)); pt [0] = ( int **) malloc ( dim1 * dim2 * sizeof ( int *)); // Allocate a memory block that can contains the 3 D array pt [0][0] = ( int * ) malloc ( dim1 * dim2 * dim3 * sizeof ( int )); // Set correct memory address for each rows ( first dimension ). for ( int i =0; i< dim1 ; i ++){ pt[i] = pt [0] + dim2 *i; // Set correct memory address for 2 nd dimension for ( int j =0; j< dim2 ;j ++){ pt[i][j]= pt [0][0] + dim2 * dim3 *i + dim3 *j; We refer to the class for more details on this example Function returning array. Declaring an array or a pointer in a function does not allow to use it as output when it is automatically allocated on the stack. Indeed the memory allocated on the stack by a function is free as soon as the function ends. To face this issue, it is possible to write functions that return arrays or pointer if one declares the arrays/pointers with the functions malloc

7 C PROGRAMMING LANGUAGE: MEMORY MANAGEMENT AND ARRAY. 7 or calloc. The memory allocated to the array is then stored on the heap and is only free when the programmer decides so by using the function free. int * create_ int_ array ( int lenght_ array ){ int * pt; pt = ( int *) calloc ( lenght_ array, sizeof ( int )); return pt; Remark: It is important to free such pointers if they are not used as output of the function. Indeed when allocating pointer with the function malloc or calloc in a function, it will be impossible to free the allocated memory if the pointers is not returned or free in the function. Failing to do so will result in a program with memory leak Function with multidimensional array as argument. To use a multidimensional array as a function argument, the programmer has to specified the dimensions of the array in the function s declaration (or at least all of the dimensions but the first one). Here is an example of a prototype of such a function: void function ( int tab [][3][4]); In addition, we note that it is not possible to determine the length/dimensions of the input array using only the array. Indeed an array is passed as a pointer that contains the address of the first byte where elements of the array are stored. The pointer does not contain any information about the length (or dimensions) of the array. As a consequence, the dimensions of an array should also be passed as argument to avoid overreading or overwriting issues. The above prototype would become: void function ( int tab [][3][4], int, int, int ); We remind that it is possible to determine the dimensions of an array in the function where it is declared using the function sizeof. For instance here is how to compute the first and second dimension of an array. int array [4][2][3]; int first_dim = sizeof ( tab )/ sizeof ( tab [0]); int second_dim = sizeof ( tab [0])/ sizeof ( tab [0][0]); The above code can not be used in a function with tab as argument because tab is now a pointer for the function sizeof. The results of the above lines will then vary between different machine/operating system. We refer to the example ex 14 func array pointer.c available on CAAM 519 s webpage, for more information Inconvenient and outlook. To construct matrix and access the elements of the matrix as introduced in this chapter, the programmer always needs to work with the memory address of the elements. It is not always very safe to do as a typo in a program can lead to various memory error (overread or overwrite). To limit such interactions, we can create structure that contains matrix, dimensions of matrix and function that work on the matrix (access to an element, scalar product, etc.). Such feature is introduced in the next chapter and presents one main advantage: once a matrix structure is properly set the programmer may avoid working with memory address or equivalent elsewhere in the program.