Matlab extensions for the development testing and verification of real time dsp software
This presentation is the property of its rightful owner.
1 / 28

Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software PowerPoint PPT Presentation

Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software. David P. Magee Communication Systems Engineer Texas Instruments Dallas, TX. Presentation Outline. DSP Software Development DSP Simulator Introduction to Intrinsics FFT Example

Related searches for Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software

Download Presentation

Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Matlab extensions for the development testing and verification of real time dsp software

Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software

David P. Magee

Communication Systems Engineer

Texas Instruments

Dallas, TX

Presentation outline

Presentation Outline

  • DSP Software Development

  • DSP Simulator

  • Introduction to Intrinsics

  • FFT Example

  • Algorithm Optimization Results

  • Other Matlab and Simulink Extensions

  • Closing Remarks

  • Q & A

Dsp software development

Develop Floating

Point Simulation



Step 1: Develop


Develop Fixed

Point Simulation



Step 2: Address

Scaling Issues


Assembly Code


Assembly Code

Step 3: Optimize

for Performance

DSP Software Development

  • Common steps for DSP software development

Issues with the 3 step approach

Issues with the 3 Step Approach

  • Each step takes time and resources

  • Algorithm testing at each stage

  • Multiple versions of the algorithm – version control headaches

  • Evaluation of processor instruction set compatibility and MIPS requirements often occurs late in the software development cycle

  • Debugging algorithms on a pipelined and/or parallel processor can be very difficult (the problem is getting more difficult as processors become more complicated)

    Can the development cycle be improved ?

Yes !

Improved software development cycle

Develop Floating

Point Simulation



Step 1: Develop



Develop Fixed

Point Simulation

and Assembly




Simulation and

Assembly Code

Step 2: Address

Scaling Issues and

Optimize for


Improved Software Development Cycle

  • Merge Steps 2 and 3

Question: How can these steps be combined ?

Matlab dsp simulator

Floating Point




Matlab Simulation


Fixed Point








Matlab + DSP Simulator

  • Develop Floating Point and Fixed Point Simulations in a single development environment - Matlab

  • Develop and test C/C++ code for Fixed Point Simulation in cooperation with the DSP Simulator

  • Migrate the C/C++ code directly to the target DSP

Dsp simulator in matlab

DSP Simulator

C/C++ code



DSP Simulator in Matlab

Develop and Debug Fixed Point

C/C++ Code in Matlab


  • Accelerate the development and analysis of DSP code

  • A mechanism to implement your IP blocks in efficient DSP code

  • Process large amounts of data

  • Compare fixed point and floating point algorithm implementations

  • Provide mixed simulation environment with fixed point and floating point algorithm implementations

  • Advanced graphing capabilities

What is a mex file

What is a MEX-file ?

  • A file containing one function that interfaces C/C++ code to the Matlab shell

  • MathWorks specifies the syntax for this function

    void mexFunction(int nlhs,mxArray *plhs[ ],

    int nrhs,const mxArray *prhs[ ])

  • See

    • Enter mex files into their Search engine

What is a dsp simulator

What is a DSP Simulator ?

  • A library of functions that simulate the mathematical operations of DSP assembly instructions.

  • For TI DSPs, the compiler recognizes special functions called Intrinsics and maps them directly into inline assembly instructions

  • In the DSP Simulator, make each function represent a supported compiler Intrinsic

Intrinsic example

C code

C6x Assembly Code

Function Example() {


y = _add2(a,b);





ADD2 . S1 A1,A2,A3



Intrinsic Example

  • ADD2: adds the upper and lower 16-bit portions of a 32 bit register

  • Intrinsic: dst = _add2(src1,src2)

  • Assembly Instruction: ADD2 (.unit) src1,src2,dst


Dsp simulator example

DSP Simulator

typedef struct _REG32X2


short lo;

short hi;

} reg32x2;

int32 _add2(int32 a,int32 b) {

int32 y;

reg32x2 *pa,*pb,*py;

pa = (reg32x2 *)&a; pb = (reg32x2 *)&b;

py = (reg32x2 *)&y;

py->lo = pa->lo+pb->lo;

py->hi = pa->hi+pb->hi;


} // end of _add2() function

C code

