General

Re: C# Array[] speed vs List<> speed

jmartingarcia — Fri, 19 Jun 2009 17:26:54 GMT

Yes, is only for positive values in this case.

Thanks

Re: C# Array[] speed vs List<> speed

jmartingarcia — Fri, 19 Jun 2009 17:22:49 GMT

Brilliant !!

Thanks !

Re: C# Array[] speed vs List<> speed

The ZMan — Fri, 19 Jun 2009 17:20:19 GMT

http://msdn.microsoft.com/en-us/library/system.math.round.aspx

Adding .5 works properly for +ve values only (most of the time for drawing sprites unless you have some transforms involved)

Re: C# Array[] speed vs List<> speed

Nick Gravelyn — Fri, 19 Jun 2009 17:13:15 GMT

jmartingarcia:
2.- That won't really work I think. You see, if the X position is the pixel 1.90 then should be the pixel 2 and not the pixel 1 on the screen.
When I convert from world units to pixels I will get fractional pixels that I need to convert to the best matching pixel position.

There's actually a little trick you can do with this. Basically add .5 to the number and cast to integer. Then if the number was .5 or more towards the next number, it will round correctly. So make a custom round method:

    
            public static int MyRound(float input) 
        
            { 
        
               return (int)(input + .5f); 
        
            }

Then give it a try with some numbers:

    
            Console.WriteLine(MyRound(1f)); // prints 1 
        
            Console.WriteLine(MyRound(1.2f)); // prints 1 
        
            Console.WriteLine(MyRound(1.5f)); // prints 2 
        
            Console.WriteLine(MyRound(1.9f)); // prints 2 
        
            Console.WriteLine(MyRound(2.1f)); // prints 2

You'll see that it now rounds to the proper number without using the Math.Round method.

Re: C# Array[] speed vs List<> speed

jmartingarcia — Fri, 19 Jun 2009 17:02:16 GMT

1.- Yes, you are right, I should create the rectangle outside the loop.

2.- That won't really work I think. You see, if the X position is the pixel 1.90 then should be the pixel 2 and not the pixel 1 on the screen.
When I convert from world units to pixels I will get fractional pixels that I need to convert to the best matching pixel position.

Re: C# Array[] speed vs List<> speed

Craig Martin — Fri, 19 Jun 2009 13:39:11 GMT

or if that code is a real performance problem

instantiate the Rectangle outside the loop

Rectangle rect = new Rectangle();

then inside the loops do this

rect.X = (int)X;
rect.Y = (int)Y;
etc

so you are reusing the same object rather than instantiating a new one every time.

Re: C# Array[] speed vs List<> speed

Craig Martin — Fri, 19 Jun 2009 13:30:56 GMT

The float64 (double) is coming from the Math.Round(..) call.

Just do this.

new Rectangle((int)X, ...)

Re: C# Array[] speed vs List<> speed

jmartingarcia — Fri, 19 Jun 2009 13:27:36 GMT

I don't know why the NProf does not want to work anymore. It runs the application but then after some seconds the application disappears and the profiler never stops.

Well, anyway, the profiler said my application was taking about 20% of the time on the collision detection. The childs of the collision detection where basically the calculation of the rectangle coordinates and the creation of the rectangle. Ignoring the creation of the rectangle, the more consuming task was the Convert.ToInt32(float64), now I'm using float in my application but is float64 because I convert to In32 the Rounded number of my float, so the rectangle creation is like this:

new Rectangle(Convert.ToInt32(Math.Round( X )), ...)

Now I'm thinking, I'm creating a rectangle for each sprite on the screen to check collision detection each Frame (update call) ... maybe I should create a rectangle once and then modify its properties on each frame.

Re: C# Array[] speed vs List<> speed

Craig Martin — Fri, 19 Jun 2009 13:06:58 GMT

In most cases the readability hence smaller bug potential of foreach is preferable to the small performance difference, unless of course you must have the index, in which case the for statement is appropriate.

But the garbage problem with lists that are constantly cleared and refilled every frame is said to be a problem on the 360 and in those cases it might be worth looking at using a fixed size array.

Re: C# Array[] speed vs List<> speed

Jeremy JANISZEWSKI — Fri, 19 Jun 2009 11:36:52 GMT

Benjamin Nitschke has written an article on this :

http://benjaminnitschke.com/2009/04/22/ForVsForeachPerformance.aspx

As you can see, a foreach + array seems to be the more efficient way to make an iteration (even if you convert a list to an array)

Re: C# Array[] speed vs List<> speed

feal87 — Fri, 19 Jun 2009 05:23:16 GMT

Ah lol, anyway tried and same results.

Re: C# Array[] speed vs List<> speed

Nick Gravelyn — Fri, 19 Jun 2009 05:15:41 GMT

feal87:
Nick Gravelyn:
Why not just use sw.Elapsed.TotalMilliseconds? There's already a property that gives you the time in milliseconds with a decimal. :)

http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.elapsedmilliseconds.aspx

well, because its a long without decimals.
The results are anyway the same but without decimals.

That property you linked is not what I said. Look at it again: sw.Elapsed.TotalMillseconds. You get the Elapsed property from Stopwatch (which returns a TimeSpan) and then use the TotalMilliseconds property of that TimeSpan to get the total milliseconds with decimal place. :)

Re: C# Array[] speed vs List<> speed

feal87 — Fri, 19 Jun 2009 05:07:24 GMT

Nick Gravelyn:
Why not just use sw.Elapsed.TotalMilliseconds? There's already a property that gives you the time in milliseconds with a decimal. :)

http://msdn.microsoft.com/en-us/library/system.diagnostics.stopwatch.elapsedmilliseconds.aspx

well, because its a long without decimals.
The results are anyway the same but without decimals.

Re: C# Array[] speed vs List<> speed

Nick Gravelyn — Thu, 18 Jun 2009 23:54:30 GMT

Why not just use sw.Elapsed.TotalMilliseconds? There's already a property that gives you the time in milliseconds with a decimal. :)

Re: C# Array[] speed vs List<> speed

feal87 — Thu, 18 Jun 2009 23:04:24 GMT

3,167861 ms foreach array
9,075665 ms for array unoptimized
2,935359 ms for array optimized
20,38946 ms foreach list
17,04064 ms for list unoptimized
6,171315 ms for list optimized

As i said they are very little differences between them, only the foreach list is the very slow one compared to the rest (9 times slower than the for over array optimized).

P.S. the ms results are calculated this way. Can you confirm it is correct?

    
            Results.Add(sw.ElapsedTicks * 1000f / Stopwatch.Frequency);