Current version

v1.10.4 (stable)

Navigation

Main page
Archived news
Downloads
Documentation
   Capture
   Compiling
   Processing
   Crashes
Features
Filters
Plugin SDK
Knowledge base
Donate
Contact info
Forum
 
Other projects
   Altirra

Search

Archives

01 Dec - 31 Dec 2013
01 Oct - 31 Oct 2013
01 Aug - 31 Aug 2013
01 May - 31 May 2013
01 Mar - 31 Mar 2013
01 Feb - 29 Feb 2013
01 Dec - 31 Dec 2012
01 Nov - 30 Nov 2012
01 Oct - 31 Oct 2012
01 Sep - 30 Sep 2012
01 Aug - 31 Aug 2012
01 June - 30 June 2012
01 May - 31 May 2012
01 Apr - 30 Apr 2012
01 Dec - 31 Dec 2011
01 Nov - 30 Nov 2011
01 Oct - 31 Oct 2011
01 Sep - 30 Sep 2011
01 Aug - 31 Aug 2011
01 Jul - 31 Jul 2011
01 June - 30 June 2011
01 May - 31 May 2011
01 Apr - 30 Apr 2011
01 Mar - 31 Mar 2011
01 Feb - 29 Feb 2011
01 Jan - 31 Jan 2011
01 Dec - 31 Dec 2010
01 Nov - 30 Nov 2010
01 Oct - 31 Oct 2010
01 Sep - 30 Sep 2010
01 Aug - 31 Aug 2010
01 Jul - 31 Jul 2010
01 June - 30 June 2010
01 May - 31 May 2010
01 Apr - 30 Apr 2010
01 Mar - 31 Mar 2010
01 Feb - 29 Feb 2010
01 Jan - 31 Jan 2010
01 Dec - 31 Dec 2009
01 Nov - 30 Nov 2009
01 Oct - 31 Oct 2009
01 Sep - 30 Sep 2009
01 Aug - 31 Aug 2009
01 Jul - 31 Jul 2009
01 June - 30 June 2009
01 May - 31 May 2009
01 Apr - 30 Apr 2009
01 Mar - 31 Mar 2009
01 Feb - 29 Feb 2009
01 Jan - 31 Jan 2009
01 Dec - 31 Dec 2008
01 Nov - 30 Nov 2008
01 Oct - 31 Oct 2008
01 Sep - 30 Sep 2008
01 Aug - 31 Aug 2008
01 Jul - 31 Jul 2008
01 June - 30 June 2008
01 May - 31 May 2008
01 Apr - 30 Apr 2008
01 Mar - 31 Mar 2008
01 Feb - 29 Feb 2008
01 Jan - 31 Jan 2008
01 Dec - 31 Dec 2007
01 Nov - 30 Nov 2007
01 Oct - 31 Oct 2007
01 Sep - 30 Sep 2007
01 Aug - 31 Aug 2007
01 Jul - 31 Jul 2007
01 June - 30 June 2007
01 May - 31 May 2007
01 Apr - 30 Apr 2007
01 Mar - 31 Mar 2007
01 Feb - 29 Feb 2007
01 Jan - 31 Jan 2007
01 Dec - 31 Dec 2006
01 Nov - 30 Nov 2006
01 Oct - 31 Oct 2006
01 Sep - 30 Sep 2006
01 Aug - 31 Aug 2006
01 Jul - 31 Jul 2006
01 June - 30 June 2006
01 May - 31 May 2006
01 Apr - 30 Apr 2006
01 Mar - 31 Mar 2006
01 Feb - 29 Feb 2006
01 Jan - 31 Jan 2006
01 Dec - 31 Dec 2005
01 Nov - 30 Nov 2005
01 Oct - 31 Oct 2005
01 Sep - 30 Sep 2005
01 Aug - 31 Aug 2005
01 Jul - 31 Jul 2005
01 June - 30 June 2005
01 May - 31 May 2005
01 Apr - 30 Apr 2005
01 Mar - 31 Mar 2005
01 Feb - 29 Feb 2005
01 Jan - 31 Jan 2005
01 Dec - 31 Dec 2004
01 Nov - 30 Nov 2004
01 Oct - 31 Oct 2004
01 Sep - 30 Sep 2004
01 Aug - 31 Aug 2004

