C++ array vs C# array Speed Difference

Question

I have been converting my C++ to C# and have finished my table lookup code.  The C++ and C# code are nearly identical.  I wrote a test driver to determine execution speed and the C# version is 2X slower than the C++ code.  There are a few multiplies, additions, etc. but the majority of the code is accessing arrays.  I am using the standard array declaration of a float.

 

namespace Gains

{

public partial class APGains

{

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

// Fields.

public static float[] arrayKr = new float[6480]

{

1.14730e+000F, 1.06686e+000F, 9.60222e-001F,

9.81282e-001F, 1.05044e+000F, 1.08314e+000F,

9.64222e-001F, 1.04591e+000F, 1.21867e+000F,

...

 

 

I am assuming (and may be wrong) that the speed hit is the C# is performing bounds test on the array access where the C++ code is not. Is there a way too turn it off to get the speed back?

Answer 1

show us your test app...



2X is an exesive value... as well the bounds test is maded only when asign values not when 'query' values...

Answer 2

Without the looping code, we can't tell where there might be any bottle necks.  Are you using foreach, for, while, etc?

 

Answer 3

Keep in mind that the 'array' construct in C# does not have the same implementation under the covers as it does in C++.

As you know, in C++, an array is literally an array of memory addresses.  The compiler calculates the memory address of each item in the array based on the type.  Thus, an array is a contiguous block of memory inside your program (be it the heap or the stack, depending on how you instantiate the array).


In C#, this is not the case.  There is no contract in the CLR that guarantees that each item in an array will be stored contiguously in memory.  It MAY happen that way, but that is merely incidental to the operation of an array in C#.  This is part of the reason why every single array index access is bounds checked.  The other reason is that for every single array operation, the CLR is translating the operation from what your .NET language says into a real array operation in native code.

Your C++ code doesn't have to do all that.  Arrays in C# will never - CAN never - be as fast as they are in native code.  The platform simply isn't built for it.

If you really need pedal-to-the-metal speed for your code, the best thing to do is write an unmanaged DLL in C that has exports for functions you need to use (you can use a C wrapper around your C++ objects, if you like; this is a fairly straightforward operation).  You then simply P/Invoke these functions into a managed C# wrapper.

We do this with great regularity in our code.  Much of what we do is scientific research and C#, while a fantastic platform for building our presentation layer, is a terrible tool for building our scientific code that really needs burn-it-up speed.  So we simply write our speed dependent stuff in C or C++ and then write a C# wrapper that we use in our managed code.

Answer 4

Here is the most offending section of code.  The C++ and C# are almost identical.  I did a speed difference on this section and it is 100X slower in C#.

 

weightArray is a float array of length twoPowerDimension

indexArray is an int array of length twoPowerDimension

 

Code Block

C#

 

kp = table5D.LookUp(APGains.arrayKp);

...

 

public float LookUp(float[] array)

{

  float value = 0;

 

  for (int index = 0; index < twoPowerDimension; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

 

  return value;

}

 

 

Code Block

C++

 

public float LookUp(const float* array)

{

  float value = 0;

 

  for (int index = 0; index < twoPowerDimension; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

 

  return value;

}

 

 

Answer 5

I've tried some experimenting with that code, and on my system the C++ code is a staggering TWENTY-EIGHT THOUSAND TIMES FASTER!

Even with the best-optimized version of the C# code I can come up with, the C++ code is still EIGHTEEN THOUSAND times faster.

That's such a huge discrepency, I feel sure I must be doing something wrong - but I can't see what it is!

If someone else can reproduce these results, then I'm going to be DEEPLY worried about using C# for any non-trivial arithmetic!

I'll post the different test programs in the next few messages, because they are quite long.

However, I will summarize the results here:

Test System

C#: Visual Studio 2005 (C#2.x) and 2008 (C# 3.5) tested with similar results.
C++: Visual Studio 2005 tested.
OS = Vista Ultimate.
Memory = 2GB
Processor = Core 2 Duo, 2.4GHz.
C++ and C# test programs are both release builds, and run several times from the command-line.

Output from C++ Test Program:

Elapsed time = 0.000859 (result = 24776425472.000000)

Output from C# Test Program:

LookUp1() - Elapsed time = 00:00:30.7864371 (result = 24776430000.00)
LookUp2() - Elapsed time = 00:00:16.1561813 (result = 24776430000.00)

Result

The BEST speed from C# is EIGHTEEN THOUSAND TIMES slower than C++...

As I said, this result is so horrific that I *MUST* be doing something wrong. Hopefully someone can point out my error and set my mind at rest!

Answer 6

C++ Test Program

Code Block

#include "stdafx.h"

#include <windows.h>

const int twoPowerDimension = 100000;

static float* weightArray = new float[twoPowerDimension];
static int* indexArray = new int[twoPowerDimension];

float LookUp(const float* array)
{
    float value = 0;

    for (int index = 0; index < twoPowerDimension; index++)
    {
        value += weightArray[index] * array[indexArray[index]];
    }

    return value;
}

int _tmain(int argc, _TCHAR* argv[])
{
    float array[100];

    for (int i = 0; i < twoPowerDimension; ++i)
    {
        indexArray[i] = i %100;
        weightArray[i] = (float)(i / 10000.0);
    }

    for (int i = 0; i < 100; ++i)
    {
        array[i] = i/(float)100.0;
    }

    PrecisionTimer timer;
    timer.start();
    float result = 0;

    for (int i = 0; i < 100000;  ++i)
    {
        result += LookUp(array);
    }

    timer.stop();

    printf("Elapsed time = %lf (result = %lf)\n", timer.elapsed(), result);
}

Answer 7

C++ Source for PrecisionTimer class:

Code Block

class PrecisionTimer    // Use this for precision timing.
{
  public:

    PrecisionTimer();

    void start();
    void stop();

    double elapsed() const ;   // Elapsed time, in seconds (NOT ms). stop() must be called first.
    double current() const ;   // Elapsed time in seconds, does not need stop() to be called first.

  private:

    _int64 clock_freq ;
    _int64 start_time ;
    _int64 stop_time  ;
};

PrecisionTimer::PrecisionTimer()
{
    LARGE_INTEGER i ;
    QueryPerformanceFrequency( &i );
    clock_freq = i.QuadPart ;
    start_time = stop_time = 0 ;
}

void PrecisionTimer::start()
{
    LARGE_INTEGER i ;
    QueryPerformanceCounter( &i );
    start_time = i.QuadPart ;
}

void PrecisionTimer::stop()
{
    LARGE_INTEGER i ;
    QueryPerformanceCounter( &i );
    stop_time = i.QuadPart ;
}

double PrecisionTimer::elapsed() const
{
    return ( stop_time - start_time ) / static_cast<double>( clock_freq );
}

double PrecisionTimer::current() const
{
    LARGE_INTEGER i ;
    QueryPerformanceCounter( &i );
    return ( i.QuadPart - start_time ) / static_cast<double>( clock_freq );
}

Answer 8

C# Test Program

Code Block

class Program
{
    static void Main()
    {
        float[] array = new float[100];

        for (int i = 0; i < twoPowerDimension; ++i)
        {
            indexArray[i] = i % 100;
            weightArray[i] = (float)(i / 10000.0);
        }

        for (int i = 0; i < 100; ++i)
        {
            array[i] = i/100f;
        }

        Stopwatch timer = new Stopwatch();
        float result = 0;

        timer.Start();

        for (int i = 0; i < 100000; ++i)
        {
            result += LookUp1(array);
        }

        timer.Stop();
        Console.WriteLine("LookUp1() - Elapsed time = {0} (result = {1:f})", timer.Elapsed, result);

        result = 0;
        timer.Reset();
        timer.Start();

        unsafe  // Fastest way I could find in C#.
        {
            fixed (float* pArray = array)
            fixed (float* pWeightArray = weightArray)
            fixed (int* pIndexArray = indexArray)
            {
                for (int i = 0; i < 100000; ++i)
                {
                    result += LookUp2(pArray, pWeightArray, pIndexArray);
                }
            }
        }

        timer.Stop();
        Console.WriteLine("LookUp2() - Elapsed time = {0} (result = {1:f})", timer.Elapsed, result);
    }

    public static float LookUp1(float[] array)
    {
        float value = 0;

        for (int index = 0; index < twoPowerDimension; index++)
        {
            value += weightArray[index] * array[indexArray[index]];
        }

        return value;
    }

    unsafe public static float LookUp2(float* pArray, float* pWeightArray, int* pIndexArray)
    {
        float value = 0;

        unchecked
        {
            for (int index = 0; index < twoPowerDimension; index++)
            {
                int i = pIndexArray[index];
                float f1 = pWeightArray[index];
                float f2 = pArray[i];

                value += f1 * f2;
            }
        }

        return value;
    }

    const int twoPowerDimension = 100000;

    static float[] weightArray = new float[twoPowerDimension];
    static int[] indexArray = new int[twoPowerDimension];
}

Answer 9

Are your times including the JIT compile of the code?  i.e. did you do a dummy run (outside the debugger in release mode) before gathering the metrics?

 

Answer 10

I ran it a few times from a command prompt, with no real variation in time from the first run.
It's a release build - I forgot to mention that in my original message (I'll go edit it).

It takes 30 seconds to run the first c# test, and 15 seconds for the second, so I would expect any JIT time to be completely dwarfed by that anyway.

Answer 11

it is extrange...

at this tikme i have done about 10 diffrerent versions based on Matthew Watson C# code and i obtain similar results running the release version under command prompt and it is extremely slow...
this is one of my last versions...

Code Block

using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace Comparison
{
    unsafe class Program
    {
        const int twoPowerDimension = 100000;
        static float value = 0;
        static int index = 0;
        public static float *weightArray_g;
        public static int *indexArray_g;
        public static float* array_g;

        unsafe static void Main()
        {
            float *weightArray= stackalloc float[twoPowerDimension];
            int *indexArray = stackalloc int[twoPowerDimension];
            float* array = stackalloc float[100];

            weightArray_g =weightArray;
            indexArray_g = indexArray;
            array_g = array;

            for (int i = 0; i < twoPowerDimension; ++i)
            {
                unchecked
                {
                    indexArray[i] = i % 100;
                    weightArray[i] = i / 10000.0f;
                }
            }

            for (int i = 0; i < 100; ++i)
            {
                unchecked
                {
                    array[i] = i / 100f;
                }
            }

            Console.WriteLine("Inicio");
            Stopwatch timer = new Stopwatch();
            float result = 0;

            timer.Start();

            unchecked
            {
                for (int i = 0; i < 100000; ++i)
                {
                    result += LookUp2();
                }
            }
            

            timer.Stop();
            Console.WriteLine("LookUp2() - Elapsed time = {0} (result = {1:f})", timer.Elapsed, result);
        }
        
        unsafe public static float LookUp2()
        {
            unchecked
            {
                for ( index= 0; index < twoPowerDimension; index++)
                    value += weightArray_g[index] * array_g[indexArray_g[index]];
            }

            return value;
        }
    }
}

What are happening here?...

on other hand i made a variant without functions to aovid context changes but obtain the same results...

Answer 12

Some things to keep in mind:

 

This:

Code Block
            int[] arry = new int[20000];
            for (int index = 0; index < arry.Length; ++index)
            {
                total += arry[index];
            }
 
 

 

is ~20% faster than this:

Code Block
            int[] arry = new int[20000];
            for (int index = 0; index < 20000; ++index)
            {
                total += arry[index];
            }
 
 

...because the framework can more efficiently deal with bounds checking.

 

Also, this:

Code Block
            int[] arry = new int[20000];
            foreach (int element in arry)
            {
                total += element;
            }
 
 

...takes about half as much time as the first because there is no bounds checking (see Effective C# by Bill Wagner and http://mark.michaelis.net/Blog/TheInternalsOfForeach.aspx).

 

Other references: http://msdn.microsoft.com/msdnmag/issues/02/02/NET/ (getting a bit old)

http://nazish.blog.com/1023722/

etc...

Answer 13

The best way to make a powerful framework perform poorly is to ask it to do almost nothing. 

 

If this is a performance critical portion of your application then you should probably drop down into an unsafe context, pin the array references then perform the calculations from within the unsafe context.  E.g.,

 

Code Block

      unsafe public static double LookUp2(float[] arr1)
      {
         fixed (float* pArr1 = arr1, pArr2 = arr2)
         {
            double value = 0;

            long start, stop, freq, overhead;
           
            QueryPerformanceFrequency(out freq);

            QueryPerformanceCounter(out start);
            QueryPerformanceCounter(out stop);

            overhead = stop - start;

 

            QueryPerformanceCounter(out start);

            for (int index = 0; index < size; index++)
            {
               value += pArr2[index] * pArr1[index];
            }

            QueryPerformanceCounter(out stop);

 

            Console.WriteLine("LookUp2() call took {0:f10} seconds (overhead={1})",
               (stop - start - overhead)/((double)freq),
               overhead);

            return value;
         }
      }

 

 

On my machine the C# version runs in ~0.00005 seconds while the C++ version runs in about 0.000005 seconds.

 

An excellent series of posts about performance and C# vs C++ can be found here.

Answer 14

@Peter:

That's all very true - and the version with pointers (which of course does no array bounds checking) is twice as fast as the slowest implementation.

However, even the pointer version is more than 18,000 times slower than the C++ version.

Answer 15

Arnshea Clayton wrote:

If this is a performance critical portion of your application then you should probably drop down into an unsafe context, pin the array references then perform the calculations from within the unsafe context.

I think you must have missed the code that I posted where I did just that. It's still 18,000 times slower in C# compared to C++.

Answer 16

Matthew Watson wrote:

Arnshea Clayton wrote:   If this is a performance critical portion of your application then you should probably drop down into an unsafe context, pin the array references then perform the calculations from within the unsafe context. I think you must have missed the code that I posted where I did just that. It's still 18,000 times slower in C# compared to C++.

yes and i obtain similar results with sligth modifications...

Answer 17

Matthew Watson wrote:

Arnshea Clayton wrote:   If this is a performance critical portion of your application then you should probably drop down into an unsafe context, pin the array references then perform the calculations from within the unsafe context. I think you must have missed the code that I posted where I did just that. It's still 18,000 times slower in C# compared to C++.

 

I'm seeing much smaller differences with an inline comparison.  On my machine the C# version runs in .00005 seconds, the C++ version runs in .000005 seconds.

Answer 18

Matthew Watson wrote:

@Peter: That's all very true - and the version with pointers (which of course does no array bounds checking) is twice as fast as the slowest implementation. However, even the pointer version is more than 18,000 times slower than the C++ version.

18,000?  So, if the c++ took 100ms, the C# took 30 minutes?

Answer 19

My tests show the C++ pointer loop to be on par with the for/Length loop.  Iterating a 20,000,000 float array and reading each element in C++ took 78 ticks.  The for loop testing the Length property of a float array took 79 ticks.  The for loop testing a constant took 93 ticks and the foreach with the constant took 391 ticks.  Nowhere need 18,000 times slower, but does contradict the foreach recommendation, at least for arrays of intrinsics.

 

C++ loop:

Code Block
    for(int i = 0; i < (sizeof(arry) / sizeof(arry[0])); ++i)
    {
        result += arry[i];
    }
 
 

 

C# loops:

Code Block
            foreach (int element in arry)
            {
                total += element;
            }
//...
            for (int index = 0; index < arry.Length; ++index)
            {
                total += arry[index];
            }
//...
            for (int index = 0; index < COUNT; ++index)
            {
                total += arry[index];
            }
 
 

arrays were pre-initialized with values from 1 to x;

Answer 20

Wow, this stirred up quite an interest.  Thanks everyone for verifying the computational speed differences.  I was just completely surprised by the difference in C++ and C#.

 

To answer a previous poster's question, yes this piece of code is very time critical.  I will need to find an acceptable work around.

Answer 21

I got a 10% increase in speed going from

 

Code Block

  for (int index = 0; index < twoPowerDimension; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

 

 

to

 

Code Block

  for (int index = 0; index < weightArray.Length; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

 

 

I have not been able to determine how I can get the foreach statement to work for this loop.

Answer 22

 

i'm sad... very sad about that,,,,

 

could some IL guru or MSFT guru helpus to bring an explanation to this ugly thing?

 

i undestand the obviously overhead caused by the CLR features, i don't expect C# to be more or equals fast as C++ , but this amounts of time are really ridiculuos. don't you think?

 

 

somthing strange ....

 

which compilers are useing everibody here? have somebody tryed with the mono compilers or something like that to bring us a best idea of situation?

Answer 23

Peter Ritchie wrote:

Matthew Watson wrote: @Peter: That's all very true - and the version with pointers (which of course does no array bounds checking) is twice as fast as the slowest implementation. However, even the pointer version is more than 18,000 times slower than the C++ version. 18,000?  So, if the c++ took 100ms, the C# took 30 minutes?

You might have missed where I posted the timings I obtained. Here is a copy and paste of the pertinant information:

Output from C++ Test Program:

Elapsed time = 0.000859 (result = 24776425472.000000)

Output from C# Test Program:

LookUp1() - Elapsed time = 00:00:30.7864371 (result = 24776430000.00)
LookUp2() - Elapsed time = 00:00:16.1561813 (result = 24776430000.00)


So the simple calculation is (approximated): 16 / 0.0009 = 17,777

Answer 24

Arnshea Clayton wrote:

Matthew Watson wrote:  Arnshea Clayton wrote:   If this is a performance critical portion of your application then you should probably drop down into an unsafe context, pin the array references then perform the calculations from within the unsafe context. I think you must have missed the code that I posted where I did just that. It's still 18,000 times slower in C# compared to C++.   I'm seeing much smaller differences with an inline comparison.  On my machine the C# version runs in .00005 seconds, the C++ version runs in .000005 seconds.

Which raises the question - where is the actual slowdown occuring, if the problem does not lie there? We still have a program that executes thousands of times slower in C#, and the question is: Why?

Answer 25

Peter Ritchie wrote:

My tests show the C++ pointer loop to be on par with the for/Length loop.  Iterating a 20,000,000 float array and reading each element in C++ took 78 ticks.  The for loop testing the Length property of a float array took 79 ticks.  The for loop testing a constant took 93 ticks and the foreach with the constant took 391 ticks.  Nowhere need 18,000 times slower, but does contradict the foreach recommendation, at least for arrays of intrinsics.

That's interesting! But it doesn't really answer the question about why the C# code is so much slower than the C++ code in the sample programs that I posted... Where is the overhead coming from?

Answer 26

Juan Carlos Ruiz Pacheco wrote:

which compilers are useing everibody here? have somebody tryed with the mono compilers or something like that to bring us a best idea of situation?

 

Visual Studio .NET 2005

Answer 27

The C# compiler treats

Code Snippet

for (int index = 0; index < weightArray.Length; index++)

 

 

as a special case, and omits the range-checking (since it knows it will be inbounds).  However, even writing it as:

 

Code Snippet

int len = weightArray.Length;

for (int index = 0; index < len; index++)

 

 

 

Will fool it, and the bounds checking is back.

Answer 28

Matthew Watson wrote:

That's interesting! But it doesn't really answer the question about why the C# code is so much slower than the C++ code in the sample programs that I posted... Where is the overhead coming from?

 

Based on running this in the CLRProfiler, it looks like the naive implementation in C# incurs some overhead due to SecurityPermissions.  Dropping down to unsafe/fixed seems to remove that overhead.  Without the overhead the performance difference factor is ~3 (for release build).

 

Based on the debug build disassembly (below), I'd expect (and observed) similar performance.  The meat of the loop, the array access and multiplication, disassemble almost identically.

 

The addresses in the C# disassembly are psuedomemory addresses (start of app's memory space is location zero) which may account for the slight performance difference.  Also, the C++ compiler is more mature than the C# compiler so the release build may produce somewhat more optimized code.

 

C# post-jit disassembly:

    for (int index = 0; index < size; index++)
000000b6  mov         dword ptr [ebp-40h],0
000000bd  nop              // unnecessary instruction as far as i can tell
000000be  jmp         000000DB
     value += (*pArr2++) * (*pArr1++);
000000c0  mov         edi,dword ptr [ebp-3Ch] // body of loop starts here
000000c3  add         dword ptr [ebp-3Ch],4
000000c7  mov         esi,dword ptr [ebp-38h]
000000ca  add         dword ptr [ebp-38h],4
000000ce  fld         dword ptr [edi]
000000d0  fmul        dword ptr [esi]
000000d2  fadd        qword ptr [ebp-14h]
000000d5  fstp        qword ptr [ebp-14h]  // updates value of value, body of loop ends here
    for (int index = 0; index < size; index++)
000000d8  inc         dword ptr [ebp-40h]
000000db  mov         eax,dword ptr [ebp-40h]
000000de  cmp         eax,dword ptr ds:[00A15198h]
000000e4  jl          000000C0 // repeat the loop as long as index < size

 

C++ disassembly:

  for (int index = 0; index < arrLen; index++)
00414052  mov         dword ptr [index],0
00414059  jmp         Class1::LookUp+64h (414064h)
0041405B  mov         eax,dword ptr [index]
0041405E  add         eax,1
00414061  mov         dword ptr [index],eax
00414064  mov         eax,dword ptr [this]  
00414067  mov         ecx,dword ptr [index]
0041406A  cmp         ecx,dword ptr [eax+8]  // compare index to arrLen
0041406D  jge         Class1::LookUp+8Ch (41408Ch) // exit loop if index >= arrLen
  {
   value += arr2[index] * array[index];
0041406F  mov         eax,dword ptr [this] // body of loop starts here
00414072  mov         ecx,dword ptr [eax+4]
00414075  mov         edx,dword ptr [index]
00414078  mov         eax,dword ptr [index]
0041407B  mov         esi,dword ptr [array]
0041407E  fld         dword ptr [ecx+edx*4]
00414081  fmul        dword ptr [esi+eax*4]
00414084  fadd        qword ptr [value]
00414087  fstp        qword ptr [value] // body of loop ends here
  }
0041408A  jmp         Class1::LookUp+5Bh (41405Bh)

 

 

Answer 29

thanks for your help...

but i don't have a big stuff using assembly...

so

can you tell me where is the big bottleneck? because C# code is  thousands of times more slower than C++ code. (and it is non an exagaration).

Answer 30

I reading some of the quotes on the speed difference.  I was getting alot less drastic differences until tonight.

 

At work, I am running Windows XP 64 bit with 2 dual core processors (4 cores) with 8 GB of memory.  My application to test my table lookups showed around a 2X hit in speed form C++ for this section of the test code.

 

Code Snippet

public float LookUp(float[] array)

{

  float value = 0;

 

  for (int index = 0; index < weightArray.Length; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

 

  return value;

}

 

 

If I make an application that justs test that section and does nothing else, there is a 100X hit in speed from C++ but that is another issue.

 

Tonight, I want to show some difference in speed depending on what part of the code was executing.  I was doing this tonight on my home computer which is running Windows XP 32 bit with dual P4 processors and 3 GB of memory.  For the section of code above, I get a 400X hit in speed where on my work computer it is only 2X.

 

I will try this tomorrow on my work computer again to see if I get the same results but this is very concerning.

 

The test code I use has several files.  Is there a place to make the files accessable to forum members?

Answer 31

Conrarn, what results do you get with the code I posted?

I'm very concerned that at least two of us are getting results with that code where it is running tens of thousands of times too slowly - which certainly seems to point to a big problem somewhere...

I'm going to try running the sample programs on some other machines here at work to see if I get similar results. I'll report back later.

Answer 32

Arnshea Clayton wrote:

Matthew Watson wrote: That's interesting! But it doesn't really answer the question about why the C# code is so much slower than the C++ code in the sample programs that I posted... Where is the overhead coming from?   Based on running this in the CLRProfiler, it looks like the naive implementation in C# incurs some overhead due to SecurityPermissions.  Dropping down to unsafe/fixed seems to remove that overhead.  Without the overhead the performance difference factor is ~3 (for release build). <SNIP>

What results do you get with the exact program that I posted? It would be interesting if you could run that, and post the output that you get from that.

As you will have observed, the second loop in my C# test program DOES use unsafe code, yet it it still tens of thousands of times slower than the C++ code on my test machine. I'd be really interested in seeing the exact results that someone else gets.

Answer 33

conrarn wrote:

I reading some of the quotes on the speed difference.  I was getting alot less drastic differences until tonight.

Did you try the exact same C# code as I posted? If so, what was the exact output of the the program? If not, could you give it a try please? I'm concerned that we have a problem of some kind here.

Answer 34

Matthew Watson wrote:

I'm going to try running the sample programs on some other machines here at work to see if I get similar results. I'll report back later.

Well I've now tried it on several different computers, some Vista, some XP, some with a .Net 3.5 version of the test program, some with a .Net 2.0 version. I'm getting similar results on all of them - none of them run the second loop faster than 15 seconds or so.

Answer 35

Got the code for the C# Stopwatch class?

 

Answer 36

It's part of the standard .NET libraries:

System.Diagnostics.Stopwatch


I missed the "Using" statements out of my sample code; they looked like this:

using System;
using System.Diagnostics;

Answer 37

Matthew Watson wrote:

Peter Ritchie wrote: My tests show the C++ pointer loop to be on par with the for/Length loop.  Iterating a 20,000,000 float array and reading each element in C++ took 78 ticks.  The for loop testing the Length property of a float array took 79 ticks.  The for loop testing a constant took 93 ticks and the foreach with the constant took 391 ticks.  Nowhere need 18,000 times slower, but does contradict the foreach recommendation, at least for arrays of intrinsics. That's interesting! But it doesn't really answer the question about why the C# code is so much slower than the C++ code in the sample programs that I posted... Where is the overhead coming from?

Well, it answers the question that it's not looping that is causing the slow-down, it's the work done in the loop that's causing the differences.  For example, in your Lookup1 and Lookup2, if you take out the second lookup (and change the multiply of the two value to simply a square--x*x) Lookup1 and Lookup2 have near identical run times.

Answer 38

Matthew Watson wrote:

It's part of the standard .NET libraries: System.Diagnostics.Stopwatch I missed the "Using" statements out of my sample code; they looked like this: using System; using System.Diagnostics;

 

First the C++ code isn't linear in time until you increase the number of interations.  Regardless, I left the code the way you wrote it.

 

C:\Work\Watson>CSharp
LookUp1() - Elapsed time = 00:00:23.7707652 (result = 24776430000.00)
LookUp2() - Elapsed time = 00:00:24.1897559 (result = 24776430000.00)

 

C:\Work\Watson>CPP
Elapsed time = 0.000906 (result = 24776425472.000000)

Answer 39

Peter Ritchie wrote:

Well, it answers the question that it's not looping that is causing the slow-down, it's the work done in the loop that's causing the differences.  For example, in your Lookup1 and Lookup2, if you take out the second lookup (and change the multiply of the two value to simply a square--x*x) Lookup1 and Lookup2 have near identical run times.

I'm also finding that both LookUp1 and LookUp2 are have been jitted to the same MethodTable entry--which means they're running the same code.  That also means the body of LookUp1 and LookUp2 isn't what is causing the time differences.  I have to assume the difference is in the way LookUp1 and LookUp2 are called is causing the time difference.

Answer 40

You guys are all chasing a red herring.

 

The C++ code only makes the call once in release mode.  The optimizer is smart enough to recognize the value as a mathematical function that treats the array as read-only and so returns the same value for each pass of the loop.  The compiler then iterates adding the value over and over again, instead of making the call.

 

Here's the disassembly:

 

00401196 fldz

for (int i = 0; i < 100000; ++i)

{

result += LookUp(array);

00401198 lea edx,[esp+30h]

0040119C fstp dword ptr [esp+14h]

004011A0 call LookUp (401000h)

004011A5 fstp dword ptr [esp+20h]

004011A9 fld dword ptr [esp+20h]

004011AD mov eax,186A0h

004011B2 sub eax,1

004011B5 fld st(0)

004011B7 fadd dword ptr [esp+14h]

004011BB fstp dword ptr [esp+14h]

004011BF jne wmain+0B2h (4011B2h)

}

 

if you step through the code in the debugger, you'll see that the loop is going from 004011B2 to 004011BF, which have no calls to the function.  The only call is on 004011A0, which is performed "outside" the loop.

 

All the loop does is:

SUB EAX, 1

FLD ST(0) (make a copy of the top of stack)

FADD DWORD PTR [ESP+14h] (add a copy of the local variable at +14h (this is 'result'))

FSTP DWORD PTR [ESP+14h] (save the result to the local variable)

JNE WMAIN+0B2h (jump if the SUB EAX didn't end up with zero).

 

Basically, if you want to think about the code it actually runs, it would look something like:

 

float save = LookUp(array);

float result = 0;

int cnt = 100000;

do

{

  cnt--;

  result += save;

} while(cnt > 0);

 

or something like that.

Answer 41

Kelly Leahy (Milliman) wrote:

You guys are all chasing a red herring.   The C++ code only makes the call once in release mode.  The optimizer is smart enough to recognize the value as a mathematical function that treats the array as read-only and so returns the same value for each pass of the loop.  The compiler then iterates adding the value over and over again, instead of making the call.   Here's the disassembly:   00401196 fldz for (int i = 0; i < 100000; ++i) { result += LookUp(array); 00401198 lea edx,[esp+30h] 0040119C fstp dword ptr [esp+14h] 004011A0 call LookUp (401000h) 004011A5 fstp dword ptr [esp+20h] 004011A9 fld dword ptr [esp+20h] 004011AD mov eax,186A0h 004011B2 sub eax,1 004011B5 fld st(0) 004011B7 fadd dword ptr [esp+14h] 004011BB fstp dword ptr [esp+14h] 004011BF jne wmain+0B2h (4011B2h) }   if you step through the code in the debugger, you'll see that the loop is going from 004011B2 to 004011BF, which have no calls to the function.  The only call is on 004011A0, which is performed "outside" the loop.   All the loop does is: SUB EAX, 1 FLD ST(0) (make a copy of the top of stack) FADD DWORD PTR [ESP+14h] (add a copy of the local variable at +14h (this is 'result')) FSTP DWORD PTR [ESP+14h] (save the result to the local variable) JNE WMAIN+0B2h (jump if the SUB EAX didn't end up with zero).   Basically, if you want to think about the code it actually runs, it would look something like:   float save = LookUp(array); float result = 0; int cnt = 100000; do {   cnt--;   result += save; } while(cnt > 0);   or something like that.

I haven't confirmed; but: yuck.  the compiler should never make that optimimization; LookUp isn't declared const so it should assume it does modify the state of the object and thus call it every time through the loop.

Answer 42

I have tested the speed on my C++ and C# programs.  I have completed testing how much time is required for each section.  The sections are A, B, C, and D.  Section D is the part of the code that started the initial forum question.  Section B is not like Section D.

 

Code Snippet

// Section D code

 

public float LookUp(float[] array)

{

  float value = 0;

 

  for (int index = 0; index < weightArray.Length; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

 

  return value;

}

 

 

 

Here are the results (seconds).  There definately is a problem in section D.

 

	C#	C++
A	0.59	0.28	52.20%
B	8.94	8.47	5.28%
C	10.06	6.99	30.52%
D	10.14	0.01	99.90%

 

Code Snippet

for (int index = 0; index < arrayTestRatio.Length; index++)

{

  // Section A

  ratio      = arrayTestRatio     [index];

  altitude   = arrayTestAltitude  [index];

  mach       = arrayTestMach      [index];

  alphaRatio = arrayTestAlphaRatio[index];

  betaMRatio = arrayTestBetaMRatio[index];

 

  // Section B

  tableIRatio     .LookUp(ratio     );

  tableIAltitude  .LookUp(altitude  );

  tableIMach      .LookUp(mach      );

  tableIAlphaRatio.LookUp(alphaRatio);

  tableIBetaMRatio.LookUp(betaMRatio);

 

  // Section C

  table5D.ComputeAccess();

 

  // Section D

  kp = table5D.LookUp(APGains.arrayKp);

  kq = table5D.LookUp(APGains.arrayKq);

  kr = table5D.LookUp(APGains.arrayKr);

}

 

 

Answer 43

After looking at Watson's test program, we need to change it because as Kelly stated, it is not testing what it should be testing.

 

As noted in my previous code (Section C), the weightArray and indexArray are changing every time LookUp is called (as well as the input array).

 

 

Answer 44

Yes, as soon as you change the C++ LookUp function to be different from invocation to invocation (like add a dummy parameter that  is passed from main as i but isn't used in LookUp) the C++ times jump up dramatically.

 

My non-scientific test with Matthew's code showed the unsafe C# to run at 00:00:20.7524139 , the C++ to run at:00:00:45.1971339 and the safe C# to run at:00:00:15.9656810.  Both C# implementations run faster than C++ in release mode...

Answer 45

Kelly Leahy (Milliman) wrote:

The C++ code only makes the call once in release mode.  The optimizer is smart enough to recognize the value as a mathematical function that treats the array as read-only and so returns the same value for each pass of the loop.  The compiler then iterates adding the value over and over again, instead of making the call.   Here's the disassembly:   00401196 fldz for (int i = 0; i < 100000; ++i) { result += LookUp(array); 00401198 lea edx,[esp+30h] 0040119C fstp dword ptr [esp+14h] 004011A0 call LookUp (401000h) 004011A5 fstp dword ptr [esp+20h] 004011A9 fld dword ptr [esp+20h] 004011AD mov eax,186A0h 004011B2 sub eax,1 004011B5 fld st(0) 004011B7 fadd dword ptr [esp+14h] 004011BB fstp dword ptr [esp+14h] 004011BF jne wmain+0B2h (4011B2h) }

You rigth as i see.

One better experiment will be force the c++ code to change the values every time ...
take a look to this C++ modified code:

Code Snippet

float LookUp(const float* array)
{
    float value = 0;

    for (int index = 0; index < twoPowerDimension; index++)
    {
        value += weightArray[index] * array[indexArray[index]];   
        weightArray[index] ++;
    }
 
    return value;
}

int _tmain(int argc, _TCHAR* argv[])
{
    float array[100];

    for (int i = 0; i < twoPowerDimension; ++i)
    {
        indexArray[i] = i %100;
        weightArray[i] = (float)(i / 10000.0);
    }

    for (int i = 0; i < 100; ++i)
    {
        array[i] = i/(float)100.0;
    }

    PrecisionTimer timer;
    timer.start();
    float result = 0;

    for (int i = 0; i < 100000;  ++i)
    {
        result += LookUp(array);
    }

    timer.stop();

    printf("Elapsed time = %lf (result = %lf)\n", timer.elapsed(), result);
}

and the final code spend:

Elapsed time = 60.374216 (result = 247525139283968.000000)

That is very near to the C# results...

and then...

just wait for C#  || JIT better compiler??? where we can make a new JIT || C# compiler feature?  in teh new feautre forum?

Answer 46

OK, no more red herrings.  Hopefully this will illustrated the problem better.  I modified Mathew's code.

 

First C#

 

Code Snippet

using System;

using System.Collections.Generic;

using System.Text;

using System.Diagnostics;

namespace CSharp

{

  class Program

  {

    const int dimension = 16;

    const int twoPowerDimension = 1 << dimension;

    static float[] weightArray = new float[twoPowerDimension];

    static int [] indexArray = new int [twoPowerDimension];

    static float[] array = new float[100000];

    static void Main()

    {

      for (int i = 0; i < array.Length; i++)

      {

        array[i] = i / 100.0F;

      }

 

      Random random = new Random(0);

 

      for (int i = 0; i < twoPowerDimension; i++)

      {

        double value = random.NextDouble();

        indexArray [i] = (int )(value * (array.Length - 1));

        weightArray[i] = (float)(value );

      }

 

      Stopwatch timer = new Stopwatch();

      float result = 0;

      timer.Start();

      for (int i = 0; i < array.Length; ++i)

      {

        array[i] = 1;

        result = LookUp(array);

      }

      timer.Stop();

      Console.WriteLine("LookUp() - Elapsed time = {0} (result = {1:f})", timer.Elapsed, result);

    }

    public static float LookUp(float[] array)

    {

      float value = 0;

      for (int index = 0; index < twoPowerDimension; index++)

      {

        value += weightArray[index] * array[indexArray[index]];

      }

      return value;

    }

  }

}

Answer 47

C++, see start of thread for PrecisionTime.h

 

Code Snippet

#include <windows.h>

#include <stdio.h>

#include <time.h>

#include "PrecisionTimer.h"

 

const int dimension = 16;

const int twoPowerDimension = 1 << dimension;

const int arrayLength = 100000;

static float* weightArray = new float[twoPowerDimension];

static int * indexArray = new int [twoPowerDimension];

static float* array = new float[arrayLength];

 

float LookUp(const float* array)

{

  float value = 0;

  for (int index = 0; index < twoPowerDimension; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

  return value;

}

 

int main(int argc, char* argv[])

{

  for (int i = 0; i < arrayLength; i++)

  {

    array[i] = i / 100.0F;

  }

 

  srand(0);

 

  for (int i = 0; i < twoPowerDimension; i++)

  {

    float value = float(rand()) / float(RAND_MAX);

    indexArray [i] = (int )(value * (arrayLength - 1));

    weightArray[i] = (float)(value );

  }

 

  clock_t start, finish;

  double duration;

  float result;

  start = clock();

 

  for (int i = 0; i < arrayLength; i++)

  {

    array[i] = 1.0F;

    result = LookUp(array);

  }

 

  finish = clock();

  duration = (double)(finish - start) / CLOCKS_PER_SEC;

  printf( "%4.3f seconds\n", duration );

}

 

 

Answer 48

Juan Carlos Ruiz Pacheco wrote:

Kelly Leahy (Milliman) wrote:   The C++ code only makes the call once in release mode. Code Snippet float LookUp(const float* array) {     float value = 0;     for (int index = 0; index < twoPowerDimension; index++)     {         value += weightArray[index] * array[indexArray[index]];            weightArray[index] ++;     }       return value; } int _tmain(int argc, _TCHAR* argv[]) {     float array[100];     for (int i = 0; i < twoPowerDimension; ++i)     {         indexArray[i] = i %100;         weightArray[i] = (float)(i / 10000.0);     }     for (int i = 0; i < 100; ++i)     {         array[i] = i/(float)100.0;     }     PrecisionTimer timer;     timer.start();     float result = 0;     for (int i = 0; i < 100000;  ++i)     {         result += LookUp(array);     }     timer.stop();     printf("Elapsed time = %lf (result = %lf)\n", timer.elapsed(), result); } and the final code spend: Elapsed time = 60.374216 (result = 247525139283968.000000) That is very near to the C# results... and then... just wait for C#  || JIT better compiler??? where we can make a new JIT || C# compiler feature?  in teh new feautre forum?

 

We need to get back on track.

 

First, the basic code below in C++ is way, way, way faster than C#.  The test driver to get the execution time was not correct.  The modified code I have above modifies the array prior to every call so Kelly's observation should no longer be true.

 

Code Snippet

public static float LookUp(float[] array)

{

  float value = 0;

  for (int index = 0; index < twoPowerDimension; index++)

  {

    value += weightArray[index] * array[indexArray[index]];

  }

  return value;

}

 

 

It is interesting to see that when the code is modified in, the C# is actually faster than the C++.  That was not expected.

 

Code Snippet

float LookUp(const float* array)

{

  float value = 0;

  for (int index = 0; index < twoPowerDimension; index++)

  {

    weightArray[index] += 0.1F;

    value += weightArray[index] * array[indexArray[index]];

  }

  return value;

}

 

 

But I still do not know the answer to the original question which is why the original LookUp is way faster in C++ than C#.  These are the results from my test that cannot possibly be incorrect because I use this same code to control airframes.

 

	C#	C++
A	0.59	0.28	52.20%
B	8.94	8.47	5.28%
C	10.06	6.99	30.52%
D	10.14	0.01	99.90%

 

Code Snippet

for (int index = 0; index < arrayTestRatio.Length; index++)

{

  // Section A

  ratio      = arrayTestRatio     [index];

  altitude   = arrayTestAltitude  [index];

  mach       = arrayTestMach      [index];

  alphaRatio = arrayTestAlphaRatio[index];

  betaMRatio = arrayTestBetaMRatio[index];

 

  // Section B

  tableIRatio     .LookUp(ratio     );

  tableIAltitude  .LookUp(altitude  );

  tableIMach      .LookUp(mach      );

  tableIAlphaRatio.LookUp(alphaRatio);

  tableIBetaMRatio.LookUp(betaMRatio);

 

  // Section C

  table5D.ComputeAccess();

 

  // Section D

  kp = table5D.LookUp(APGains.arrayKp);

  kq = table5D.LookUp(APGains.arrayKq);

  kr = table5D.LookUp(APGains.arrayKr);

}

 

 

Answer 49

 

i don´t know if you have follow the asm posts...

 

but the results are:

 

1- The c++ compiler dectect that every call to lookup function return the same value and the funtion doesn't make any modification on the arrays values, cause of that the C++ compiler create native code that just call lookup function once , then save the value returned and use this value in all other iterations whitout repeat  calls to lookup function.

 

2- on other hand C# || JIT compiler is not too smart as C++ compiler and the final native as a fact call the lookup function everytime instead of save the value as C++ code generate does.

 

3- And finally the example that i make change the lookup function  in C++ code to modify one array value everytime, then the c++ compiler 'detect' the lookup function changes the array values and cause of that the compiler generate code to call lookup function everytime as the C# || JIT native compiled code does .

 

4- Using this you 'force' calls to lookup functions  in C++ generated  native code and you can run the  c++ program and see that it runs too slow as the C# program does.

 

Finally and cause of that i wrote:

 

and the final code spend: Elapsed time = 60.374216 (result = 247525139283968.000000) That is very near to the C# results... and then... just wait for C#  || JIT better compiler??? where we can make a new JIT || C# compiler feature?  in teh new feautre forum?

Answer 50

What's happening in table5D.ComputeAccess?  Does it cause table5D.Lookup to return different results each time through the loop?

 

The difference in timing you're seeing seems to indicate that the C++ compiler thinks this is a loop invariant.  Without actually seeing the ASM surrounding this loop (which I can't without compilable "complete" code, or at least something close enough to test with) it's very hard to say how 'smart' the c++ optimizer is being.

 

It seems like this is definitely a difference between the optimizers however, and not a language features / bounds checking / etc. issue, though it's hard to be sure.

 

 

Answer 51

Juan Carlos Ruiz Pacheco wrote:

i don´t know if you have follow the asm posts...   but the results are:   1- The c++ compiler dectect that every call to lookup function return the same value and the funtion doesn't make any modification on the arrays values, cause of that the C++ compiler create native code that just call lookup function once , then save the value returned and use this value in all other iterations whitout repeat  calls to lookup function.   2- on other hand C# || JIT compiler is not too smart as C++ compiler and the final native as a fact call the lookup function everytime instead of save the value as C++ code generate does.   3- And finally the example that i make change the lookup function  in C++ code to modify one array value everytime, then the c++ compiler 'detect' the lookup function changes the array values and cause of that the compiler generate code to call lookup function everytime as the C# || JIT native compiled code does .   4- Using this you 'force' calls to lookup functions  in C++ generated  native code and you can run the  c++ program and see that it runs too slow as the C# program does.   Finally and cause of that i wrote:   and the final code spend: Elapsed time = 60.374216 (result = 247525139283968.000000) That is very near to the C# results... and then... just wait for C#  || JIT better compiler??? where we can make a new JIT || C# compiler feature?  in teh new feautre forum?

 

Yes, you are correct but those results are NOT based upon the correct test driver.  The real code actually changes the weightArray and indexArray before every call to LookUp so the test driver that Matthew wrote did not test the code correctly.  I ran a test, as shown above, that shows the LookUp is WAY slower in C# than C++.  Here are the results again.

 

	C#	C++
A	0.59	0.28	52.20%
B	8.94	8.47	5.28%
C	10.06	6.99	30.52%
D	10.14	0.01	99.90%

 

Code Snippet

for (int index = 0; index < arrayTestRatio.Length; index++)

{

  // Section A

  ratio      = arrayTestRatio     [index];

  altitude   = arrayTestAltitude  [index];

  mach       = arrayTestMach      [index];

  alphaRatio = arrayTestAlphaRatio[index];

  betaMRatio = arrayTestBetaMRatio[index];

 

  // Section B

  tableIRatio     .LookUp(ratio     );

  tableIAltitude  .LookUp(altitude  );

  tableIMach      .LookUp(mach      );

  tableIAlphaRatio.LookUp(alphaRatio);

  tableIBetaMRatio.LookUp(betaMRatio);

 

  // Section C  weightArray and indexArray are changed every time here

  table5D.ComputeAccess();

 

  // Section D

  kp = table5D.LookUp(APGains.arrayKp);

  kq = table5D.LookUp(APGains.arrayKq);

  kr = table5D.LookUp(APGains.arrayKr);

}

 

 

Answer 52

Kelly Leahy (Milliman) wrote:

You guys are all chasing a red herring.   The C++ code only makes the call once in release mode.  The optimizer is smart enough to recognize the value as a mathematical function that treats the array as read-only and so returns the same value for each pass of the loop.  The compiler then iterates adding the value over and over again, instead of making the call. thing like that.

 

Ahh, that explains it.  When I saw the release mode C++ disassembly, I saw that it only evaluated the function once; I didn't make the connection that this was optimizing away redundant calls to lookup.  So I went with the debug assembly (which is a little easier to follow). 

 

Oddly enough the C# debug assembly handles the condition check and jump in fewer instructions (2) than the C++ debug assembly (3).  Maybe the C# compiler devs were expecting a lot more production code to run in debug mode as people get acquainted with the technology...

Answer 53

I made a new test driver and put it on the web so everyone can complete the timing test.  THIS VERSION IS CODED CORRECTLY FOR THE TEST.  I make a change to array before every call to LookUp.  There should not be any code optimization but if there is, then there is a MAJOR compiler problem.

 

http://members.cox.net/nealconrardy/Example.zip

 

 

Here are my results

 

C:\Work\>cpp
0.000 seconds

 

C:\Work\>csharp
LookUp() - Elapsed time = 00:00:15.5159809 (result = 32820.53)

Answer 54

OK... now this is just getting funny...

 

THIS VERSION IS not CODED CORRECTLY FOR THE TEST.

 

result is never used, so when you build with optimizations, the compiler doesn't do anything for LookUp.

 

You should probably step through the code and see how many times LookUp is called when you are testing these before you just believe your results.  Had you tried running in the debugger (with the release mode code) setting a breakpoint inside LookUp, you'd have found it doesn't even execute ONCE!

 

Answer 55

Kelly Leahy (Milliman) wrote:

OK... now this is just getting funny...   THIS VERSION IS not CODED CORRECTLY FOR THE TEST.   result is never used, so when you build with optimizations, the compiler doesn't do anything for LookUp.   You should probably step through the code and see how many times LookUp is called when you are testing these before you just believe your results.  Had you tried running in the debugger (with the release mode code) setting a breakpoint inside LookUp, you'd have found it doesn't even execute ONCE!

conrarn, this could sound like a scolding... but in one way i tell you...

Answer 56

Kelly Leahy (Milliman) wrote:

OK... now this is just getting funny...   THIS VERSION IS not CODED CORRECTLY FOR THE TEST.   result is never used, so when you build with optimizations, the compiler doesn't do anything for LookUp.   You should probably step through the code and see how many times LookUp is called when you are testing these before you just believe your results.  Had you tried running in the debugger (with the release mode code) setting a breakpoint inside LookUp, you'd have found it doesn't even execute ONCE!

 

Not funny at all but you are mistaken.  Follow the threads.

 

1) I posted the original question and then posted a single function that showed the problem.

2) Some else wrote a test driver, not me, and the compiler optimized out unneccessary calls

3) I updated this test driver (see Example.zip download above) so there should be no way C++ would optimize out the call

4) THE PROBLEM STILL EXISTS

 

 

Example.zip is the solution which contains both a C++ and C# example so it should be easy to download at test.  If I am wrong, then compiler has a MAJOR problem because in this test code I change array every time LookUp is called.

 

Again, if I am wrong, I will apologize.  And yes, I ran through the debugger and code get called every iteration in both the C++ and C# code.

Answer 57

Actually, you're wrong.  Your example.zip was EXACTLY the code I ran.  When running in release mode, it does not call LookUp at ALL.

 

You need three changes:

 

1)

float result;

   should be changed to

float result = 0;

 

2)

result = LookUp(array);

    should be changed to

result += LookUp(array);

 

3)

result should be used somewhere, so change your printf to read:

printf( "%4.3f seconds, result = %f\n", duration, result);

 

If you don't do those things the following will happen:

 

1) and 2) - if you don't do these, then the compiler can optimize out the call the LookUp and only call it after the array has been modified for the entire loop (not sure whether it will actually perform this optimization, but it is, in theory, safe).

3) if you don't do this one, it will NEVER call LookUp, since you never use the return value and LookUp doesn't call anything else, so it's known to have no side effects.

 

I'm not saying whether these optimizations are overly agressive or not (I personally think they might be), I'm just telling you what its doing.

Answer 58

My apologies, you are absolutely correct.

 

I ran it in the debugger and it stepped in to the function every time.  Still, my mistake and I apologize.

 

Answer 59

No worries.

 

I think now you are probably seeing the C++ code run slower or nearly the same as the C# code.  At least that's what I see on my machine.

 

It still doesn't answer your original questions, but I'm curious as to what's happening to your mainline block.  If you could paste the entire C++ disassembly for the mainline from your original post, I may be able to tell you if some surprising optimizations are being done.

 

Basically I would need the stuff several lines before the for loop and the stuff slightly after it.

 

Answer 60

conrarn wrote:

My apologies, you are absolutely correct.   I ran it in the debugger and it stepped in to the function every time.  Still, my mistake and I apologize.

 

Fortunately it should be possible to write lookup in a way that performs as good or better than the code in C++.  You may need to inline it (e.g., instead of calling Lookup(), put the code for LookUp() inside the loop) and drop down into unsafe mode.

 

To prevent the c++ compiler from optimizing away the product, I print the value of value after it has been calculated.

 

In release mode, the results (in seconds) are:

 

Size = 6,480

C#   = 0.0000329651

C++  = 0.000015

 

Size = 64,800

C#   = 0.0003344000

C++  = 0.000252

 

Size = 648,000

C#  = 0.0050816514

C++ = 0.006057

 

Size 6,480,000

C#  = 0.0368376428

C++ = 0.055844

 

Size 64,800,000

C#  = 0.3899333575

C++ = ??? - crashes EVERY time while allocating the array

 

The code for these tests is below:

 

Code Snippet

// C# SAMPLE

 

unsafe static void Main(string[] args)

{

int size = int.Parse(args[0]);

Console.WriteLine("size={0}", size);

 

float[] array = new float[size];

float[] weight = new float[size];

Random rnd = new Random();

 

// initialize the array with random values

for (int i = 0; i < array.Length; i++)

array[i] = (float)(rnd.NextDouble() * 1000);