ESL DESIGN
Allocate memory efficiently in
Matlab-to-C code
By Robert Yu
Applications Engineer
Agility Design Solutions Inc.
E-mail: robert.yu@agilityds.com
When developing algorithms for
communication, signal process-
ing and controls, Matlab is the
de facto standard development
environment. Matlab’s syntax and
toolbox functions facilitate algo-
rithm exploration and refinement.
At some point, however, a
Matlab algorithm must be ported
to another implementation,
typically C. Embedded systems, in
which many algorithms eventu-
ally end up as software, can im-
pose additional requirements on
memory usage. This article looks
at how data storage in Matlab
translates to memory allocation in
C for embedded systems.
Methods
Translating Matlab code to C is not
a straightforward process. Several
articles have tackled translation
techniques, and tools now exist
for automatic Matlab-to-C trans-
lation. In embedded software,
one of the biggest concerns is
memory usage.
In C, the developer has the
choice of allocating memory in
static memory, on the stack or
dynamically (on the heap). Each
allocation method has its advan-
tages and disadvantages.
Static allocation, in which
the compiler sets aside a fixed
amount for each variable, is the
simplest method and works
even on processors without stack
support. However, this method
inefficiently allocates all storage
memory for the lifetime of the
program, so more memory is al-
located than is actually in use. In
addition, the amount of memory
is fixed and must be specified at
compile time. In Listing 1, the
memory for variable “array” is al-
located statically.
In stack allocation, the pro-
cessor allocates a fixed 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
efficiently than static allocation,
because memory is allocated Listing 1: The memory for variable “array” is allocated statically.
and released as needed by each
function. However, the stack is
limited to a finite area of memory.
It can be difficult to predict how
large the overall stack needs to
be, and stack overflow can be
difficult to detect. Like static
allocation, the size of variables
on the stack must be specified
at compile time. Listing 2 illus-
trates stack allocation for vari-
able “array.”
In dynamic allocation, you Listing 2: Shown is a stack allocation for variable “array.”
manually allocate memory at
runtime. The memory is drawn
from the heap, using C’s malloc
and free commands. Because
you have complete control over
memory usage, dynamic alloca-
tion allows more efficient use
of memory than either static
or stack allocation. Listing 3
shows an example of dynamic
allocation.
Be wary of its trade-offs
The flexibility of dynamic memory
allocation, however, comes at a
price: Listing 3: Shown is an example of dynamic allocation.
• Manual memory manage-
ment is error-prone, and heap- • Custom memory allocators— projects forbid the use of dynamic
related software problems (i.e. such as memory pool manag- memory allocation entirely.
memory leaks) are particularly ers—avoid these problems, In Matlab, you don’t need to
difficult to debug. but introduce more complex- think about memory allocation.
• Searching the heap for an ap- ity and possible defects into The Matlab interpreter handles
propriate-sized block takes an the system. details of array memory and
indeterminate amount of time, data types, leaving the algorithm
which is unacceptable for Given these issues, embedded developer free to concentrate
“hard” real-time systems. software developers traditionally on the algorithm itself. In fact,
• Repeatedly allocating and frown upon dynamic memory al- typical Matlab users don’t even
freeing memory blocks of dif- location, especially in software for worry about array sizes as Matlab
ferent sizes eventually leads to mission-critical systems and avi- will automatically resize arrays as
fragmentation. onics. Many embedded software required. For this article, however,
EE Times-Asia | October 1-15, 2008 | eetasia.com 
 Listing 7: One can allocate LUT in static memory.

Listing 4: In Matlab, you don’t need to think about memory allocation. Fixed-
and variable-size arrays in Matlab are shown.

Listing 5: Shown is a Matlab function that maps one integer to another via a
simple LUT.

Listing 8: This example initializes x with 10 random numbers between 0 and

1.0, then returns the indices of elements in x that are greater.

Listing 6: Shown is a Matlab function with LUT allocated on the stack.