Stuff

Powered by Pivot  
XML: RSS feed 
XML: Atom feed 

§ Optimizing a FIR filter routine

Recently I had to implement a low-pass audio filter in software. A low-pass filter is so named because it passes low frequencies while muting high ones, similar to what you'd get by turning treble all the way down on a stereo. Low-pass filters have a number of uses, the particular use in this case being to prevent aliasing in a subsequent resampling pass.

There are many ways to implement a low-pass filter, but the method that I used was a finite impulse response (FIR) filter. FIR filters have a few advantages, such as simplicity of implementation in software and ease of making linear-phase filters. The cutoff frequency was fairly high, so the FIR filter kernel didn't need that many taps -- a 15 tap symmetric filter was enough. 

To retell the tale, let's start with this routine:

void filter(float *dst, const float *src, size_t n, const float *kernel) {
    const float k0 = kernel[0];
    const float k1 = kernel[1];
    const float k2 = kernel[2];
    const float k3 = kernel[3];
    const float k4 = kernel[4];
    const float k5 = kernel[5];
    const float k6 = kernel[6];
    const float k7 = kernel[7];
    do {
        float v = src[7] * k0
                + (src[ 6] + src[ 8]) * k1
                + (src[ 5] + src[ 9]) * k2
                + (src[ 4] + src[10]) * k3
                + (src[ 3] + src[11]) * k4
                + (src[ 2] + src[12]) * k5
                + (src[ 1] + src[13]) * k6
                + (src[ 0] + src[14]) * k7;
        ++src;
        *dst++ = v;
    } while(--n);
}

So... how fast does it run? Well, compiled using Visual C++ 2010 and run on a Core 2, the timing is about 125,000 cycles for 4,096 samples, or 30.5 cycles/sample. Not too surprising, considering that there are 22 elementary operations per sample (14 additions, 8 multiplications). This is with cache effects mostly discounted, as I test routines like this by running them 10 times in a loop and taking the minimum time -- cache effects are important, but they're too often noise when profiling a routine like this and can make it hard to compare routines. Therefore, all of these timings are ideal timings with regard to memory delays.

Another thing you might notice is the lack of __restrict; I'm omitting them for brevity here, although they were used on the timings. I know why the restrict keyword exists and how it helps optimization, but truth be told, I've never seen a single case where the Visual C++ compiler took advantage of it, no matter how many times I've tried it.

Alright, that's the easy case....

It's not terribly useful to benchmark a routine on a fast system, so we're going to try something harder: my trusty little Atom-based netbook. Survey says: 442,000 cycles, or 108 cycles/sample. Ugh. Well, we know that an Atom isn't as fast as a Core 2, so this isn't surprising. However, we can do better than this. First stop is to look at the disassembly:

fld         dword ptr [eax+8]
add         eax,4
fadd        dword ptr [eax-4]
add         ecx,4
dec         edx
fmul        st,st(4)
fld         dword ptr [eax]
fmul        st,st(6)
faddp       st(1),st
fld         dword ptr [eax+8]
fadd        dword ptr [eax-8]
fmul        st,st(4)
faddp       st(1),st
fld         dword ptr [eax+0Ch]
fadd        dword ptr [eax-0Ch]
fmul        st,st(3)
faddp       st(1),st
fld         dword ptr [eax+10h]
fadd        dword ptr [eax-10h]
fmul        st,st(2)
faddp       st(1),st
fld         dword ptr [eax+14h]
fadd        dword ptr [eax-14h]
fmul        dword ptr [esp+10h]
faddp       st(1),st
fld         dword ptr [eax+18h]
fadd        dword ptr [eax-18h]
fmul        dword ptr [esp+14h]
faddp       st(1),st
fld         dword ptr [eax+1Ch]
fadd        dword ptr [eax-1Ch]
fmul        dword ptr [esp+18h]
faddp       st(1),st
fstp        dword ptr [esp+2Ch]
fld         dword ptr [esp+2Ch]
fstp        dword ptr [ecx-4]
jne         0000005F