Function Example() {


y = _add2(a,b);



DSP Simulator Example

  • C Code with _add2() Intrinsic

Dsp simulator

DSP Simulator

  • How many Intrinsics exist for each DSP family ?

TMS320C54x: 36

TMS320C55x: 42

TMS320C62x: 59

TMS320C64x: 135

TMS320C64+: 162

TMS320C67x: 68

Most algorithms previously written in assembly code can now be expressed in C/C++ code with Intrinsic function calls

Dsp simulator1

DSP Simulator

  • Consists of two files

    • C6xSimulator.c

    • C6xSimulator.h

  • Contains C functions for representing the numerical operations of 158 DSP assembly instructions

  • Can control endianness with a symbolic constant

Dsp simulator and c

DSP Simulator and C++

  • DSP Simulator works in C++ programming environments

    • Partition data into appropriate types (real, complex) and bit widths (8/16/32 bits)

    • Write functions in C++

    • Use operator overloading for required data types to map operators to the desired Intrinsic functions

Benefit: Operator overloading allows for easy migration to next generation DSP instruction sets

Using the dsp simulator

Using the DSP Simulator

  • Develop C/C++ code with Intrinsic function calls

  • Compile and link the C/C++ code and the DSP Simulator to form a Matlab executable file

  • Debug and evaluate the performance of the fixed point algorithms in Matlab

  • Rely on TI tools to generate an optimized assembly version of the C/C++ code for the target DSP

Benefit: One version of C/C++ code runs in Matlab and in the target DSP !

Migrating c c code to the dsp

Migrating C/C++ Code to the DSP

  • How does it work ?

C/C++ code can directly access DSP assembly instructions without actually writing assembly code

Benefit: Eliminate headaches associated with assembly programming

  • Pipeline scheduling

  • Register allocation

  • Unit allocation

  • Stack manipulation

  • Parallel instruction debug

Conclusion: Make the compiler do the hard work !

When is the c c code optimized

When is the C/C++ Code Optimized ?

  • Look at compiler report in the assembly file to determine unit loading.

    • Look at the assembly code. Are all the units being used each cycle ?

    • Try to balance loading by using different sequence of Intrinsics to perform the same overall mathematical operation.

      • e.g. X * 4 => X << 2

    • May require manual unrolling of loops.

  • Determine the ideal number of MAC operations for an algorithm and compare it to the compiler report



  • DSP software engineer must perform algorithm mapping from floating point to fixed point manually

    • ranges for floating point values

    • fixed point scaling issues

    • saturation issues

  • DSP software architecture is limited to the creativity of the software engineer

Recommendation: Develop an automated tool that converts Matlab/Simulink floating point files to fixed point DSP C/C++ code using the programming guidelines discussed in the paper.

Fft example

FFT Example

Developed an FFT for the C64x DSP architecture

Briefly discuss

  • FFT Functions

  • FFT Simulation File

  • Development time between hand coded assembly and C code with Intrinsics

    • Software development time

    • Software performance

Fft functions

// inside the Radix-2 stage




// compute the real part

// (x0.real-x1.real)*w1.real

reg2 = _mpyhir(w1,reg1real);

// (x0.imag-x1.imag)*w1.imag

reg3 = _mpylir(w1,reg1imag);

reg2 -= reg3;

// compute the imag part

// (x0.imag-x1.imag)*w1.real

reg4 = _mpyhir(w1,reg1imag);

// (x0.real-x1.real)*w1.imag

reg5 = _mpylir(w1,reg1real);

reg4 += reg5;



FFT Functions

The FFT functions

  • Main FFT function

  • First FFT stage

  • Radix-2 stage

  • Radix-4 stage

  • Last FFT stage

    Example: Radix-2 stage

  • Uses mpyhir() and mpylir() Intrinsics

Note: Twiddle factor indexing not shown in this Example

Fft simulation file

% test_fft.m

% initialize some parameters

Nin = 64;

N = 128;

NumFFTs = 1000;

% create a random input

h = rand(NumFFTs,Nin);

h = [h;zeros(NumFFTs,N-Nin)];

% compute FFT using Matlab function

Hd = fft(h,[],2);

% call the fixed point function

[H] = ti_fft(h1dfilt,Nin,N);

% compute the NSR in dB scale

e = Hd-H;

NSR = 10*log10(sum(abs(e).^2,2)…


FFT Simulation File

The simulation file is a Matlab script file

  • Performs the simulation

  • Calls the floating point Matlab FFT function fft()

  • Calls the fixed point FFT function ti_fft()

  • Compares the frequency responses of fixed point and floating point FFTs in Matlab

  • Computes the SNR, NSR, etc. using Matlab

Fft development time

FFT Development Time

Software Development Time Comparison

  • Time required to develop hand-coded assembly functions

    • 2-3 person months

  • Time required to develop C code with Intrinsic function calls

    • 2-3person weeks

Development time is reduced by a factor of 4 to 5 !

Fft performance comparison

FFT Performance Comparison

Metric: Kernel sizes and cycle counts

  • Kernel sizes for hand-coded assembly functions

    • FirstFFTStage:18*(N/16)

    • R2Stage:7*(N/8)

    • R4Stage:12*(N/8)

    • LastFFTStage:24*(N/16)

  • Kernel sizes for C code with Intrinsic function calls

    • FirstFFTStage:19*(N/16)

    • R2Stage:8*(N/8)

    • R4Stage:14*(N/8)

    • LastFFTStage:27*(N/16)

Intrinsics performance is within 15% of assembly !

Algorithm optimization results

Algorithm Optimization Results

In most cases, Intrinsics performance is within 10% !

Matlab function libraries

DSP Simulator


Function N

Function 1

Function 2

C/C++ code



Matlab Function Libraries

For a particular DSP application

  • The DSP Simulator emulates the numerical behavior of the DSP instructions

  • Power User develops a library of optimized algorithms that contain Intrinsic function calls

  • General user writes C/C++ code that calls the optimized functions in the library

  • The user’s C/C++ code is compiled with the DSP Simulator, the library and the MEX-file

  • User tests the algorithms for performance, evaluates cycle counts, etc. in Matlab

  • The same C/C++ code is migrated directly to the target DSP

Matlab function library examples



















Matlab Function Library Examples

Math Library

Communications Library

Controls Library

Benefit: Ability to share fixed-point DSP C/C++ code and test vectors between multiple users

Closing remarks

Closing Remarks

DSP Simulator Benefits

  • Develop fixed point DSP code in Matlab

  • Easily compare floating point and fixed point algorithm implementations in Matlab

  • Bit-true, fixed point simulations

  • Reduce software development time by a factor of 4 to 5

  • Incorporate DSP code into higher level system simulations

  • Debugging code in Matlab is easier than in a real-time system

  • Easily evaluate/predict MIPS requirements

  • Run the same C/C++ source code in Matlab and in the DSP

  • Easily migrate algorithms to new DSP instruction sets

  • Develop software before next generation DSPs are available

Matlab extensions for the development

Q & A

  • Thanks for attending my presentation !

  • Login