matlab extensions for the development testing and verification of real time dsp software
Skip this Video
Download Presentation
Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software

Loading in 2 Seconds...

play fullscreen
1 / 28

Matlab Extensions for the Development - PowerPoint PPT Presentation

  • Uploaded on

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

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Matlab Extensions for the Development' - emily

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
Q & A
  • Thanks for attending my presentation !