使用数组索引的C＃性能

Question

I have an array and I want to use on single value multiple times in the same method.

int[] array = new array[] {1, 2, 3};

Now I'm asking you if its a big performance issue if I use the array and an index to get the value...

int x = array[1] * 2;
int y = array[1] * 3;
int z = array[1] * 4;

or is it better to create a local variable?

int value = array[1];
int x = value * 2;
int y = value * 3;
int z = value * 4;

I know it easier to read with a local variable, but it just interested me if it makes any performace differences. ;-)

Answer 1

No, there would be no performance difference. For this to work:

int x = array[1] * 2;

the value at array[1] is going to have to be moved into a memory location anyway when the IL is generated. The remaining operations will then be optimized away by the compiler (ie it's not going to retrieve the value more than once).

---

Alright, to settle the argument I decided to dump each, here is the first:

.method private hidebysig static void  Main(string[] args) cil managed
{
  IL_0000:  nop
  IL_0001:  ldc.i4.3
  IL_0002:  newarr     [mscorlib]System.Int32
  IL_0007:  dup
  IL_0008:  ldtoken    field valuetype '<PrivateImplementationDetails>{79A4FD92-FA37-4EB9-8056-B52A57262FBB}'/'__StaticArrayInitTypeSize=12' '<PrivateImplementationDetails>{79A4FD92-FA37-4EB9-8056-B52A57262FBB}'::'$$method0x6000001-1'
  IL_000d:  call       void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
                                                                                                      valuetype [mscorlib]System.RuntimeFieldHandle)
  IL_0012:  stloc.0
  IL_0013:  ldloc.0
  IL_0014:  ldc.i4.1
  IL_0015:  ldelem.i4
  IL_0016:  stloc.1
  IL_0017:  ldloc.1
  IL_0018:  ldc.i4.2
  IL_0019:  mul
  IL_001a:  stloc.2
  IL_001b:  ldloc.1
  IL_001c:  ldc.i4.3
  IL_001d:  mul
  IL_001e:  stloc.3
  IL_001f:  ldloc.1
  IL_0020:  ldc.i4.4
  IL_0021:  mul
  IL_0022:  stloc.s    z
  IL_0024:  ret
} // end of method Program::Main

and here is the second:

.method private hidebysig static void  Main(string[] args) cil managed
{
  IL_0000:  nop
  IL_0001:  ldc.i4.3
  IL_0002:  newarr     [mscorlib]System.Int32
  IL_0007:  dup
  IL_0008:  ldtoken    field valuetype '<PrivateImplementationDetails>{79A4FD92-FA37-4EB9-8056-B52A57262FBB}'/'__StaticArrayInitTypeSize=12' '<PrivateImplementationDetails>{79A4FD92-FA37-4EB9-8056-B52A57262FBB}'::'$$method0x6000001-1'
  IL_000d:  call       void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array,
                                                                                                      valuetype [mscorlib]System.RuntimeFieldHandle)
  IL_0012:  stloc.0
  IL_0013:  ldloc.0
  IL_0014:  ldc.i4.1
  IL_0015:  ldelem.i4
  IL_0016:  stloc.1
  IL_0017:  ldloc.1
  IL_0018:  ldc.i4.2
  IL_0019:  mul
  IL_001a:  stloc.2
  IL_001b:  ldloc.1
  IL_001c:  ldc.i4.3
  IL_001d:  mul
  IL_001e:  stloc.3
  IL_001f:  ldloc.1
  IL_0020:  ldc.i4.4
  IL_0021:  mul
  IL_0022:  stloc.s    z
  IL_0024:  ret
} // end of method Program::Main

They are exactly the same--as I stated.

Answer 2

Although I agree that such micro-optimizations are evil and unnecessary, and readability might be more important , it was quite a fun to make a dummy benchmark for two methods:

private static int TestWithIndex(int[] array)
{
    int x = array[1] * 2;
    int y = array[1] * 3;
    int z = array[1] * 4;
    return x + y + z;
}