we’ll identify two types of Matlab
arrays: fixed-size and variable-size.
Fixed-size arrays are Matlab arrays
for which the dimensions remain
fixed during runtime. Variable-size
arrays change in size or shape
during runtime. Some Matlab ex-
amples are shown in Listing 4.
Variable-size arrays are an ex-
tremely useful feature of Matlab.
Most non-trivial Matlab programs
make use of them; sometimes
you simply don’t know how
large an array (such as an image
or resampled buffer) will be until
runtime. Although the Matlab
language doesn’t explicitly distin-
guish between fixed-size and vari-
able-size arrays, you’ll see that this
distinction becomes critical when
translating to C.
Fixed-size arrays
When translating Matlab code to
C, you must choose how to allo-
cate memory for your data. If the
Matlab code uses a fixed-size array,
the translation is a simple matter
of allocating an equivalent array in
C. Because the array size is known
at compile time, you can allocate
the array statically or on the stack,
and there’s no need to resort to
dynamic allocation. For example,
the Matlab function in Listing 5
maps one integer to another via a
simple look-up table (LUT), which
is a vector of fixed size.
The equivalent C code, with
LUT allocated on the stack, is
shown in Listing 6. Similarly, you
can allocate LUT in static memory,
as shown in Listing 7.
A tool we developed for
Matlab-to-C translation takes the
same approach to fixed-size ar-
rays. When the size of a Matlab
array is known ahead of time, it
simply allocates the equivalent
array in C. By default, the transla-
Listing 9: Shown is the C translation of findrand with fixed-size arrays.
tion tool uses the size of the array
to determine whether to allocate
the array on the stack, statically or
dynamically. However, you have
complete control over this behav-
ior and, for example, can direct
the translator to avoid all dynamic
memory allocation.
Variable-size arrays
If your Matlab code uses variable-
size arrays, how do you translate
them to C? The natural solution
is to allocate an equivalent array
dynamically. But in an environment
that prohibits dynamic memory al-
location, you have several solutions
for handling the variable-size array:
• Rewrite the algorithm to elimi-
nate all variable-size arrays—
You can emulate variable-size
arrays by pre-allocating a maxi-
mum, fixed-size array, then use
extra “bookkeeping” variables
and logic to track the actual
array size during runtime. This
method can be done in C or
even Matlab, although this
goes against the grain of nor-
mal Matlab coding style.
• Use a custom memory alloca-
tor in C such as a pool manag-

 eetasia.com | October 1-15, 2008 | EE Times-Asia

 er to allow dynamic memory
allocation without the associ-
ated problems—This solution
sidesteps the problems with
malloc and free, but introduces
extra complexity.
As an example of variable-
size arrays in Matlab, consider
the Matlab find function: Given
a vector x, the Matlab statement
“ind=find(x)” returns a vector ind
of indices corresponding to non-
zero entries of x. The exact length
of ind cannot be determined until
runtime. Find is a commonly used
function in Matlab, but the vari-
able length of the output makes
translation to C problematic, es-
pecially when dynamic memory
allocation is prohibited.
The example in Listing 8 ini-
tializes x with 10 random numbers
between 0 and 1.0, then returns
the indices of elements in x that
are greater than 0.5. The length of
ind isn’t known until after the ran-
dom numbers are generated.
To avoid dynamic memory
allocation, you can recognize
that the length of ind will never
exceed the length of x (=10). This
gives you the maximum possible
size for ind, which you allocate on
the stack. You can also introduce
a separate variable, ind_dim1, to
track the actual size of ind. The
resulting C translation of findrand
is shown in Listing 9.
The Matlab language frees
you from having to think about
memory allocation and actively
EE Times-Asia | October 1-15, 2008 | eetasia.com
encourages the use of variable-
size arrays. On the other hand,
many algorithms developed in
Matlab are eventually ported
to C on an embedded system,
where memory, time and hard-
ware constraints limit how the
C implementation allocates
memory. In some cases, embed-
ded projects prohibit the use of
dynamic memory allocation en-
tirely. It’s no wonder that trans-
lating from Matlab to embedded
C is a complicated task.