Not too bad, but there are some obvious issues here. In my experience, Visual C++ tends not to interleave calculations and instead prioritizes clustering related operations together. This is not a bad idea for a CPU like the Core 2, which has both out-of-order execution and an anemic lack of general purpose registers. However, it's not great for the in-order Atom because it means that the whole routine is full of stalls, since nothing can run in parallel. We need to do something about this.

The most obvious thing to do would be to try to reorder the instructions to gain some parallelism. I won't spend time here doing so, but suffice it to say that I tried this and it executed even more poorly than the straightforward code above. A bit of checking with Agner Fog's optimization tome reveals that the Atom has two big problems in this area, one being pathological scheduling with back-to-back x87 instructions and another being a non-free cost for the FXCH instruction. The Core 2, of course, doesn't mind and actually likes the rescheduled instruction stream better. We know that it's possible to do better on both CPUs, though, so it's not worth wasting any more time with x87.

Time for SSE

You might wonder why I didn't try throwing /arch:SSE on the compiler. Well, I did, but the x86 version of Visual C++ is generally reluctant to use SSE scalar math instructions even when you tell it to, and refused to recompile the inner loop as such. Part of the reason is that it's constrained by the ABI, which requires returning parameters in st(0), and I suspect it's also partly due to some older CPUs that executed x87 better than scalar SSE. Therefore, we'll have to go to assembly for this one. The good news is that in SSE we don't have to deal with a stupid register stack:

movss xmm0, [ecx+7*4]
movss xmm1, [ecx+6*4]
mulss xmm0, [edx+0*4]
movss xmm2, [ecx+5*4]
addss xmm1, [ecx+8*4]
movss xmm3, [ecx+4*4]
addss xmm2, [ecx+9*4]
mulss xmm1, [edx+1*4]
movss xmm4, [ecx+3*4]
addss xmm3, [ecx+10*4]
mulss xmm2, [edx+2*4]
addss xmm0, xmm1
movss xmm5, [ecx+2*4]
addss xmm4, [ecx+11*4]
mulss xmm3, [edx+3*4]
addss xmm0, xmm2
movss xmm6, [ecx+1*4]
addss xmm5, [ecx+12*4]
mulss xmm4, [edx+4*4]
addss xmm0, xmm3
movss xmm7, [ecx+0*4]
addss xmm6, [ecx+13*4]
mulss xmm5, [edx+5*4]
addss xmm0, xmm4
mulss xmm6, [edx+6*4]
addss xmm0, xmm5
addss xmm7, [ecx+14*4]
addss xmm0, xmm6
mulss xmm7, [edx+7*4]
add ecx, 4
addss xmm0, xmm7
movss [ebx], xmm0
add ebx, 4
dec eax
jne xloop

Core 2 likes this about the same as the interleaved x87 asm routine at about 88,000 cycles (21.5 cycles/sample). Atom appreciates it a lot more, however, and grinds through it twice as fast at 200,000 cycles (49 cycles/sample). Not bad.

So we've established that scalar SSE floating-point runs much, much better on Atom than x87. I guess the hardware designers are sick of the register stack, too. We're still doing everything in scalar math, however, so next stop is vectorization.

Vectorizing a FIR routine

If you take a look at the original routine again you'll notice that I took advantage of the symmetric filter kernel and added symmetric taps together before scaling by the common weighting factors. Well, this doesn't work as well for a vectorized routine, because the symmetry is around a single tap, and when dealing with vectors that means some annoying shuffling to get everything in place. In this case, it seems more trouble than it's worth, so we'll ditch it and just evaluate the filter kernel without the symmetry optimization. This means double the multiplications, but those are about the same cost as the shuffles would be anyway as long as we keep the pipelines fed.

