Improving Android Performance at Mobiconf 2014

Improving Android
Performance
#perfmatters
Raimon Ràfols

Agenda
- Who am I?
- Java and VMs
- Examples - Do & dont's
- Tooling

Who am I?
- Mobile Software Engineering Manager at
Imagination Technologies (@imgtec)
- Twitter: @rrafols
- http://blog.rafols.org

Disclaimer
This presentation contains bytecode

Why do we need to talk about java?

*.java → [javac] → *.class
*.class → [dx] → dex file

Compilers
Produces optimised code for
target platform

Javac
Doesn't optimise anything

Javac
Doesn't know on which
architecture will the code
be executed

Not the most optimal solution
(regarding performance)

Dalvik VM and ART are register
based architectures

Register based integer addition

Java VM (JVM)
Only the JVM knows on which
architecture is running

Java VM (JVM)
All optimisations are left to be
done by the JVM

Maybe takes this concept a bit too
far...

GCC compiler
#include <stdio.h>
int main() {
int a = 10;
int b = 1 + 2 + 3 + 4 + 5 + 6 + a;
printf("%dn", b);
}
…
movl $31, %esi
call _printf
…
* Using gcc & -O2 compiler option

javac
public static void main(String args[]) {
int a = 10;
int b = 1 + 2 + 3 + 4 + 5 + 6 + a;
System.out.println(b);
}
0: bipush 10
2: istore_1
3: bipush 21
5: iload_1
6: iadd
7: istore_2
...

javac
int a = 10;
int b = 1 + 2 + 3 + 4 + 5 + a + 6;
}
0: bipush 10
2: istore_1
3: bipush 15
5: iload_1
6: iadd
7: bipush 6
9: iadd
10: istore_2
...

javac
int a = 10;
int b = a + 1 + 2 + 3 + 4 + 5 + 6;
}

javac
int a = 10;
int b = a + 1 + 2 + 3 + 4 + 5 + 6;
}
0: bipush 10
2: istore_1
3: iload_1
4: iconst_1
5: iadd
6: iconst_2
7: iadd
8: iconst_3
9: iadd
10: iconst_4
11: iadd
12: iconst_5
13: iadd
14: bipush 6
16: iadd
17: istore_2

Improving Android Performance at Mobiconf 2014

Autoboxing
Transparent to the developer but
compiler adds some 'extra' code

Autoboxing
long total = 0;
for(int i = 0; i < N; i++) {
total += i;
}
4: lconst_0
5: lstore_3
6: iconst_0
7: istore 5
9: iload 5
11: ldc #6;
13: if_icmpge 28
16: lload_3
17: iload 5
19: i2l
20: ladd
21: lstore_3
22: iinc 5,1
25: goto 9

Autoboxing
Long total = 0;
for(Integer i = 0; i < N; i++) {
total += i;
}
9: iconst_0
10: invokestatic #4; //Method java/lang/Integer.valueOf:
(I)Ljava/lang/Integer;
13: astore 4
15: aload 4
17: invokevirtual #5; //Method java/lang/Integer.intValue:()I
20: ldc #6; //int 10000000
22: if_icmpge 65
25: aload_3
26: invokevirtual #7; //Method java/lang/Long.longValue:()J
29: aload 4
34: i2l
35: ladd
36: invokestatic #3; //Method java/lang/Long.valueOf:
(J)Ljava/lang/Long;
39: astore_3
40: aload 4
42: astore 5
44: aload 4
49: iconst_1
50: iadd
51: invokestatic #4; //Method java/lang/Integer.valueOf:
(I)Ljava/lang/Integer;
54: dup
55: astore 4
57: astore 6
59: aload 5
61: pop
62: goto 15

Autoboxing
●
This is what that code is actually doing:
Long total = 0;
for(Integer i = Integer.valueOf(0);
i.intValue() < N;
i = Integer.valueOf(i.intValue() + 1)) {
total = Long.valueOf(total.longValue() + (long)i.intValue())
}

Sorting
Two easy ways to sort:
• Arrays.sort(array);
• Collections.sort(list);
Lets evaluate the performance as both data
type & sorting algorithms are different.

