Embedded Systems Design - June 2008 - (Page 32)

feature Listing 1 Static memory allocation in C. // // static memory allocation void alloc_static() { static int array[10]; // static allocation int n; // // populate "array" for (n=0;n<10;n++) { array[n]=n+1; printf("%d:%d\n",n,array[n]); } Listing 2 Stack allocation in C. // // stack allocation void alloc_stack() { int array[10]; // stack allocation int n; // // populate "array" for (n=0;n<10;n++) { array[n]=n+1; printf("%d:%d\n",n,array[n]); } } In stack allocation, the processor allocates a ﬁxed amount of memory when a function is invoked. The memory for the currently executing function is maintained on a stack, and when the function exits, the memory on the stack is released. This method uses memory more efﬁciently than static allocation, because memory is allocated and released as needed by each function. However, the stack is limited to a ﬁnite area of memory. It can be difﬁcult to predict how large the overall stack needs to be, and stack overﬂow can be difﬁcult to detect. Like static allocation, the size of variables on the stack must be speciﬁed at compile time. Listing 2 illustrates stack allocation for variable “array.” Finally, in dynamic allocation, you manually allocate memory at run time. The memory is drawn from the heap, using C’s malloc and free commands. Because you have complete control over memory usage, dynamic allocation allows more efﬁcient use of memory than either static or stack allocation. Listing 3 shows an example of dynamic allocation. The ﬂexibility of dynamic memory allocation, however, comes at a price: • Listing 3 Heap allocation in C. // // heap allocation void alloc_heap() { int* array; int n; if (needMemory) // allocate memory only if needed { // // allocate array on heap array = (int *)malloc(10*sizeof(int)); free(array); } } // free memory • • • Manual memory management is error prone, and heap-related software problems, such as memory leaks, are particularly difﬁcult to debug. Searching the heap for an appropriate size block takes an indeterminate amount of time, which is unacceptable for “hard” real-time systems. Repeatedly allocating and freeing memory blocks of different sizes eventually leads to fragmentation. Custom memory allocators, such as memory pool managers, avoid these problems, but introduce more complexity and possible defects into the system. memory is allocated than is actually in use. In addition, the amount of memory is ﬁxed and must be speciﬁed at 32 compile time. For example in Listing 1, the memory for variable “array” is allocated statically. Given these issues, embedded software developers traditionally frown upon dynamic memory allocation, especially in software for mission-critical systems and avionics. Many embedded JUNE 2008 | embedded systems design | www.embedded.com http://www.embedded.com

Table of Contents Feed for the Digital Edition of Embedded Systems Design - June 2008

Embedded Systems Design - June 2008 Contents #Include Party Bit Programmer's Toolbox Cover Feature: Virtual Hardware Platforms for Embedded Software Validation Allocating Memory in MATLAB-to-C Code MDD and IDEs: Making the Twain Meet in Embedded Systems Design Avoid a Thrashing Guest Editor Advertising Index Break Points Marketplace

Embedded Systems Design - June 2008

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.