- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Report Inappropriate Content

I am using a beta license of the IPP libraries on the ATOM processor. I am compiling in eclipse using the gcc compiler.

I am trying to benchmark the processor's capability to perform a set of identical FIR filters on 128 channels of data.

I believe that I must not be using the IPP Signal Processing libraries appropriately because I am seeing the following behavior:

It takes 6 times as long to run an integer implementation of the filter as it does to run a single precision floating point implementation.

Cutting the number of channels in half does not cut the time it takes to execute the set of single precision floating point filters.

Removing the multiply lines from the single precision floating point filters does not cut the time it takes to execute the set of single precision floating point filters.

Would you have any suggestions for common mistakes in loading or moving data which I might be committing?

Link Copied

- Mark as New
- Bookmark
- Subscribe
- Mute
- Subscribe to RSS Feed
- Permalink
- Report Inappropriate Content

Hello,

we would recommend you to try the following IPP FIR functions which were specifically tuned for Intel Atom processor

// Names: ippsFIRStream

// Purpose: FIR stream filter with integer taps. Vector filtering

// It does not have delay line.

// Parameters:

// pSrc - pointer to the input vector

// pDst - pointer to the output vector

// numIters - number iterations (for single-rate equal length data vector)

// pState - pointer to the filter state

// scaleFactor - scale factor value

// Return:

// ippStsContextMatchErr - wrong State identifier

// ippStsNullPtrErr - pointer(s) to the data is NULL

// ippStsSizeErr - numIters <= 0

// ippStsNoErr - otherwise

// Note: for Multi-Rate filtering

// length pSrc = numIters*downFactor

// length pDst = numIters*upFactor

// for inplace functions max this values

*/

IPPAPI( IppStatus, ippsFIRStreamGetStateSize_16s,( int tapsLen, int* pStateSize ))

IPPAPI( IppStatus, ippsFIRMRStreamGetStateSize_16s,( int tapsLen, int upFactor,

int downFactor, int *pStateSize ))

IPPAPI( IppStatus, ippsFIRStreamInit_16s,( IppsFIRState_16s** pState,

< P class=MsoNormal> const Ipp16s *pTaps, int tapsLen, int tapsFactor, IppRoundMode rndMode, Ipp8u* pBuf ))IPPAPI( IppStatus, ippsFIRMRStreamInit_16s,( IppsFIRState_16s** ppState,

const Ipp16s *pTaps, int tapsLen, int tapsFactor, int upFactor, int upPhase,

int downFactor, int downPhase, IppRoundMode rndMode, Ipp8u* pBuffer ))

IPPAPI(IppStatus, ippsFIRStreamInitAlloc_16s, (IppsFIRState_16s** pState,

const Ipp16s *pTaps, int tapsLen, int tapsFactor, IppRoundMode rndMode))

IPPAPI(IppStatus, ippsFIRMRStreamInitAlloc_16s, (IppsFIRState_16s** pState,

const Ipp16s *pTaps, int tapsLen, int tapsFactor, int upFactor,

int upPhase, int downFactor, int downPhase, IppRoundMode rndMode))

/* /////////////////////////////////////////////////////////////////////////////

// Names: ippsFIRStream

// Purpose: FIR stream filter with float taps. Vector filtering

// It does not have delay line.

// Parameters:

// pSrc - pointer to the input vector

// pDst - pointer to the output vector

// numIters - number iterations (for single-rate equal length data vector)

// pState - pointer to the filter state

// scaleFactor - scale factor value// Return:

// ippStsContextMatchErr - wrong State identifier

// ippStsNullPtrErr - pointer(s) to the data is NULL

// ippStsSizeErr - numIters <= 0

// ippStsNoErr - otherwise

// length pSrc = numIters*downFactor

// length pDst = numIters*upFactor

// for inplace functions max this values

*/

IPPAPI( IppStatus, ippsFIRStreamGetStateSize_32f,( int tapsLen, int *pBufferSize ))

IPPAPI( IppStatus, ippsFIRMRStreamGetStateSize_32f,( int tapsLen, int upFactor,

int downFactor, int *pBufferSize ))

IPPAPI( IppStatus, ippsFIRStreamInit_32f,( IppsFIRState_32f** pState,

const Ipp32f *pTaps, int tapsLen, Ipp8u *pBuffer ))

IPPAPI( IppStatus, ippsFIRMRStreamInit_32f,( IppsFIRState_32f** pState,

const Ipp32f *pTaps, int tapsLen, int upFactor, int upPhase,

int downFactor, int downPhase, Ipp8u *pBuffer ))

IPPAPI( IppStatus, ippsFIRStreamInitAlloc_32f,( IppsFIRState_32f** pState,

const Ipp32f *pTaps, int tapsLen ))

IPPAPI( IppStatus, ippsFIRMRStreamInitAlloc_32f,( IppsFIRState_32f** pState,

const Ipp32f* pTaps, int tapsLen, int upFactor, int upPhase,

int downFactor, int downPhase ))

Regards,

Vladimir

- Subscribe to RSS Feed
- Mark Topic as New
- Mark Topic as Read
- Float this Topic for Current User
- Bookmark
- Subscribe
- Printer Friendly Page