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

emily
matlab extensions for the development testing and verification of real time dsp software n.
Skip this Video
Loading SlideShow in 5 Seconds..
Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software PowerPoint Presentation
Download Presentation
Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software

play fullscreen
1 / 28
Download Presentation
Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software
1084 Views
Download Presentation

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

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Matlab Extensions for the Development, Testing and Verification of Real-Time DSP Software David P. Magee Communication Systems Engineer Texas Instruments Dallas, TX

  2. Presentation Outline • DSP Software Development • DSP Simulator • Introduction to Intrinsics • FFT Example • Algorithm Optimization Results • Other Matlab and Simulink Extensions • Closing Remarks • Q & A

  3. Develop Floating Point Simulation Debug Simulation Step 1: Develop Understanding Develop Fixed Point Simulation Debug Simulation Step 2: Address Scaling Issues Develop Assembly Code Debug Assembly Code Step 3: Optimize for Performance DSP Software Development • Common steps for DSP software development

  4. 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 !

  5. Develop Floating Point Simulation Debug Simulation Step 1: Develop Understanding Simultaneously Develop Fixed Point Simulation and Assembly Code Simultaneously Debug Simulation and Assembly Code Step 2: Address Scaling Issues and Optimize for Performance Improved Software Development Cycle • Merge Steps 2 and 3 Question: How can these steps be combined ?

  6. Floating Point Simulation System Simulation Matlab Simulation Environment Fixed Point Simulation System Simulation Host Environment DSP Simulator 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

  7. DSP Simulator C/C++ code MEX-file Matlab DSP Simulator in Matlab Develop and Debug Fixed Point C/C++ Code in Matlab Benefits: • 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

  8. 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 http://www.mathworks.com • Enter mex files into their Search engine

  9. 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

  10. C code C6x Assembly Code Function Example() { . y = _add2(a,b); . } Example: . 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 Compile

  11. 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; return(y); } // end of _add2() function C code Function Example() { . y = _add2(a,b); . } DSP Simulator Example • C Code with _add2() Intrinsic

  12. 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

  13. 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

  14. 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

  15. 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 !

  16. 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 !

  17. 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

  18. Limitations • 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.

  19. 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

  20. // inside the Radix-2 stage for(k=Nover2;k>0;k--) { . // 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

  21. % 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)… ./sum(abs(Hd).^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

  22. 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 !

  23. 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 !

  24. Algorithm Optimization Results In most cases, Intrinsics performance is within 10% !

  25. DSP Simulator Library Function N Function 1 Function 2 C/C++ code MEX-file Matlab 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

  26. Library Library Library NoiseEst NoiseEst ChanEst ResEqu SlidingMode Hinf OuterProduct InnerProduct PID FIR RS BF IC VectorSum Viterbi 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

  27. 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

  28. Q & A • Thanks for attending my presentation !