That leaves the question of how to evaluate the filter. Ordinarily I construct FIR loops to read from a sliding window, weighting input samples to produce a single output sample. However, for vectorized routines I've warmed up to the alternate strategy of inverting the filter and accumulating output samples into a sliding window instead. There are two reasons to do this: (1) read/modify/write is no more costly if you can keep the destination in a register, and more importantly (2) it avoids the need for expensive horizontal adds.

First stab, using intrinsics:

__m128 zero = _mm_setzero_ps();
__m128 x0 = zero;
__m128 x1 = zero;
__m128 x2 = zero;
__m128 x3 = zero;
__m128 f0;
__m128 f1;
__m128 f2;
__m128 f3;
// init filter
__m128 k0 = _mm_loadu_ps(kernel + 0);
__m128 k1 = _mm_loadu_ps(kernel + 4);
f0 = _mm_shuffle_ps(k1, k1, _MM_SHUFFLE(0, 1, 2, 3));
f1 = _mm_shuffle_ps(k0, k0, _MM_SHUFFLE(0, 1, 2, 3));
f2 = _mm_move_ss(k0, k1);
f2 = _mm_shuffle_ps(f2, f2, _MM_SHUFFLE(0, 3, 2, 1));
f3 = _mm_move_ss(k1, zero);
f3 = _mm_shuffle_ps(f3, f3, _MM_SHUFFLE(0, 3, 2, 1));
// prime
for(int i=0; i<14; ++i) {
    x0 = _mm_move_ss(x0, x1);
    x0 = _mm_shuffle_ps(x0, x0, _MM_SHUFFLE(0, 3, 2, 1));
    x1 = _mm_move_ss(x1, x2);
    x1 = _mm_shuffle_ps(x1, x1, _MM_SHUFFLE(0, 3, 2, 1));
    x2 = _mm_move_ss(x2, x3);
    x2 = _mm_shuffle_ps(x2, x2, _MM_SHUFFLE(0, 3, 2, 1));
    x3 = _mm_move_ss(x3, zero);
    x3 = _mm_shuffle_ps(x3, x3, _MM_SHUFFLE(0, 3, 2, 1));


    __m128 s = _mm_load1_ps(src++);
    x0 = _mm_add_ps(x0, _mm_mul_ps(f0, s));
    x1 = _mm_add_ps(x1, _mm_mul_ps(f1, s));
    x2 = _mm_add_ps(x2, _mm_mul_ps(f2, s));
    x3 = _mm_add_ps(x3, _mm_mul_ps(f3, s));
}
// pipeline
do {
    x0 = _mm_move_ss(x0, x1);
    x0 = _mm_shuffle_ps(x0, x0, _MM_SHUFFLE(0, 3, 2, 1));
    x1 = _mm_move_ss(x1, x2);
    x1 = _mm_shuffle_ps(x1, x1, _MM_SHUFFLE(0, 3, 2, 1));
    x2 = _mm_move_ss(x2, x3);
    x2 = _mm_shuffle_ps(x2, x2, _MM_SHUFFLE(0, 3, 2, 1));
    x3 = _mm_move_ss(x3, zero);
    x3 = _mm_shuffle_ps(x3, x3, _MM_SHUFFLE(0, 3, 2, 1));

    __m128 s = _mm_load1_ps(src++);
    x0 = _mm_add_ps(x0, _mm_mul_ps(f0, s));
    x1 = _mm_add_ps(x1, _mm_mul_ps(f1, s));
    x2 = _mm_add_ps(x2, _mm_mul_ps(f2, s));
    x3 = _mm_add_ps(x3, _mm_mul_ps(f3, s));
    _mm_store_ss(dst++, x0);
} while(--n);