Sorting
• Arrays.sort(arrays) uses a modified version
of a 3-way quicksort.
• Collections.sort(list) uses a iterative
implementation of mergesort (stable)

Sorting
Arrays.sort(array) uses the same
implementation as
Collections.sort(list) for non-
primitive data types.

Loops
What's going on under the hood

Loops - List
ArrayList<Integer> list = new …
static long loopStandardList() {
long result = 0;
for(int i = 0; i < list.size(); i++) {
result += list.get(i);
}
return result;
}

Loops - List (Java bytecode)
7: lload_0
8: getstatic #26 // Field list:Ljava/util/ArrayList;
11: iload_2
12: invokevirtual #54 // Method java/util/ArrayList.get:(I)Ljava/lang/Object;
15: checkcast #38 // class java/lang/Integer
18: invokevirtual #58 // Method java/lang/Integer.intValue:()I
21: i2l
22: ladd
23: lstore_0
24: iinc 2, 1
27: iload_2
28: getstatic #26 // Field list:Ljava/util/ArrayList;
31: invokevirtual #61 // Method java/util/ArrayList.size:()I
34: if_icmplt 7

Loops - List (Dalvik bytecode)
0003: sget-object v3, Lcom/rrafols/bcndevcon/Loop;.list:Ljava/util/ArrayList;
0005: invoke-virtual {v3}, Ljava/util/ArrayList;.size:()I
0008: move-result v3
0009: if-lt v0, v3, 000c // +0003
000b: return-wide v1
000c: sget-object v3, Lcom/rrafols/bcndevcon/Loop;.list:Ljava/util/ArrayList;
000e: invoke-virtual {v3, v0}, Ljava/util/ArrayList;.get:(I)Ljava/lang/Object;
0011: move-result-object v3
0012: check-cast v3, Ljava/lang/Integer;
0014: invoke-virtual {v3}, Ljava/lang/Integer;.intValue:()I
0018: int-to-long v3, v3
0019: add-long/2addr v1, v3
001a: add-int/lit8 v0, v0, #int 1 // #01
001c: goto 0003 // -0019

Loops - foreach
ArrayList<Integer> list = new …
static long loopForeachList() {
long result = 0;
for(int v : list) {
result += v;
}
return result;
}

Loops - foreach (Java bytecode)
12: aload_3
13: invokeinterface #70, 1 // InterfaceMethod java/util/Iterator.next:()
18: checkcast #38 // class java/lang/Integer
21: invokevirtual #58 // Method java/lang/Integer.intValue:()I
24: istore_2
25: lload_0
26: iload_2
27: i2l
28: ladd
29: lstore_0
30: aload_3
31: invokeinterface #76, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z
36: ifne 12

Loops - foreach (Dalvik bytecode)
0008: invoke-interface {v4}, Ljava/util/Iterator;.hasNext:()Z
000b: move-result v3
000c: if-nez v3, 000f // +0003
000e: return-wide v0
000f: invoke-interface {v4}, Ljava/util/Iterator;.next:()Ljava/lang/Object;
0012: move-result-object v3
0013: check-cast v3, Ljava/lang/Integer;
0015: invoke-virtual {v3}, Ljava/lang/Integer;.intValue:()I
0019: int-to-long v5, v2
001a: add-long/2addr v0, v5
001b: goto 0008 // -0013

Loops - Array
static int[] array = new ...
static long loopStandardArray() {
long result = 0;
for(int i = 0; i < array.length; i++) {
result += array[i];
}
return result;
}

Loops - Array (Java bytecode)
7: lload_0
8: getstatic #28 // Field array:[I
11: iload_2
12: iaload
13: i2l
14: ladd
15: lstore_0
16: iinc 2, 1
19: iload_2
23: arraylength
24: if_icmplt 7

