Test SPP

Test SPP.

Test SPP
Test Signal Processing Power.

This Stand alone Freeware is easy to use : Just click on the TEST_SPP button and wait for around one minute to get the result.

- SPP-1.
Gives the integer calculation power of your computer.

- SPP-2.
Gives the floating point calculation power of your computer.

- SPP-M
Gives the stream power, it means the number of tracks you can MIX on your computer.

DOWNLOAD TEST_SPP
(83Ko ZIP file 13-Mar-2001).

TEST_SPP program tests the PC power in real audio processing situation. The process is made by frames of 512 samples (like it can be in a real time audio stream) and is done according to the classical audio processing algorithms. So TEST_SPP gives you a good (but pessimist) idea of the power that you could expect from your PC when using Audio applications.

SPP cycle Definition :
the SPP cycle includes 2 MOV, 2MUL and 1 ADD and is according to the computation of one cell IIR first order. For example it means that one parametric EQ cell needs around 2 SPP cycles. According to this definition you will be able to compare easily your PC power to other processor type.

To emulate the Real time processing, the programming has been made as it is shown below : by frames of 512 samples (buffers contains 50.000 samples).

QueryPerformanceCounter((LARGE_INTEGER*)&mstime_1);
while(test_in == TRUE)
{
   __ProcessFrameSPP2(&fx_obj,512);
   cyclecount++;
   Sleep(0);
}
QueryPerformanceCounter((LARGE_INTEGER*)&mstime_2);
//and of course ---------
cyclecount=cyclecount*512;

The processing function is written as a classical external processing function, by getting param in the local stack and parallelizing CPU operations and FPU operations when it is possible (here for managing circular buffers)
the assembler part between cycle_again: label and jnz cycle_again is that we call the SPP cycle

void __ProcessFrameSPP2(LPT_SPP2_CONTEXT lpfx , DWORD nbSample)
{
   float * lp_Sin;
   float * lp_Sout;
   float local_coeff_1;
   float local_coeff_2;
   float local_yy_z1;
   float * lp_in_start,* lp_in_end;
   float * lp_out_start,* lp_out_end;
   //Get param in local
   local_coeff_1 =lpfx->coeff_1;
   local_coeff_2 =lpfx->coeff_2;
   local_yy_z1   =lpfx->yy_z1;
   lp_in_end     =lpfx->lp_in_end;
   lp_out_end    =lpfx->lp_out_end;
   lp_in_start   =lpfx->lp_in_start;
   lp_out_start  =lpfx->lp_out_start;
   lp_Sin        =lpfx->lp_Sin;
   lp_Sout       =lpfx->lp_Sout;
   //----------------------------------
   __asm
   {
      push esi
      push edi
      push ebx
      mov esi,DWORD PTR lp_Sin
      mov edi,DWORD PTR lp_Sout
      mov ebx,DWORD PTR lp_in_end
      mov edx,DWORD PTR lp_out_end
      //----------------------------
      mov ecx,nbSample


cycle_again:
         fld DWORD PTR [esi]
         fld DWORD PTR local_yy_z1
      add esi,0x00000004
         fmul DWORD PTR local_coeff_1
      cmp esi,ebx
      jne SHORT circular_1_continue
      mov esi, DWORD PTR lp_in_start
circular_1_continue:
         fadd
      mov eax,edi
         fst DWORD PTR local_yy_z1			
      add eax,0x00000004
         fmul DWORD PTR local_coeff_2
      cmp eax,edx
      jne SHORT circular_2_continue
      mov eax,DWORD PTR lp_out_start
circular_2_continue:
         fstp DWORD PTR [edi]
      mov edi,eax
      dec ecx
      jnz cycle_again


      //----------------------------
      mov DWORD PTR lp_Sin,esi
      mov DWORD PTR lp_Sout,edi
		
      pop ebx
      pop edi
      pop esi
   }
   //re-set param according to new locals
   lpfx->yy_z1=local_yy_z1;
   lpfx->lp_Sin=lp_Sin;
   lpfx->lp_Sout=lp_Sout;
}

SPP-M cycle Definition :
The SPP-M cycle describes the MIX power of your computer. The measure is made in the same way than the SPP cycle. A 64 tracks virtual console is set before mixing all these tracks 512 samples per 512 samples in a master BUS according to a gain for each track (around 6.5Mfloat are allocated to avoid cache processing). The mix is made track by track by calling a process function for each track (which add next track multiplied by a gain to the output BUS).

Measure examples :
! Attention ! the result of the measure is depending on your OS, your config, the mother board, the BUS clock and all the devices and drivers installed on your PC.
TEST_SPP does not measure the pure CPU power, but the real CPU resource available in a real situation when using your Audio Application.

*Intel PIII 450()**
SPP-1 mono 44100Hz	447 SPP/smp
SPP-2 mono 44100Hz	552 SPP/smp
SPP-M mono 44100Hz	895 tracks
Transfer rate	75 Mf

(*) PIII 450 WIN98 + a lot of devices. You can get much better measure on an other PIII 450.

*Intel Pentium 200()**
SPP-1 mono 44100Hz	123 SPP/smp
SPP-2 mono 44100Hz	170 SPP/smp
SPP-M mono 44100Hz	254 tracks
Transfer rate	21 Mf

(*) P200 WIN95 + a lot of devices. You can get much better measure on an other P200.

Intel Pentium 120 Win NT4
SPP-1 mono 44100Hz	85 SPP/smp
SPP-2 mono 44100Hz	122 SPP/smp
SPP-M mono 44100Hz	163 tracks
Transfer rate	13 Mf

It's recommanded to do several measures, for example just when starting you PC, and one hour after using it. The variation can be important. Also be sure that your PC does not access disk while testing, or make 2 or 3 time the test to check that there is no significant variation (< 5%) between two measures.

Reading transfer rate
The transfer rate gives the number of float (samples of the sound) moved per second in this mixing process (not the memory BUS rate). The number of track is high because the sound is in memory, not on the Hard Disk. Also to mix one track needs around 0.5 SPP cycle, so you should get around 2 times the SPP-2 measure if the BUS does not bound the processing.

Recommandation and conclusion
Of course, some special programming optimizations are possible to do (depends on the algorithm and the effect type) and can accelerate the processing (or also by using MMX or by reducing the number of processing functions - not really possible in a plug-in architecture software-). But according to my knowledge and experience, the measure done by this small software (TEST_SPP) seems to represent pretty well the abilities of a PC in Digital Audio Processing, and in a realistic way.