12. 30 / 10 / 2016
New course coming
30 / 10 / 2016
New course coming
13. 30 / 10 / 2016
New course coming
30 / 10 / 2016
New course coming
● +: Networking Debt.
● A: CPU
○ Theory
○ Practice
● B: Battery
○ Theory
○ Practice
10/08/2016
CPU & Battery
14. - Assess the problem and
establish acceptable behavior.
- Measure perf b4 modification.
- Identify bottleneck.
- Remove bottleneck.
- Measure perf after modification.
- If better, adopt.
If worse, put it back.
Methods of Systematic performance improvement
https://en.wikipedia.org/wiki/Performance_tuning
16. Last month, Yonatan talked about
- Networks basics
- Retrofit 2.0
- Caching, Prefetching
- Bundling-up with Android (~ Sync Adapters),
Or at least playing nice (~ Job Scheduler)
- Doze (Will be revised
today)Really, check it out. https://docs.google.com/presentation/d/1maecLjfOOy38_VJWc2YKzoXGSR2ulF3KLG6wmoJ3OwE/edit?usp=sharing
22. GZip
When communicating with servers, it makes sense to compress the
data, and it’s quite easy to do so.
GZip is a GNU-Licensed compression algorithm, which is a merge of
2 compression algorithms: Lampel-Ziv-77 and Huffman-Codes,
That works in 32kb chunks.
23. GZip - LZ77 Concept - Back References
קולגלגלהמתגלגלמלמטה
למעלה
מרכבותסתומותהולכות
ומתגלגלות
Credit for the example: Orevi Joe
2,28,4
7,27,210,2 49,4 41,2
5,2
24. How to mess up compressibility
When you’re sending arrays or lists of large objects, the JSON format
OOB has a lot of redundancy, and if the object is large, then some of
the references fail.
25. How to mess up compressibility - Solution
Consider crafting a DTO that would be optimized for smaller footprint
and compression.
Have numbers and similar strings close to each other.
Consider refactoring a list-of-object to an object-of-lists.
26. JSON Class Representation
[
{
"id": 314,
"shoe_size": 42,
"show_image": "-- 32kB Base64 representation of a PNG --",
},
{
"id": 42,
"shoe_size": 42,
"show_image": "-- 32kB Base64 representation of another PNG --",
},
{
"id": 456,
"shoe_size": 42,
"show_image": "-- 32kB Base64 representation of a different PNG --",
},
}
27. JSON Class Representation
{
"id": [314,42,456],
"shoe_sizes": [42,42,42],
"show_images": [
"-- 32kB Base64 representation of a PNG --",
"-- 32kB Base64 representation of another PNG --",
"-- 32kB Base64 representation of a different PNG --"
]
}
31. Process
1.Create schema
2.Compile schema with flatc compiler
3.Import generated files into your project
4.Read from byte[]:
java.nio.ByteBuffer buf = builder.dataBuffer();
// Deserialize the data from the buffer.
33. Any Questions?
● +: Networking Debt.
● A: CPU
○ Theory
○ Practice
● B: Battery
○ Theory
○ Practice
10/08/2016
CPU & Battery
34. Part A: CPU
A
“Tears come from the heart and not from the brain. ”
Leonardo Di Vinci
35. Understanding CPU
- How does my phone know Java?
- Big-O Notation and an intro to Data Structures
- Auto-Boxing
- Optimized Data Structures (Sparse Arrays and Maps)
- Things we can’t control
36. But before we begin,
something totally unrelated..
What is Eyjafjörður?
38. Build → Execute
On your PC, Gradle does a really complicated
Build process, that takes the Java Code and
Turns it into an APK.
We’ll go into what it does,
So we can appreciate the beauty.
39. Build → Execute
Simplified Walkthrough the build:
A. Manifest Merging
B. AAPT goes over the RES file and produces R.java and resources
C. Javac takes the code and produces a JAR file
D. ProGuard optimizes the JAR(s)
E.Dx takes the JAR(s) and produces a DEX file
F. AAPT takes everything (+ the Manifest), signs it and packs it to an APKRead more: https://developer.android.com/studio/build/index.html
40. The APK is unzipped on the device.
The customized Java Runtime loads and executes your code.
Build → Execute
If KitKat (4.4) and below
DALVIK
If Lollipop and above
ART
42. Build → Execute: Dalvik
Dalvik is a VM that..:
- uses dex (and odex) files to run programs.
Thanks, DEX, for using a short to index the method table. #65K
- Instead of being Stack based (Like the JVM), it is Register based.
- It’s main idea:
Being optimized for low memory consumption.
43. Build → Execute: Dalvik
And then there was Froyo (2.2)
Google added an amazing ability,
called JIT compiling (by trace).
JIT - Compile parts (~by trace) of the “ByteCode” to Machine-Code.
Performance was better - but the optimization options were limited.
44. Runtime-Perf: What to measure?
These are some of the KPIs for the Runtime:
- Performance
- App Startup Time
- Jank
- Battery Footprint
- Memory Footprint
45. Build → Execute: Art
The Art (~Android Runtime) uses the same dx format,
But instead of JIT-Compiling, uses AOT-Compiling.
When installing an app, the phone compiles the entire dex to
machine-code, and binds (statically link) whatever it needs
to the framework.
46.
47.
48. Build → Execute: Art
In N, ART does both JIT and AOT.
It profiles your code, and decides which
methods it should compile.
Since compilation is not a trivial task, it does it
only when the device is 100% charged and
connected to the charger.
Read: In Nougat, connecting your phone to a charger makes it work faster.
49. So, Is your phone a computer or not?
Why Yes:
It has a CPU, Memory, GPU, an OS,
It runs Java
Why No:
Not the same VM,
Not the same amounts of CPU, Memory,
Not the same usage patterns and expectations.
51. Big-O and Data Structures
This is what we were taught in Intro2CS, DataStructures, and etc.:
- Considering very large inputs (limn->∞) and ignore constants
- The Big O Notation: “1.02n” >> “n3 + 5n2” === “30n3” > “1000n2”
- Counting operations
- Accessing a memory cell by address is O(1)
Loops on some input are O(n),
- Trade-off Everything
53. Big-O and Data Structures
Some rules still apply in mobile:
- Use the right algorithm,
- Use the right data-structure,
- Be Smart
Don’t forget that this is a mobile device.
54. Storing a list of numbers
You need to store n integers.
If you know what n is, use an array.
If you don’t - What do you do?
(Support insert-last
and get operation)
55. Possible Solution:
Create an array-like interface:
int get(int index)
void insertLast(int value)
Guess or get an initial size, and if needed,
Create a new array with more room,
copy the items, and use the new array.
Discuss.
56. Possible Solution, Now with Generics:
Create an array-like interface:
T get(int index)
void insert(T value, int index)
This is also called an ArrayList<T>.
Are there any
implications? Discuss.
57. How Generics Work
In Java,
The compiler translates your <T>s to Objects, and adds casting as
necessary.
So, you can’t use int (or boolean, or double, or long, …), so instead,
you use Integer (or Boolean, Double, or Long), which do the same
thing, more or less.
58. Now, consider these codes
int i = 5;
Integer i = 5;
int j = i + 2;
Integer j = i + 2;
What do these compile to?
59. Now, consider these codes
int i = 5;
Integer i = 5;
int j = i + 2;
Integer j = i + 2;
public void noBoxing();
Code:
0: iconst_5
1: istore_1
2: iload_1
3: iconst_2
4: iadd
5: istore_2
public void withBoxing();
Code:
0: iconst_5
1: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
4: astore_1
5: aload_1
6: invokevirtual #3 // Method java/lang/Integer.intValue:()I
9: iconst_2
10: iadd
11: invokestatic #2 // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
14: astore_2
15: return
60. Now, consider this code
ArrayList<Integer> list =
new ArrayList<Integer>();
list.add(1);
list.add(2);
Same issue.
61. Now, consider this code
ArrayList<Integer> list = new ArrayList<Integer>();
For (int i = 0; i++; i < list.size()){
int value = list.get(i);
}
Same issue.
62. AutoBoxing
To handle previous code samples,
The runtime automagically takes your int, puts it inside a box, called
Integer and stores it in the heap.
This is AutoBoxing.
Colt McAnlis: https://youtu.be/dgzOwuoXVJU
65. Storing a list of objects, by Key
You need to store n objects, by key.
If you know what n is, use an array.
If you don’t - What do you do?
(Support an insert and get operations)
66. Storing a list of objects, by Key
Consider this API:
void insert(key, value)
int get(key)
67. What’s in a key?
Consider this task:
You have a list of devices that you want to retrieve by their IMEI.
Here’s a sample IMEI: 53865487920334156 (17 digits)
It doesn’t make sense to have an array with 1017 cells…
Same for Creditcards, ID numbers, GUIDs, and mostly anything that has an id and there’s a lot of it in the world, and you
will not need them all
68. Here’s what we’ll do
- Squash the key to something we can handle (~HashCode),
Store according to the key
- Handle Conflicts somehow (Open-hash / Closed-hash)
- Handle resizing somehow
- If we add Generics, This will be called
java.util.HashMap<TKey, TValue>
69. Is it the right algorithm?
- Inserting: Amortized O(1), but up to O(n)
- Searching: Amortized O(1), but up to O(n)
- Memory Consumption - Not so good.
70. What’s wrong with it?
- If you’re using Integers or Longs (IMEIs), for keys or for values,
you might hit AutoBoxing.
- The “Entry” class (internal implementation detail) is another layer
of abstraction that gets allocated that we don’t need.
- Compacting and Expending are expensive
71. HashMap solution 1: ArrayMaps
ArrayMaps (from android.util) use a different algorithm:
It uses 2 arrays - one for the values and the keys, and one for the
hashes, which is kept sorted.
Colt McAnlis: https://youtu.be/ORgucLTtTDI
72. HashMap solution 1: ArrayMaps
ArrayMaps (from android.util) use a different algorithm:
It uses 2 arrays - one for the values and the keys, and one for the
hashes, which is kept sorted.
Insertion - O(n)
Searching - O(log n)
Colt McAnlis: https://youtu.be/ORgucLTtTDI
73. HashMap solution 1: ArrayMaps
ArrayMaps (from android.util) use a different algorithm:
It uses 2 arrays - one for the values and the keys, and one for the
hashes, which is kept sorted.
Insertion - O(n)
Searching - O(log n)
Memory consumption - much better, but autoboxing is still an issue
Colt McAnlis: https://youtu.be/ORgucLTtTDI
74. HashMap Solution #1: ArrayMaps
This data-structure is useful on mobile for 2 use-cases:
75. HashMap solution 2: SparseArrays and co.
Sparse Arrays are optimized for no-autoboxing, and use similar
algorithms for storage as ArrayMaps.
Use SparseArrays when the keys or the values are primitives (partial):
Colt McAnlis: https://youtu.be/I16lz26WyzQ
Key Type Value Type SparseArray
Integer Object SparseArray
Integer Boolean SparseBooleanArray
Long Object LongSparseArray
76. Important for job interviews
SparseArrays and Array-Maps:
GET - Requires binary search - O(log n)
INS - Require binary search and moving - O(n)
(and they also don’t retain order, נבלות)
77. Another “what does this compiles to”
Consider the following code:
// from Iterators.foo();
ArrayList<Foo> foos = new ArrayList<Foo>();
for (Foo foo : foos){
// … Do something with foo
}
78. public void foo();
Code:
0: new #2 // class java/util/ArrayList
3: dup
4: invokespecial #3 // Method java/util/ArrayList."<init>":()V
7: astore_1
8: aload_1
9: invokevirtual #4 // Method java/util/ArrayList.iterator:()Ljava/util/Iterator;
12: astore_2
13: aload_2
14: invokeinterface #5, 1 // InterfaceMethod java/util/Iterator.hasNext:()Z
19: ifeq 35
22: aload_2
23: invokeinterface #6, 1 // InterfaceMethod java/util/Iterator.next:()Ljava/lang/Object;
28: checkcast #7 // class Foo
31: astore_3
32: goto 13
35: return
What does it compile to? (In Bytecode)
79. Now, Let’s compare
public void baz(){
ArrayList<Foo> foos = new ArrayList<Foo>();
int size = foos.size();
for (int i = 0; i < size; i++){
Foo foo = foos.get(i);
// Do something with foo...
}
}
81. Hmm. Android vs. Java?
- Java: use for(int i : list) because that’s how we do
it in java.
- Android: do what Java says, especially if you’re using
an iterator. https://developer.android.com/training/articles/perf-
tips.html#Loops
- Colt McAnlis:
Use a CS101 for loop, avoid the iterator if possible.
See for yourself: https://youtu.be/MZOf3pOAM6A
82. One thing we can’t control
Android can change the speed of the CPU to conserve battery.
Slower CPU ⇒ Battery lasts longer
This might cause 2 symptoms:
- Dropped frames (it takes 20ms for the CPU to speed-up again)
- Normal things take longer
ThisColt McAnlis: https://youtu.be/c8u3fEM3JG0
84. Any Questions?
● +: Networking Debt.
● A: CPU
○ Theory
○ Practice
● B: Battery
○ Theory
○ Practice
10/08/2016
CPU & Battery
85. A recent study showed that 100% of your users don’t use
your app when their battery is out of juice.
The Battery
B
86. Understanding Battery
- Battery theory
- As A Developer, How to reduce battery usage
- As ANDROID, How to reduce battery usage
87. Measurement Units
Ampere (A) is a unit of electric current.
It describes how much power
something needs at an instant.
Milli-Ampere (mA) is the unit that
we actually use, because it’s a mobile
device, and things don’t use a lot of power.
Example: My GPS needs 140mA, and my 4G chip needs 180mA.
https://en.wikipedia.org/wiki/Ampere
88. Measurement Units
However, it doesn’t take time into considerations -
That’s why we use mAh.
Example:
Nexus 5X battery is 2,700 mAh
https://en.wikipedia.org/wiki/Ampere-hour
89. Battery Theory
My GPS needs 140mA, and my 4G chip needs 180mA.
Which is better for getting a location:
using the GPS or the 4G chip?
90. Battery Theory
My GPS needs 140mA, and my 4G chip needs 180mA.
Getting a GPS lock takes about 25 seconds, so:
25s x 140mA ~= 1mAh
91. Battery Theory
My GPS needs 140mA, and my 4G chip needs 180mA.
Getting network location lock takes about 2 seconds, so:
2s x 180mA ~= 0.1mAh
Jeffrey Sharkey: https://youtu.be/OUemfrKe65c (From Google I/O 2009)
92. So, What’s killing your battery?
The
Screen
The
Modem
The
GPS
Foreground work Background work
94. So what can you do?
Taste of what’s possible: https://developer.android.com/reference/android/app/job/JobInfo.Builder.html
Reduce
Keep
background
activity to
minimum
Defer
Wait with the
activity until the
device is
charging
Coalesce
Try to piggy-back,
batch, queue or group
background work with
other background
tasks that has to be
done
95. The battery and the Radio
True or false:
3G and WIFI need (more or less)
the same amount of power ~180 mAh
96. The battery and the Radio
However, downloading 100mb
via 3G radio takes 1’56’’
and via WIFI 0’10’’
180mAh x 10sec = 0.5 mAh
180mAh x 116sec = 5.8 mAh
97. The battery and the Radio
Also:
- Radio wake-up costs a lot of power
- Radio has to stay awake for responses (and responses of responses)
- Radio goes to sleep after about ~20sec of activity.
Dive Deeper: Ran Nachmani @ Big Android BBQ 2015: https://youtu.be/LO_Swql0zVg
98. The battery and the Radio
So what can you do?
I/O 2016: https://youtu.be/VC2Hlb22mZM
Reduce Defer Coalesce
- If it’s not important - Don’t
- Reduce payload (GZIP, FlatBuffers)
- Use the JobScheduler to wait for
- Charger
- WIFI
- Piggy-back with
SyncAdapters
- Prefetch and Batch
Change usage pattern according to network state!
99. Tool: DDMS / ADM
The Android Device Monitor can really help in understanding what the
network is doing.
101. GPS in action
Your device can find its locations using 3 devices:
- The GPS, which uses few satellites for exact location.
- The 3G network that uses cell-tower triangulation.
- Some WIFI networks can also hint of where you are.
Each of these is a location provider.
102. Most use the Fused Location Provider from Google Play services.
It merges all location providers for bests results and optimal
footprint.
protected void createLocationRequest() {
LocationRequest mLocationRequest = new LocationRequest();
mLocationRequest.setInterval(10000);
mLocationRequest.setFastestInterval(5000);
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
}
GPS in action
https://developer.android.com/training/location/change-location-settings.html
103. GPS in action
True or false:
You might be updated on location
More frequent than you ask.
104. The battery and the GPS
We already talked about using the GPS vs the 3G data.
What else can we do?
More: Colt McAnlis: https://youtu.be/81W61JA6YHw
Reduce Defer Coalesce
- Ask for less accurate location
- Ask for less updates
- Limit number of callbacks
- Ask for less updates - Piggy-back other GPS
requests
105. Reduce the location battery footprint
of your app.
Set the priority for the accuracy you need.
PRIORITY_LOW_POWER (~10km "city" accuracy)
PRIORITY_BALANCED_POWER_ACCURACY (~100m "block" accuracy)
PRIORITY_HIGH_ACCURACY (accurate as possible at the expense of
battery life)
The battery and the GPS
https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest
Reduce
- Ask for less accurate location
- Ask for less updates
- Limit number of callbacks
106. The battery and the GPS
Reduce the location battery footprint
of your app.
Set the interval as high as you can.
mLocationRequest.setInterval(10000);
https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest
DeferReduce
- Ask for less accurate location
- Ask for less updates
- Limit number of callbacks
107. The battery and the GPS
Reduce the location battery footprint
of your app.
Also limit the number of callbacks.
mLocationRequest.setFastestInterval(5000);
https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest
Reduce
- Ask for less accurate location
- Ask for less updates
- Limit number of callbacks
108. The battery and the GPS
Reduce the location battery footprint
of your app.
Use PRIORITY_NO_POWER to passively listen for location updates
from other clients.
https://developers.google.com/android/reference/com/google/android/gms/location/LocationRequest
- Piggy-back other GPS requests
Coalesce
112. Wasting screen / cpu energy
Sometimes, you want to keep the device awake to do some work.
Perhaps you want the screen to stay on while watching a video, or wake-up from sleep to calculate
something periodically.
This can be done with WakeLocks:
PowerManager powerManager = (PowerManager) getSystemService(POWER_SERVICE);
WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
"MyWakelockTag");
wakeLock.acquire();
Training: https://developer.android.com/training/scheduling/wakelock.html
Colt McAnlis: https://youtu.be/reMau7d0yeg
113. Wasting screen / cpu energy
However, it’s really important to handle WakeLocks with care.
- Beware of dependencies
(User data, server faults, etc.)
- Always use a timeout
Training: https://developer.android.com/training/scheduling/wakelock.html
Colt McAnlis: https://youtu.be/reMau7d0yeg
114.
115. Short story
Friday, ~8:00AM
My phone has ~22%
Mr. Levin: “Put it on the floor in your bag, don’t touch it,
and let it go into DOZE.”
117. Doze
Introduced with Marshmallow (6.0, API 23),
https://developer.android.com/training/monitoring-device-state/doze-standby.html
118. Doze
When the device is in this state:
- Network access is suspended
- The device ignores wake locks
- Alarms (a la AlarmManager) don’t get execute (unless While-Idle or setAlarmClock)
- No SyncAdapters or JobSchedulers
- System also does not do Wifi Scans
https://developer.android.com/training/monitoring-device-state/doze-standby.html
121. If you have a problem with Doze, It means that you have a problem
with a simple fact:
Your users have life
They might forget their tablet at home when they leave for a 3 days
trip to Amsterdam, and would love for it to have battery when they
come back from their trip.
#TrueStory #FML
Doze
Joanna Smith, Big Android BBQ 2015: https://youtu.be/Rwshwq_vI1s
122. Doze
Besides that,
Don’t do anything.
If you’re using all the stuff we taught, you should be good
- SyncAdapters, JobSchedulers will work as expected.
- Alarms are to be watched, and other network access too.
Joanna Smith, Big Android BBQ 2015: https://youtu.be/Rwshwq_vI1s
123. Doze
These are the states that the phone can be in:
Joanna Smith, Big Android BBQ 2015: https://youtu.be/Rwshwq_vI1s
Active Inactive
Idle
Pending
Idle Idle
Maintenance
This transition takes ~2h
Remember my story? About a 45m lecture?
124. Doze
In Android Nougat,
The terms for entering Doze were loosened.
This means that even while the device is in the user’s
pocket it can go into Doze. Still same principle apply:
Don’t do anything about it.