Loops - Array (Dalvik bytecode)
0003: sget-object v3, Lcom/rrafols/bcndevcon/Loop;.array:[I
0005: array-length v3, v3
0006: if-lt v0, v3, 0009 // +0003
0008: return-wide v1
000b: aget v3, v3, v0
000d: int-to-long v3, v3
000e: add-long/2addr v1, v3
000f: add-int/lit8 v0, v0, #int 1 // #01
0011: goto 0003 // -000e

Loops - size cached
static long loopStandardArraySizeStored() {
long result = 0; int length = array.length;
for(int i = 0; i < length; i++) {
result += array[i];
}
return result;
}

Loops - size stored (Java bytecode)
12: lload_0
16: iload_3
17: iaload
18: i2l
19: ladd
20: lstore_0
21: iinc 3, 1
24: iload_3
25: iload_2
26: if_icmplt 12

Loops - size stored(Dalvik bytecode)
0006: if-lt v0, v1, 0009 // +0003
000b: aget v4, v4, v0
000d: int-to-long v4, v4
000e: add-long/2addr v2, v4
000f: add-int/lit8 v0, v0, #int 1 // #01
0011: goto 0006 // -000b

Loops - backwards
static long loopStandardArrayBackwards() {
long result = 0;
for(int i = array.length - 1; i >= 0; i--) {
result += array[i];
}
return result;
}

Loops - backwards (Java bytecode)
12: lload_0
16: iload_2
17: iaload
18: i2l
19: ladd
20: lstore_0
21: iinc 2, -1
24: iload_2
25: ifge 12

Loops - backwards(Dalvik bytecode)
0007: if-gez v0, 000a // +0003
000a: sget-object v3, Lcom/rrafols/bcndevcon/Loop;.array:[I
000c: aget v3, v3, v0
000e: int-to-long v3, v3
000f: add-long/2addr v1, v3
0010: add-int/lit8 v0, v0, #int -1 // #ff
0012: goto 0007 // -000b

String concatenation
The evil + sign

Java allows us to concatenate Strings using
the + operator to make our lifes easier. As
what happened before with autoboxing the
compiler will generate some additional code.

String str = "";
for(int i = 0; i < ITERATIONS; i++) {
str += ANY_OTHER_STRING;
}

8: new #26 // class java/lang/StringBuilder
11: dup
12: aload_1
13: invokestatic #28 // Method java/lang/String.valueOf:
(Ljava/lang/Object;)Ljava/lang/String;
16: invokespecial #34 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
19: ldc #11 // String ANY_OTHER_STRING
21: invokevirtual #37 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)
24: invokevirtual #41 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
27: astore_1
28: iinc 2, 1
31: iload_2
32: bipush ITERATIONS
34: if_icmplt 8

• It's creating a StringBuilder Object in every iteration of
the loop. It's the same as the following code:
String str = "";
StringBuilder sb = new StringBuilder(String.valueOf(str));
sb.append(ANY_OTHER_STRING);
str = sb.toString();
}

String concatenation - alternatives
• Use String.concat()
• Concat cost is O(N) + O(M) - (N,M) length of each
String
• Concat returns a new String Object.
String str = "";
str = str.concat(ANY_OTHER_STRING);

• Use StringBuilder
• StringBuffer.append cost is O(M) amortized time (M
length of appended String)
• Avoids creation of new objects.
StringBuilder sb = new StringBuilder()
sb.append(ANY_OTHER_STRING);
}
str = sb.toString();

• StringBuilder is the not thread safe
implementation of StringBuffer.
• No need to add synchronization overhead if
it's not going to be used by multiple threads.

Tooling - Disassembler
Java
• javap -c <classfile>
Android:
• Dexdump -d <dexfile>
• Smali - https://code.google.com/p/smali/

Tooling - Obfuscation
• Proguard & Dexguard
o Proguard & Dexguard are code obfuscators but they
also do a good job on optimizing at bytecode level,
reducing overhead, eliminating dead code, inlining
methods, …
o Proguard is free and comes with the android sdk,
needs to be enabled by just uncommenting one line
in project.properties

Tooling - Performance measurement
• Avoid doing manual performance tests with
System.currentTimeMillis() (although gives a
good estimate) and multiple tests in one run.
• JIT might be evil!

Performance measurements
Avoid doing multiple tests in one run
JIT might be evil!

Do not trust the compiler!
@rrafols
http://blog.rafols.org

Improving Android Performance at Mobiconf 2014

More Related Content

What's hot (20)

Viewers also liked (18)

Similar to Improving Android Performance at Mobiconf 2014 (20)

More from Raimon Ràfols (7)

Recently uploaded (6)

Improving Android Performance at Mobiconf 2014