This is a bit more obscure than the original routine, so a bit of explanation: x0-x3 form a 16 output sample pipeline where we shift in zeros at the high end (x3.w) and shift out samples at the low end (x0.x). At the same time, we bring in input samples one at a time and accumulate its contribution to each of the 16 output samples according to the input sample's relative location to the output sample. This is done simply by splatting out the input sample 16 times and scaling that vector by the reversed kernel (which is the same, since it's symmetric). Each turn of the crank merges one input sample, shifts the window over one, and writes out one output sample. There is one other minor gotcha, which is that we have to prime the pipe with 14 input samples first -- but that's just the normal loop with the output sample discarded.

Core 2 clocks in at 66,000 cycles (16.1 cycles/sample), Atom at 141,000 cycles (34.4 cycles/sample). That looks a bit better. We're now at about 2-2.5x over the original scalar code.

Problem in the machine code

If we dump the disassembly generated by VC10, there's a problem:

movss       xmm6,xmm1
movss       xmm3,xmm6
movss       xmm6,xmm2
movss       xmm1,xmm6
movss       xmm6,xmm0
movss       xmm2,xmm6
movss       xmm6,xmm4
movss       xmm0,xmm6
movaps      xmmword ptr [esp+10h],xmm0
movss       xmm0,dword ptr [eax]
shufps      xmm0,xmm0,0
movaps      xmm6,xmm0
mulps       xmm6,xmm5
shufps      xmm3,xmm3,39h
addps       xmm3,xmm6
movaps      xmm6,xmm0
mulps       xmm6,xmmword ptr [esp+20h]
shufps      xmm1,xmm1,39h
addps       xmm1,xmm6
movaps      xmm6,xmm0
mulps       xmm6,xmmword ptr [esp+30h]
mulps       xmm0,xmmword ptr [esp+40h]
shufps      xmm2,xmm2,39h
addps       xmm2,xmm6
movaps      xmm6,xmmword ptr [esp+10h]
mov         ecx,edx
add         eax,4
add         edx,4
dec         esi
shufps      xmm6,xmm6,39h
addps       xmm0,xmm6
movss       dword ptr [ecx],xmm3
jne         00000330

What the heck is going on with the movss instructions at the top of the loop? Not too bash the VC++ team too much, but unnecessary register-to-register moves have been an issue with intrinsics in VC++ all the way back to the VC6 Processor Pack, and it's astonishing that even with the renewed focus on intrinsics code generation in VC10 the problem still hasn't been solved (bug 556347). Sigh. Back to assembly it is:

movss xmm7, [ecx]
movss xmm0, xmm1
shufps xmm7, xmm7, 0
movaps xmm4, [esp]
movss xmm1, xmm2
shufps xmm0, xmm0, 00111001b
movaps xmm5, [esp+16]
movss xmm2, xmm3
shufps xmm1, xmm1, 00111001b
pxor xmm6, xmm6
add ecx, 4
shufps xmm2, xmm2, 00111001b
movss xmm3, xmm6
movaps xmm6, [esp+32]
mulps xmm4, xmm7
shufps xmm3, xmm3, 00111001b
mulps xmm5, xmm7
mulps xmm6, xmm7
mulps xmm7, [esp+48]
addps xmm0, xmm4
addps xmm1, xmm5
addps xmm2, xmm6
addps xmm3, xmm7
movss [edx], xmm0
add edx, 4
dec eax
jne xloop

Pipeline is in XMM0-XMM3, source pointer is ECX, dest pointer is EDX. I've omitted setup code here, but don't worry, I'll provide it later. Results: Core 2 takes 40,000 cycles (9.8 cycles/sample), Atom takes 89,000 cycles (21.8 cycles/sample). That's about a third faster than the compiler.

Scheduling for Atom

Can we get this lower? Definitely, at least for the Atom. Specifically, there are some stalls in the above code that are causing problems:

Therefore, we've got to reorder the instructions to clear the stalls. Brace yourself, this is going to be messy:

