CODEWITHSUNDEEP
javaandroid
xmen
xmen

Reputation: 1967

Performance tips questions

public void zero() {
    int sum = 0;
    for (int i = 0; i < mArray.length; ++i) {
        sum += mArray[i].mSplat;
    }
}

public void one() {
    int sum = 0;
    Foo[] localArray = mArray;
    int len = localArray.length;

    for (int i = 0; i < len; ++i) {
        sum += localArray[i].mSplat;
    }
}

According to Android documentation, in above code, zero is slower. But I don't understand why ? well I haven't learn that much deep but as I know length is a field not method. So when loop retrieves its value, how its different from retrieving from local variable ? and array length is always fixed once initialized. What am I missing ?

Upvotes: 5

Views: 173

Answers (4)

Ritesh Gune
Ritesh Gune

Reputation: 16739

  public void zero() {
    int sum = 0;
    for (int i = 0; i < mArray.length; ++i) {
        sum += mArray[i].mSplat;
    }
}

Here if you look at the for loop array length is calculated for every iteration, that degrades the performance.

  public void one() {
    int sum = 0;
    Foo[] localArray = mArray;
    int len = localArray.length;

    for (int i = 0; i < len; ++i) {
        sum += localArray[i].mSplat;
    }
}

In this case the length is calculated before for loop and then used in the loop.

Upvotes: 2

njzk2
njzk2

Reputation: 39403

It is a matter of scope. Accessing an instance variable is slower than a method variable because it is not stored in the same memory places. (because method variables are likely to be accessed more often).

Same goes for len, but with an extra optimization. len cannot be changed from outside the method, and the compiler can see that it will never change. Therefore, its value is more predictable and the loop can be further optimized.

Upvotes: 2

assylias
assylias

Reputation: 328923

In the first example, the JVM needs to first fetch the reference to the array and then access its length field.

In the second example, it only accesses one local variable.

On desktop JVMs this is generally optimised and the two methods are equivalent but it seems that Android's JVM does not do it... yet...

Upvotes: 3

MalaKa
MalaKa

Reputation: 3794

Well I guess this is because at zero, he always needs to retrieve the information from mArray and in one, he has it accessible. This means, zero needs two "methods":

  1. Access mArray
  2. Access mArray.length

But one only needs one "methods":

  1. Access len

Upvotes: 8

Related Questions