private static int TestWithTemp(int[] array)
{
    int value = array[1];
    int x = value * 2;
    int y = value * 3;
    int z = value * 4;
    return x + y + z;
}

calling them int.MaxValue times in Release mode produces:

• 12032 ms - for TestWithIndex
• 10525 ms - for TestWithTemp

And then let's look at the IL generated (Release mode, Optimizations enabled):

TestWithIndex

.method private hidebysig static 
    int32 TestWithIndex (
        int32[] 'array'
    ) cil managed 
{
    // Method begins at RVA 0x2564
    // Code size 29 (0x1d)
    .maxstack 2
    .locals init (
        [0] int32 x,
        [1] int32 y,
        [2] int32 z,
        [3] int32 CS$1$0000
    )

    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: ldc.i4.1
    IL_0003: ldelem.i4
    IL_0004: ldc.i4.2
    IL_0005: mul
    IL_0006: stloc.0
    IL_0007: ldarg.0
    IL_0008: ldc.i4.1
    IL_0009: ldelem.i4
    IL_000a: ldc.i4.3
    IL_000b: mul
    IL_000c: stloc.1
    IL_000d: ldarg.0
    IL_000e: ldc.i4.1
    IL_000f: ldelem.i4
    IL_0010: ldc.i4.4
    IL_0011: mul
    IL_0012: stloc.2
    IL_0013: ldloc.0
    IL_0014: ldloc.1
    IL_0015: add
    IL_0016: ldloc.2
    IL_0017: add
    IL_0018: stloc.3
    IL_0019: br.s IL_001b

    IL_001b: ldloc.3
    IL_001c: ret
} // end of method Program::TestWithIndex

Here we see three ldelem.i4 .

TestWithTemp

.method private hidebysig static 
    int32 TestWithTemp (
        int32[] 'array'
    ) cil managed 
{
    // Method begins at RVA 0x2590
    // Code size 29 (0x1d)
    .maxstack 2
    .locals init (
        [0] int32 'value',
        [1] int32 x,
        [2] int32 y,
        [3] int32 z,
        [4] int32 CS$1$0000
    )

    IL_0000: nop
    IL_0001: ldarg.0
    IL_0002: ldc.i4.1
    IL_0003: ldelem.i4
    IL_0004: stloc.0
    IL_0005: ldloc.0
    IL_0006: ldc.i4.2
    IL_0007: mul
    IL_0008: stloc.1
    IL_0009: ldloc.0
    IL_000a: ldc.i4.3
    IL_000b: mul
    IL_000c: stloc.2
    IL_000d: ldloc.0
    IL_000e: ldc.i4.4
    IL_000f: mul
    IL_0010: stloc.3
    IL_0011: ldloc.1
    IL_0012: ldloc.2
    IL_0013: add
    IL_0014: ldloc.3
    IL_0015: add
    IL_0016: stloc.s CS$1$0000
    IL_0018: br.s IL_001a

    IL_001a: ldloc.s CS$1$0000
    IL_001c: ret
} // end of method Program::TestWithTemp

Here only one ldelem.i4 of course.

Answer 3

If you do not have performance requirements or performance problems, then your main goal is to write readable code which will be easy to maintain. It's easy to see duplication in your first example:

int x = array[1] * 2;
int y = array[1] * 3;
int z = array[1] * 4;

It has several issues. First - the more you have duplicated code, the more code you have to support and the higher chance you will not modify one of code copies at some point of time. Second - duplication always means you have hidden knowledge in your code. If some code is repeated then it has specific meaning, which you haven't made obvious. Eg you have speed value in second item of array. Make this knowledge explicit:

int speed = array[1];
int x = speed * 2; // of course, magic numbers also should be replaced
int y = speed * 3;
int z = speed * 4;

And remember - premature optimization is evil. Usually you have 20% of code which takes 80% of execution time. There is high probability that your optimizations will not affect application performance. So, you should find these 20% first, and only then do optimizations (if they really needed).