movss  xmm7, [ecx]
movss  xmm0, xmm1
shufps xmm7, xmm7, 0
mulps  xmm4, xmm7
movss  xmm1, xmm2
shufps xmm0, xmm0, 00111001b
add   ecx, 4
mulps  xmm5, xmm7
movss  xmm2, xmm3
shufps xmm1, xmm1, 00111001b
movaps xmm6, xmm7
mulps  xmm6, [esp+32]
shufps xmm2, xmm2, 00111001b
addps  xmm0, xmm4
mulps  xmm7, [esp+48]
add   edx, 4
psrldq xmm3, 4
addps  xmm1, xmm5
movaps xmm4, [esp]
dec   eax
movaps xmm5, [esp+16]
addps  xmm2, xmm6
movss  [edx-4], xmm0
addps  xmm3, xmm7
jne   xloop

I've added a single SSE2 instruction, PSRLDQ, to avoid an issue with register pressure (couldn't spare a register for zero). It's worth noting that while the Atom is capable of running two instructions per cycle at peak, there are unused instruction slots in the loop above. The reason is that the loop is bottlenecked on instructions that can only execute in the first pipe, so there's no possible way to drop a clock by reordering instructions alone. This is because pipe 0 handles too many types of instructions we need here: load/store, shift, and vector multiply. It would be easier if load/store instructions executed in pipe 1, but the problem is that would likely make MULPS xmm, m128 instructions unpairable, which would have made it a wash here.

Incidentally, Agner's tome says there is a 4-5 clock latency to read memory for vector instructions on the Atom, but I wasn't seeing that at all on loads. Good thing, too, because it would have made the code run much slower.

This runs at about the same speed on Core 2, but on Atom, it runs another third faster: 62,000 cycles, or 15 cycles/sample. By my estimates the code should actually run at 14 cycles/sample, but I have been unable to eliminate the last cycle for some reason -- it could be that branches on Atom are two cycles, in which case 15 cycles would be optimal for this instruction mix. This is about the fastest I've been able to get the routine so far, for an improvement of 3x over the scalar code on Core 2 and 7x on Atom.

Left as exercises for the reader

If you want to play with the code: http://www.virtualdub.org/downloads/fir.zip. It's not polished, it doesn't check CPU flags, and it doesn't even have a project file. I trust you can deal with this, of course. It works on VS2005 and VS2010.

The routine would likely run faster if written in x64, as with the extra registers some of the load/stores could be eliminated and the loop unrolled. To bad I'm still stuck in x86 land. :P

I tried an SSSE3 version to take advantage of PALIGNR instead of MOVSS + SHUFPS, but it wasn't as advantageous as I had hoped -- 10% faster on Core 2, but 7% slower on Atom. One reason is that PALIGNR is a shift instruction, so on Atom it still requires pipe 0, while MOVSS is a cheap instruction that can fit in a pipe 1 hole. Another reason is that PALIGNR, like SHUFPS, has the source and destination registers swapped from the way you would expect. In this case, it forces the pipeline to be run in the opposite direction with left shifts, which then requires extra instructions to pull the output sample from the top of a register. I tried EXTRACTPS to do this, until I found out the hard way -- via a crash -- that it's an SSE4.1 instruction. Oops.

Best I can tell, the only way to get a major speedup from this code on x86 would be to ditch floating-point and go back to good old fashioned 16-bit fixed point. Fixed-point code is still viable in many cases because integer instructions can often execute in more pipes and with lower latencies. Going to fixed point would mean switching the algorithm back to the original style of a sliding source window, as the multiplies widen values from 16-bit to 32-bit, and we'd need to take advantage of PMADDWD in order to get a speedup over the FP code. The downside is that we'd be back to doing a horizontal add at the end, and that would be tricky to optimize and interleave.

Final note: The level of optimization achieved here is a bit of overkill in that the original application runs this on a real-time, stereo 64KHz audio stream. If you crunch the numbers, that's 0.8% of a 1.6GHz Atom even with the original scalar code, and at a 10% CPU target for battery life and heat reasons, that's still only 8% of total CPU usage. Truth be told, I got a little carried away again optimizing this thing, but I figure that I might as well take the 3-7x improvement now that I have it.

Comments

Comments posted:


