I should have added that although one could use much faster "block copy"
routines, or used Intvalue() instead of SingleValue() in this example. But
my example uses single operations throughout because in my current work
there need to be operations on the float values before copying.
On 16/5/07 02:21, "Daniel Stenning" <[EMAIL PROTECTED]> wrote:
> Heres a simple test I did which creates simply copies 44100 floats from one
> memoryblock to another. It does this 3000 times in order to allow timing to
> be done.
>
> I did this initially to see if there is a significant performance gain from
> using Ptr pointers to the memoryblocks to do the reads and copies, versus
> using the memoryblock SingleValue() methods.
>
> Indeed there is. Using Ptr is faster.
>
> But out of curiosity I thought I'd see how near the performance was compared
> to doing the core copy operation in C - using a dylib. So I wrote a quick
> dylib with a single function:
>
> void copySingle (int count, float * A, float * B ) {
> int i;
> for ( i = 0; i < count ; i++ ) {
> B[i] = A[i];
> }
> };
>
>
> And then via a declare called this function 3000 times. ( passing 3000 as
> the count argument )
>
> The time taken in RB using Ptr: around 45 seconds
> And in by calling the C dylib ? : 5 seconds.
>
> This is on a G4 PowerBook.
>
> I was NOT expecting that, and that 45 second timing was even after using
> pragmas to reduce overheads.
>
> I was expecting RB to be a little slower than C but not THAT much slower.
> After all - RB is supposed to be natively compiled - thus comparable to C.
>
> Here is the code for the RB version:
> ****************************************************************
>
> #pragma DisableAutoWaitCursor
> #pragma DisableBackgroundTasks
> #pragma DisableBoundsChecking
> #pragma StackOverflowChecking false
>
> Dim Count As integer = 44100 -1
> DIm iterations as integer = 3000
>
> // source buffer
> Dim A as new MemoryBlock( 44100 * 4)
>
> // stuff A with incrementing single values
> for i as integer = 0 to Count
> A.SingleValue(i*4) = i
> Next
>
> // target buffer
> Dim B as new MemoryBlock( 44100 * 4)
>
> // use pointers for speed
> dim pA As Ptr = A
> dim pB as Ptr = B
>
> Result.Text = "Started"
> app.DoEvents
>
> dim u as integer = Count * 4
> for j as integer = 0 to iterations
> for i as integer = 0 to u step 4
> pB.Single(i) = pA.Single(i)
> Next
> Next
>
> Beep
>
> Result.Text= "FINISHED"
>
> *************************************
> And here is the version that calls the C function in the dylib:
>
>
> soft Declare Sub copySingle Lib LIBPATH ( c as integer, ptA as Ptr, ptB
> as Ptr )
>
> Dim Count As integer = 44100
> DIm iterations as integer = 3000
>
> Dim A as new MemoryBlock( 44100 * 4)
>
> // stuff A with incrementing single values
> for i as integer = 0 to Count-1
> A.SingleValue(i*4) = i
> Next
>
> Dim B as new MemoryBlock( 44100 * 4)
>
> dim pA As Ptr = A
> dim pB as Ptr = B
>
> Result.Text = "Started"
> app.DoEvents
>
> dim u as integer = Count
> for j as integer = 0 to iterations
> copySingle( u, pA, pB )
> Next
>
> Beep
> Result.Text= "FINISHED"
>
>
>
> So - here is the 40 million dollar question - WHY is RB nearly 10 times
> slower than C ?
> Is this something that can and should be adressed by RS ?
>
>
> _______________________________________________
> Unsubscribe or switch delivery mode:
> <http://www.realsoftware.com/support/listmanager/>
>
> Search the archives:
> <http://support.realsoftware.com/listarchives/lists.html>
>
Regards,
Dan
_______________________________________________
Unsubscribe or switch delivery mode:
<http://www.realsoftware.com/support/listmanager/>
Search the archives:
<http://support.realsoftware.com/listarchives/lists.html>
