局部变量或类字段？

Question

I read today a post about performance improvement in C# and Java.

I still stuck on this one:

---

19. Do not overuse instance variables

Performance can be improved by using local variables. The code in example 1 will execute faster than the code in Example 2.

Example1:

public void loop() {
    int j = 0;
    for ( int i = 0; i<250000;i++){
        j = j + 1;
    }
}

Example 2:

int i;
public void loop() {
    int j = 0;
    for (i = 0; i<250000;i++){
        j = j + 1;
    }
}

---

Indeed, I do not understand why it should be faster to instantiate some memory and release it every time a call to the loop function is done when I could do a simple access to a field.

It's pure curiosity, I'm not trying to put the variable 'i' in the class' scope :p Is that true that's faster to use local variables? Or maybe just in some case?

Answer 1

1. Stack faster then Heap.

    void f() { int x = 123; // <- located in stack } int x; // <- located in heap void f() { x = 123 } 

2. Do not forget the principle of locality data . Local data should be better cached in CPU cache. If the data are close, they will loaded entirely into the CPU cache, and the CPU does not have to get them from memory.

Answer 2

The performance is down to the number of steps required to get the variable. Local variable addresses are known at compile time (they are a known offset on the stack), to access a member you load the object 'this' to get the address of the actual object, before you can get the address of the member variable.

Answer 3

Even if it will be, there will be almost non measurable difference in this cases. Probabbly in first case, there is some optimization done on processor registry level, but again:

• it's almost irrelevant
• and what is more important, often unpredictable.

In terms of memory, it's exactly the same, there is no any difference.

The first case it generaly better: as you declare variable there were it's imediately used, which is commonly used good pattern, as it's

• easy to understand (scopes of responsibilities)
• easy refactor

Answer 4

In C# another minor difference is the number of generated MSIL instructions (I guess it's similar in Java).

It takes two instructions to load an instance field:

ldarg.0                 // load "this" reference onto stack
ldfld   MyClass.myField // find the field and load its value

...but it only takes one instruction to load a local variable:

ldloc.0                 // load the value at index 0 from the list of local variables

Answer 5

I suspect there's very little difference, however in the case where the variable is a member of the object, each access requires an indirection via this (effectively), whereas the local variable does not.

More generally, the object has no need for a member i , it's only used in the context of the loop, so making it local to its use is better in any case.

Answer 6

I tested a calculation with 500,000 iterations where I used about 20 variables locally and one that does it with fields. The local variable test was about 20 milliseconds and the one with fields was about 30 milliseconds. A significant performance gain when you use local variables.

Whether the performance difference is relevant, depends on the project. In your average business application the performance gain may not be noticeable and it is better to go for readable / maintainable code, but I am working on sound synthesis software where nano-optimizations like this actually become relevant.