Thank you for a very thought provoking article!

I learned that "compilers now out perform programmers on optimisations", and never thought to question it. You've demonstrated this isn't always the case!

Sarah (link) - 16 05 10 - 18:50


It's more true if you restate it as "compilers now outperform most programmers on optimizations." I won't claim to be the best asm optimizer by far -- I think I'm pretty far behind the x264 folks, for instance -- but there are a lot of programmers that don't know assembly language, and you need that if you are going to work at this level. The other factor is that part of this optimization was at the algorithmic level (change in evaluation strategy), and general purpose compilers generally can't work at that level because it's far more domain specific and requires a lot more knowledge about the problem than can generally be conveyed in regular programming languages.

Phaeron - 16 05 10 - 19:26


"The level of optimization achieved here is a bit of overkill..." - it might be overkill for this application, but thanks for sharing. I will try some of these tricks for speeding up 3D volume separable filtering, where the in-line, X-axis portion, is what you have provided. It is the hardest to vectorize. I must add that on x64, which I am fortunate enough to use, VS generates decent scalar SSE code.

Since you mention intrinsics - have you noticed that VS almost never does loop unrolls (partial or otherwise) when SSE intrinsics are in the body of the loop? It almost seems that for loop transform purposes, VS treats intrinsics as function calls....

Stefan - 17 05 10 - 01:13


Very nice description of optimizing a routing using vectorization. Too few people know how to do this in my opinion!

Anon - 17 05 10 - 01:16


> I will try some of these tricks for speeding up 3D volume separable filtering....

I don't know how big your data set or kernel is, but if they're both big enough, the FFT convolution may be a lot faster than the straightforward evaluation method used here. That's something I generally wouldn't recommend trying to write yourself. :)

> Since you mention intrinsics - have you noticed that VS almost never does loop unrolls (partial or otherwise) when SSE intrinsics are in the body of the loop? It almost seems that for loop transform purposes, VS treats intrinsics as function calls....

That's very possible, especially since intrinsics seem tacked on to the code generator. I haven't found VC++'s loop unrolling to be very useful or predictable; there are no ways to control it, and it tends to unroll loops you don't care about, like initialization loops.

By the way, loop rolling is even less attractive now, unless your loop body is trivial like a fill or copy loop. Intel's recent processors -- Pentium M through Core i7 -- have a loop buffer that can cache predecoded instructions. The loop buffer is only big enough to hold 49-64 bytes worth of code, beyond which you lose the benefit. Even the loops above exceed this limit by a significant amount.

Phaeron - 17 05 10 - 15:31


> I don't know how big your data set or kernel is, but if they're both big enough, the FFT convolution may be a lot faster than the straightforward evaluation method used here. That's something I generally wouldn't recommend trying to write yourself. :)

FFT is overkill for small kernels, and slower + more memory intensive (if you cannot compute the kernel transform on the fly). I have used FFTW in the past and would never dream of replicating it myself - I am firmly with you on that point.

I have found loop unrolling to be a very big win, but for small trivial loops with a few SSE instructions (smaller than the ones in your routine). That held valid on Nehalem despite the loop buffer (we have early Intel SDP access so we tried it long time ago). I had taught myself to trust the compiler more with optimizations, but the piss-poor intrinsic support has changed that lesson. The only good news for me is that usually very few routines need this type of optimization....

Stefan - 19 05 10 - 05:40


This problem solved in Visual C++ 2012 compiler

Dragon - 05 08 12 - 10:48

Comment form


Please keep comments on-topic for this entry. If you have unrelated comments about VirtualDub, the forum is a better place to post them.
Name:  
Remember personal info?

Email (Optional):
Your email address is only revealed to the blog owner and is not shown to the public.
URL (Optional):
Comment: /

An authentication dialog may appear when you click Post Comment. Simply type in "post" as the user and "now" as the password. I have had to do this to stop automated comment spam.



Small print: All html tags except <b> and <i> will be removed from your comment. You can make links by just typing the url or mail-address.