Engineer-to-Engineer Note

Transcription

1 Engineer-to-Engineer Note EE-211 Technicl notes on using Anlog Devices DSPs, processors nd development tools Contct our technicl support t dspsupport@nlogcom nd t dsptoolssupport@nlogcom Or visit our on-line resources nd 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors Contributed by Kls Brink nd Rickrd Fhlquist Rev 1 Jnury 13, 24 Introduction This document presents two ssembly code implementtions with memory of direct-form FIRs, cpble of hndling complex input nd output nd complex or rel coefficients with 16- bit integer precision These implementtions present methods of chieving high performnce while conserving memory Generl A mthemticl representtion in direct form of FIR filter is given below y M 1 k = [] i = x[ i k] h[ k] i, 1,, N-1 N M y[i] Number of smples Number of filter coefficients Output smple number i x[i-k] Input smple number i-k h[k] Filter coefficient number k Eqution 1 Direct-form FIR This eqution is the result from the vector inner product between the filter coefficient vector h nd the (time) order-reversed input dt vector x This is lso known s the convolution between h nd x Figure 1 presents the sme eqution grphiclly x[i] Z -1 x[i-1] Z -1 x[i-m+3] Z -1 x[i-m+2] h[] h[1] h[m-3] h[m-2] h[m-1] Z -1 x[i-m+1] y[i] Figure 1 Direct-form FIR A C pseudo-code description of the sme FIR is given below, where ** represents complex multipliction for(i=; i< N; i++){ y[i] = ; Ncoeffs = i < (M-1)? i : (M-1); for(k=; k<=ncoeffs; k++){ y[i] = y[i] + x[i-k] ** h[k]; Listing 1 C pseudo-code lgorithm of direct form FIR Prllelism in TigerSHARC Processors ADSP-TS2x TigerSHARC processors re highly prllel computing devices tht hve three distinct types of prllelism: Ltency-2 computtionl pipeline Multiple compute units Wide memory structure These three forms of prllelism complement ech other, nd ll three must be exploited to chieve high level of efficiency The computtion rte nd memory bndwidth in this mchine re blnced in such wy tht filing Copyright 24, Anlog Devices, Inc All rights reserved Anlog Devices ssumes no responsibility for customer product design or the use or ppliction of customers products or for ny infringements of ptents or rights of others which my result from Anlog Devices ssistnce All trdemrks nd logos re property of their respective holders Informtion furnished by Anlog Devices Applictions nd Development Tools Engineers is believed to be ccurte nd relible, however no responsibility is ssumed by Anlog Devices regrding technicl ccurcy nd topiclity of the content provided in Anlog Devices Engineer-to-Engineer Notes

2 to py ttention to one of the three components of prllelism my result in sub-optiml performnce 16-Bit Integer FIR with Complex Tps, Input nd Output Dt Introduction ADSP-TS2x TigerSHARC processors support two complex multiplictions (one in ech compute block) per core clock cycle long with simultneous dt trnsfers Filter clcultions like Eqution 1 cn, of course, be implemented in strightforwrd sequentil fshion using one (inner) loop for the summtion, ech itertion performing multipliction between n (old) input smple nd coefficient, nd dding tht to the output of the lst itertion, nd nother (outer) loop going through the sme procedure over nd over gin to produce the output smples However, using the prllel fetures nd high internl bndwidth of ADSP-TS2x TigerSHARC processors, chieves higher performnce Pipelining nd Prllel Resources Utiliztion The FIR representtions show tht most dt used to compute output y[i] re the sme s the ones used to compute y[i+1] The sme pplies for y[i+1] when it comes to y[i+2] nd so on The outer loop in the C pseudo-code performs ll the necessry steps to clculte ll the output smples Unrolling this outer loop gins three things: 1 Dt cn be reused between clcultions of different output smples 2 MAC opertions cn be prllelized 3 The effects of loop overhed re reduced Reducing loop overhed is not to be neglected s this decreses the time required to perform the conditionl brnching necessry for looping, thereby incresing the percentge of time vilble to perform the ctul clcultions Unrolling the outer loop four times yields n lgorithm described by the following C pseudocode: for(i=; i< N; i+=4){ y[i] = ; y[i+1] = ; y[i+2] = ; y[i+3] = ; Ncoeffs = i < (M-1)? i : (M-1); for(k=; k<=ncoeffs; k++){ y[i] = y[i] + x[i-k] **h[k]; y[i+1] = y[i+1]+ x[i+1-k]**h[k]; y[i+2] = y[i+2]+ x[i+2-k]**h[k]; y[i+3] = y[i+3]+ x[i+3-k]**h[k]; Listing 2 Outer loop unrolled 4 times Wht we hve done so fr is reuse the coefficients By lso unrolling the inner loop, we chieve reuse of input dt s well Unrolling of the inner loop by four gives the C pseudo-code in Listing 3 for(i=; i< N; i+=4){ y[i] = ; y[i+1] = ; y[i+2] = ; y[i+3] = ; Ncoeffs = i < (M-1)? i : (M-1); for(k=; k<=ncoeffs; k+=4){ y[i] = y[i] + x[i-k] **h[k]; y[i] = y[i] + x[i-1-k]**h[k+1]; y[i] = y[i] + x[i-2-k]**h[k+2]; y[i] = y[i] + x[i-3-k]**h[k+3]; y[i+1] = y[i+1]+ x[i+1-k]**h[k]; y[i+1] = y[i+1]+ x[i-k] **h[k+1]; y[i+1] = y[i+1]+ x[i-1-k]**h[k+2]; y[i+1] = y[i+1]+ x[i-2-k]**h[k+3]; y[i+2] = y[i+2]+ x[i+2-k]**h[k]; y[i+2] = y[i+2]+ x[i+1-k]**h[k+1]; y[i+2] = y[i+2]+ x[i-k] **h[k+2]; y[i+2] = y[i+2]+ x[i-1-k]**h[k+3]; y[i+3] = y[i+3]+ x[i+3-k]**h[k]; y[i+3] = y[i+3]+ x[i+2-k]**h[k+1]; y[i+3] = y[i+3]+ x[i+1-k]**h[k+2]; y[i+3] = y[i+3]+ x[i-k] **h[k+3]; Listing 3 Outer nd inner loops unrolled 4 times 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 2 of 1

3 We now hve high level of dt reuse nd possibility to prllelize clcultions Wht is not so obvious in the C pseudo-code is tht we lso hve the possibility to do pipelining (ie, fetch dt concurrent with performing the clcultions) Dt Prtitioning Complex 16-bit dt is represented in ADSP- TS2x TigerSHARC processors by 32-bit word s shown in Figure Imginry Rel Figure 2 Complex 16-bit dt representtion Input nd Coefficient Buffer Structure The input smples nd coefficients re stored in memory s described in Figure 3 Input 31 x[3] x[2] x[1] x[] x[7] x[6] x[5] x[4] Address xhhhh xhhhh + 4 Output Buffer Structure The two compute blocks (CBX nd CBY) ech clculte two output smples every outer loop itertion CBX produces smples y[i+3] nd y[i+1], nd CBY produces y[i+2] nd y[i] Qudword ligned storge is used when writing the output smples to memory, nd j4 keeps trck of the current position to be written j4 Output 31 y[3] y[2] y[1] y[] y[7] y[6] y[5] y[4] Address xkkkk xkkkk + 4 Figure 4 Output storge in memory Dely Line Structure The filter hs memory in which it stores history of the lst M input smples used by the filter This history is clled the dely line The smples from the dely line re qud-word loded, nd Figure 5 shows how they re stored Circulr buffer Dely line x[i-m+3] x[i-m+7] {x[i-1] x[i-m+2] x[i-m+6] x[i-2] x[i-m+1] x[i-m+5] x[i-3] 31 x[i-m] x[i-4] x[i-m+4] Address xllll M + 4 xllll M + 8 j xllll j5 k1 Coefficients 31 h[3] h[2] h[1] h[] h[7] h[6] h[5] h[4] xgggg xgggg + 4 Figure 3 Input nd coefficient storge in memory The ddresses re qud-word ligned This type of dt storge enbles qud-word loding, which is used for the input smples Qud-word loding is used lso for the coefficients J5 points to the position from where we re currently loding input smples, nd k1 points to the current coefficient loding position Figure 5 Dely line in memory The dely line is implemented s circulr buffer with j s pointer to the current position/index in the buffer Circulr buffer Dely line x[i+3] x[i-m+7] {x[i-1] x[i+2] x[i-m+6] x[i-2] x[i+1] x[i-m+5] x[i-3] 31 x[i] x[i-m+4] x[i-4] Figure 6 Dely line fter updte Address j xllll M + 4 xllll M + 8 xllll Old smples re red from the dely line strting t the position indicted by j nd counting bckwrds, wrpping t the circulr buffer boundries Assuming tht Figure 5 shows the 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 3 of 1

4 dely line just before smples y[i], y[i+1], y[i+2] nd y[i+3] hve been generted, Figure 6 shows the contents of the dely line fter the output genertion nd updte of the dely line Interfce The interfce to the filter function consists of the following prts: A pointer to the output buffer A pointer to the input buffer The number of smples to be filtered A pointer to the filter stte (including the dely line nd coefficient buffer) The filter stte consists of pointer to the coefficient buffer, the number of coefficients, pointer to the dely line buffer nd n index/pointer to where we re currently in the dely line buffer typedef struct { int2x16 *h; // Filter coefficients int2x16 *d; // Dely line int2x16 *p; // Dely line Index int k; // Number of coeff fir_stte_t; Listing 4 Filter stte structure The filter stte is given by the C-code in Listing 4 This structure must be initilized before the filter is used for the first time (see Appendix for n exmple of C-code initiliztion function ) 16-Bit Integer FIR with Rel Tps nd Complex Input/Output Dt Sometimes there is need to filter the rel nd imginry prts of complex smple seprtely One exmple is when the I nd Q prts of ntenn dt re treted s seprte dt strems, both independently ffected by the sme filter kernel Formt Both the tps nd the rel nd imginry prts of the input dt re 16 bits Figures 7 nd 8 show how the input to the filter lgorithm is formtted h[n+1] h[n+3] h[n+5] h[n] h[n+2] h[n+4] Figure 7 Filter coefficients formt 31 Im{x[i] Im{x[i+1] Im{x[i+2] 15 Re{x[i] Re{x[i+1] Re{x[i+2] void fir_16_comp( int2x16 *outdt, int2x16 *indt, int N, fir_stte_t *fir_stte ); Listing 5 Filter function prototype Listing 5 shows C-code prototype of the interfce Figure 8 Input smple formt Since the dt to be filtered is 32 bits wide with ech 16-bit short word treted independently, one pproch tht fcilittes the prllel structure of the ADSP-TS2x TigerSHARC processor is 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 4 of 1

5 to duplicte ech filter coefficient nd crete pirs of coefficients tht occupy 32 bits ech h[n] h[n] Figure 9 Duplicted coefficients This wy four 16-bit MACs re performed per cycle in ech compute block, the rel results re ccumulted in two of the MR registers, nd the imginry results re stored in two other Implementtion One filtered output smple (y[i]) is clculted in compute block X nd the next (y[i+1]) is simultneously computed in compute block Y Using this pproch, only hlf the number of itertions re needed for certin number of input smples To ccomplish this, the coefficients re skewed one position for one of the compute blocks when loded from memory In the filter implementtion listed in ppendix A (fir16_relsm) the filter kernel ws short enough to be completely stored in the X nd Y register files Dely Line The dely line is s long s the filter kernel Using the sme dely line pproch s the one described for the complex filter, problems rise becuse the filter tps re 16 bits, wheres the input smples re 32 (16+16) bits One wy to esily get round this is to plce the lst processed smples (the dely line) directly before the next buffer to filter in memory The downside is tht between every cll to the filter, the dely line needs to be trnsferred to the beginning of the next buffer For modertely long kernel, however, the overhed is not significnt Old input buffer Dely line buffer Figure 1 Dely line hndling Next input buffer 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 5 of 1

6 Appendix The ssembly code for the filter functions re given, s well s heder file (*h) specifying the filter stte structure, filter stte initiliztion function, nd the filter function prototype, so tht it cn esily be used in C-code fir_16_comph /* ******************************************************************************** * * Copyright (c) 23 Anlog Devices Inc All rights reserved * * *******************************************************************************/ #include <i16h> typedef struct { int2x16 *h; // Filter coefficients int2x16 *d; // Strt of (circulr) dely line int2x16 *p; // Current index into dely line int k; // Number of coefficients fir_stte_t; void fir_16_comp(int2x16 *outdt, int2x16 *indt, int N, fir_stte_t *fir_stte); #define fir_init(stte, coeffs, dely, ncoeffs) \ (stte)h = (int2x16 *) (coeffs); \ (stte)d = (int2x16 *) (dely); \ (stte)p = (int2x16 *) (dely); \ (stte)k = (int) (ncoeffs) Listing 6 fir_16_comph fir_16_compsm /* ******************************************************************************** * * Copyright (c) 23 Anlog Devices Inc All rights reserved * * *******************************************************************************/ globl _fir_16_comp; section progrm; lign_code 4; _fir_16_comp: #define Yout j4 // Pointer to output smple buffer #define Xin j5 // Pointer to input smple buffer #define N j6 // Number of smples to be filtered #define FStte j7 // Pointer to filter stte structure #define h_offs // Filter stte structure offset to Coefficients // buffer pointer #define d_offs 1 // Filter stte structure offset to Dely line pointer 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 6 of 1

7 #define p_offs 2 // Filter stte structure offset to Dely line index #define k_offs 3 // Filter stte structure offset to Number of // coefficients // Sve stck so we cn use the internl registers // Stck PROLOGUE J26 = J27-64; K26 = K27-64;; [J27 += -28] = CJMP; K27 = K27-2;; Q[J ] = XR27:24; Q[K ] = YR27:24;; Q[J27 + 2] = XR31:28; Q[K ] = YR31:28;; Q[J ] = J19:16; Q[K ] = K19:16;; Q[J ] = J23:2; Q[K ] = K23:2;; // Stck PROLOGUE ENDS // Set number of smples to be generted/filtered // (outerloop, 4 smples ech itertion) // Set number of times to go through filter kernel to use whole filter // (innerloop, 4 coeffs/tps ech itertion) yr24 = N ; // Number of smples xr24 = [FStte + k_offs] ;; // Number of coeffs j = [FStte + p_offs] ;; // Set j to point to ltest smple in dely // line, ie x[i+k-1] jl = xr24 ; // Circulr buffer length = Number of coeffs R24 = ASHIFT R24 BY -2 ;; // Divide number of smples nd coeffs by 4 LC1 = yr24 ; // Number of itertions for outerloop (LC1) = // Number of smples/4 jb = [FStte + d_offs] ;; // Circulr buffer bse ddress = dely line // buffer bse ddress lign_code 4; outerloop: k1 = [FStte + h_offs] ; // Set k1 to point to coefficient buffer LC = xr24 ;; // Number of itertions for innerloop (LC) = // Number of coeffs/4 // Lod input smples nd coeffs R7:4 = q[xin+=4] ;; // Get x[i+k+3]:x[i+k] from input smple buffer R11:8 = q[k1+=4] ;; // Get c[k+3]:c[k] from coefficient buffer R19:16 = R7:4 ; // Sve x[i+k+3]:x[i+k] for lter store in // dely line // Perform initil complex mult between dt nd coeffs nd store in clered // MACs xmr3:2 += R7 ** R8 (CI) ; // y[i+3] = + x[i+k+3] ** c[k] ymr3:2 += R5 ** R8 (CI) ;; // y[i+1] = + x[i+k+1] ** c[k] xmr1: += R6 ** R8 (CI) ; // y[i+2] = + x[i+k+2] ** c[k] ymr1: += R4 ** R8 (CI) ; // y[i+] = + x[i+k+] ** c[k] R3: = CB Q[j+=-4] ;; // Get x[i+k-1]:x[i+k-4] lign_code 4; innerloop: // Iterte through filter length xmr3:2 += R6 ** R9 (I) ; // y[i+3] = y[i+3] + x[i+k+2] ** c[k+1] ymr3:2 += R4 ** R9 (I) ;; // y[i+1] = y[i+1] + x[i+k+] ** c[k+1] 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 7 of 1

8 xmr1: += R5 ** R9 (I) ; // y[i+2] = y[i+2] + x[i+k+1] ** c[k+1] ymr1: += R3 ** R9 (I) ; // y[i+] = y[i+] + x[i+k-1] ** c[k+1] R23:2 = q[k1+=4] ;; // Get c[k+7]:c[k+4] xmr3:2 += R5 ** R1 (I) ; // y[i+3] = y[i+3] + x[i+k+1] ** c[k+2] ymr3:2 += R3 ** R1 (I) ;; // y[i+1] = y[i+1] + x[i+k-1] ** c[k+2] xmr1: += R4 ** R1 (I) ; // y[i+2] = y[i+2] + x[i+k+] ** c[k+2] ymr1: += R2 ** R1 (I) ; // y[i+] = y[i+] + x[i+k-2] ** c[k+2] R9:8 = R21:2 ;; // Use c[k+5]:c[k+4] xmr3:2 += R4 ** R11 (I) ; // y[i+3] = y[i+3] + x[i+k+] ** c[k+3] ymr3:2 += R2 ** R11 (I) ; // y[i+1] = y[i+1] + x[i+k-2] ** c[k+3] R7:4 = R3: ;; // Shift x[i+k-1]:x[i+k-4] into x[i+k+3]:x[i+k] xmr1: += R3 ** R11 (I) ; // y[i+2] = y[i+2] + x[i+k-1] ** c[k+3] ymr1: += R1 ** R11 (I) ; // y[i+] = y[i+] + x[i+k-3] ** c[k+3] R11:1 = R23:22 ;; // Use c[k+7]:c[k+6] xr15:14 = MR3:2, MR3:2 += R7 ** R8 (I); // y[i+3] = y[i+3] + x[i+k-1] ** c[k+4] yr15:14 = MR3:2, MR3:2 += R5 ** R8 (I);; // y[i+1] = y[i+2] + x[i+k-3] ** c[k+4] if NLCE, JUMP innerloop ; // All filter tps computed? xr13:12 = MR1:, MR1: += R6 ** R8 (I); // y[i+2] = y[i+2] + x[i+k-2] ** c[k+4] yr13:12 = MR1:, MR1: += R4 ** R8 (I); // y[i+] = y[i+] + x[i+k-4] ** c[k+4] R3: = CB Q[j+=-4] ;; // Get x[i+k-5]:x[i+k-8] j=j+8 (CB) ; sr12 = COMPACT R13:12 (IS);; // Trnsfer result from MACs nd compct // from 32-bit to 16-bit (with sturtion) CB q[j+=j31] = xr19:16 ; // Store x[i+k+3]:x[i+k] in dely line buffer sr13 = COMPACT R15:14 (IS);; // Trnsfer result from MACs nd compct from // 32-bit to 16-bit (with sturtion) lign_code 4; if NLC1E, JUMP outerloop ; // All smples computed? q[yout+=4] = R13:12 ;; // Store 4 output smples in output buffer [FStte + p_offs] = j ;; // Sve j to point to ltest smple in dely // line, ie x[i+k-1] // Restore stck nd return to clling function // EPILOGUE STARTS CJMP = [J ];; YR27:24 = q[k ]; XR27:24 = q[j ];; YR31:28 = q[k ]; XR31:28 = q[j27 + 2];; K19:16 = q[k ]; J19:16 = q[j ];; K23:2 = q[k ]; J23:2 = q[j ];; CJMP (ABS); J27:24=q[J26+68]; K27:24=q[K26+68]; nop;; // EPILOGUE ENDS _fir_16_compend: Listing 7 fir_16_compsm fir16_relsm section progrm; globl _fir16_rel; _fir16_rel: 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 8 of 1

9 // Locl defines #define Yout j4 #define Xin j5 #define INPUT_LEN j6 #define FIR_STATE j7 // Offsets to stte struct elements #define coeff_offs #define dely_offs 1 #define idx_offs 2 #define nof_coeff_offs 3 //PROLOGUE J26 = J27-64; K26 = K27-64;; [J27 += -28] = CJMP; K27 = K27-2;; Q[J ] = XR27:24; Q[K ] = YR27:24;; Q[J27 + 2] = XR31:28; Q[K ] = YR31:28;; Q[J ] = J19:16; Q[K ] = K19:16;; Q[J ] = J23:2; Q[K ] = K23:2;; //PROLOGUE ENDS k = [FIR_STATE + coeff_offs];; k = k + k;; // Times 2 for short dt ccess j = k;; j = j + x1;; xr3: yr3: xr3: yr3: = sdab q[k += x8]; // Prelod filter coeffs to CBX = sdab q[j += x8];; // Prelod skewed coeffs copy into CBY = sdab q[k += x8]; = sdab q[j += x8];; xr2 = INPUT_LEN;; // Expnd the coeffs into 2 identicl short words(16 bits) ech SR11:8 = MERGE R1:, R1:;; SR15:12 = MERGE R3:2, R3:2;; // Divide by two since two outputs re clculted simultneously xr2 = ASHIFT R2 by -1;; j11 = -1;; // increment for i/p pointer j = Xin + x2; // The first dt will be picked from dely line LC = xr2 ;; R27:24 = DAB q[j += 4];; // Prefetch R27:24 = DAB q[j += 4];; j8 = [FIR_STATE + dely_offs];; // Get pointer to dely line ///////// Loop over number of input smples //////// lign_code 4; loop_: R3: = R27:24;; MR3: += R9:8 * R25:24 (CI); R31:28 = DAB q[j += 4];; MR3: += R11:1 * R27:26 (I); R27:24 = DAB q[j += j11];; MR3: += R13:12 * R29:28 (I); R27:24 = DAB q[j += 4];; MR3: += R15:14 * R31:3 (I); R27:24 = DAB q[j += 4];; sr23:22 = COMPACT MR3: (IS);; 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 9 of 1

10 R7:4 = R31:28;; sr21 = R23 + R22;; if NLCE, jump loop_; l[yout += x2] = xyr21;; /////////// End of loop_ //////////////// q[j8 += x4] = xr3:;; // Store dely line q[j8 += j31] = xr7:4;; // EPILOGUE STARTS CJMP = [J ];; YR27:24 = q[k ]; XR27:24 = q[j ];; YR31:28 = q[k ]; XR31:28 = q[j27 + 2];; K19:16 = q[k ]; J19:16 = q[j ];; K23:2 = q[k ]; J23:2 = q[j ];; CJMP (ABS); J27:24=q[J26+68]; K27:24=q[K26+68]; nop;; // EPILOGUE ENDS _fir16_relend: Listing 8 fir16_relsm Document History Version Rev 1 Jnury 13, 24 by Kls Brink Description Initil Relese 16-bit FIR Filters on ADSP-TS2x TigerSHARC Processors (EE-211) Pge 1 of 1