Guide to Improving Compose Performance

Transcript

1. Mohit Sarveiya Guide to Improving Compose Performance @heyitsmohit Google Developer Expert in Kotlin & Android
2. Guide to Improving Compose Performance • Recomposition performance
3. Guide to Improving Compose Performance • Recomposition performance • Compiler Plugin Internals
4. Guide to Improving Compose Performance • Recomposition performance • Compiler Plugin Internals • Compiler Plugin Tests
5. Guide to Improving Compose Performance • Recomposition performance • Compiler Plugin Internals • Compiler Plugin Tests • Experimental features
6. Guide to Improving Compose Performance Performance Tip: Avoid premature optimizations
7. Guide to Improving Compose Performance Measure Improve Inspect
8. Performance Impacts • Initial Composition time
9. Performance Impacts • Initial Composition time • Layout performance
10. Performance Impacts • Initial Composition time • Layout performance • Recomposition performance
11. Composition Layout Draw Column Row Image Text Image
12. Composition Layout Draw Column Row Text Image Image
13. Composition Layout Draw Travel Row Column 100 pictures 10 videos
14. Guide to Improving Compose Performance Composition Layout Draw
15. Understanding Stability
16. Stability • Allows us to skip execution of a composable body
17. Stability @Composable fun UsersScreen(modifier: Modifier, users: List<UserModel>) { Column { users.forEach { model -> User(model) } } }
18. Stability @Composable fun UsersScreen(modifier: Modifier, users: List<UserModel>) { Column { users.forEach { model -> User(model) } } }
19. Stability @Composable fun UsersScreen(modifier: Modifier, users: List<UserModel>) { Column { users.forEach { model -> UserRow(model) } } } @Composable fun UserRow(model: UserModel)
20. Stability data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime )
21. Stability Frame 1 Frame 2 Frame 3
22. Stability Frame 1 Frame 2 Frame 3 Frame 4 Recompose UsersScreen
23. Stability Frame 1 Frame 2 Frame 3 Frame 4 Recompose UsersScreen Recomposition count increase
24. What makes a type stable? • Immutability
25. What makes a type stable? • Immutability • Observable mutability (e.g. MutableState)
26. Stability data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) Mutable
27. Stability data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) List
28. Stability data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) Unstable
29. Stability Under the Hood • What are the implications of using unstable types?
30. Stability Under the Hood @Composable fun UsersScreen(…) { … } @Composable fun UserRow() { … } data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) Compose Compiler Plugin Transformed IR
31. Stability Under the Hood @Composable fun UsersScreen(modifier: Modifier, users: List<UserModel>) { Column { users.forEach { model -> UserRow(model) } } } @Composable fun UserRow(model: UserModel)
32. @Composable fun UsersScreen(users, %composer: Composer?, %changed: Int) { }
33. @Composable fun UsersScreen(users, %composer: Composer?, %changed: Int) { } %composer = %composer.startRestartGroup()
34. @Composable fun UsersScreen(users, %composer: Composer?, %changed: Int) { } if (%changed) { %dirty = %dirty or if (%composer.changedInstance(users)) } %composer = %composer.startRestartGroup()
35. @Composable fun UsersScreen(users, %composer: Composer?, %changed: Int) { … } … if (dirty and !%composer.skipping) { items.forEach { model: UserModel -> … } } %composer.endRestartGroup() ?. updateScope { %composer: Composer? -> UsersScreen(users, composer,…) } Recomposition scope
36. Unstable data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime )
37. @Composable fun UsersScreen(users, %composer: Composer?, %changed: Int) { } if (%changed and 0b0110 == 0) { %dirty = %dirty or if (%composer.changedInstance(users)) } if (dirty and !%composer.skipping) { … } %composer = %composer.startRestartGroup( <> ) Bit masking
38. @Composable fun UsersScreen(users, %composer: Composer?, %changed: Int) { } if (%changed and 0b0110 == 0) { %dirty = %dirty or if (%composer.changedInstance(users)) } if (dirty and !%composer.skipping) { … } %composer = %composer.startRestartGroup( <> ) enum class StabilityBits(val bits: Int) { UNSTABLE(0b100), STABLE(0b000); fun bitsForSlot(slot: Int): Int }
39. @Composable fun UsersScreen(users, %composer: Composer?, %changed: Int) { } if (%changed and 0b0110 == 0) { %dirty = %dirty or if (%composer.changedInstance(users)) } if (dirty and !%composer.skipping) { … } %composer = %composer.startRestartGroup( <> ) Instance Equality for unstable types
40. Stable Param class Model(val value: Int = 0) @Composable fun Test(state: Model) { A(state) }
41. Stable Param class Model(val value: Int = 0) @Composable fun example(state: Model) { A(state) }
42. Stable Param @Composable fun example(state, %composer) { %composer = %composer.startRestartGroup() … if (%changed) { %dirty = %dirty or if (%composer.changed(state)) 0b0100 else 0b0010 } … %composer.endRestartGroup() }
43. Stable Param @Composable fun example(state, %composer) { %composer = %composer.startRestartGroup( <> ) … if (%changed) { %dirty = %dirty or if (%composer.changed(state)) 0b0100 else 0b0010 } … %composer.endRestartGroup() } Equality check
44. Unskippable Conditions • Stable parameters have differences from last execution
45. Unskippable Conditions • Stable parameters have differences from last execution • If the composer.skipping call returns false
46. Unskippable Conditions • Stable parameters have differences from last execution • If the composer.skipping call returns false • Provided parameters to the function were unstable
47. Unskippable Composable @Composable fun UsersScreen(users: List<UserModel>) restartable fun UsersScreen( unstable users: List<UserModel> )
48. How to Analyze • Stable & Unstable types • Restartable and Skippable functions
49. Compiler Report @Composable fun UsersScreen(…) { … } @Composable fun UserRow() { … } data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) Compose Compiler Plugin Metrics
50. Compiler Report Module Metrics Class Stability Transformer Composer Lamba Memoization Composable Function Body Transformer Composable Param Transformer
51. Compiler Report interface ModuleMetrics { fun recordFunction( ... ) fun recordClass( ... ) fun recordLambda( ... ) fun saveMetricsTo( ... ) }
52. Compiler Report class ModuleMetricsImpl(var name: String) : ModuleMetrics { var skippableComposables = 0 var restartableComposables = 0 var readonlyComposables = 0 var markedStableClasses = 0 var inferredStableClasses = 0 var inferredUnstableClasses = 0 ... }
53. Compiler Report Inferred Stable Classes Marked Stable Classes Inferred Unstable Classes 70 0 Total Classes 61 9 Memoized Lambdas 76 Inferred Uncertain Classes 15
54. Compiler Report kotlinOptions { freeCompilerArgs += [ "-P", “plugin:…kotlin:reportsDestination=“ + buildDir.absolutePath + "/compose_metrics" ] }
55. Compiler Report (CI) Release Build Compiler Report Compare with Previous Stats
56. Compiler Report @Composable restartable fun UsersScreen(…, unstable users: List<UserModel>) @Composable fun UsersScreen(modifier: Modifier, users: List<UserModel>)
57. Stability Under the Hood • How is stability determined?
58. Stability Under the Hood @Composable fun Profile(modifier: Modifier, user: UserModel) { ... } data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime )
59. Stability Under the Hood data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) @StabilityInferred(parameters = 0) unstable class User { unstable name: String unstable friends: List<String> unstable lastLoggedIn: LocalDateTime } Class Stability Transformer
60. Stability Under the Hood @StabilityInferred(parameters = 0) unstable class User { unstable name: String unstable friends: List<String> unstable lastLoggedIn: LocalDateTime } data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) Synthesized Annotation
61. Stability Under the Hood Class Stability Transformer Stability Inferencer
62. Stability Under the Hood Stability Class Stability Transformer Stability Inferencer
63. Stability Under the Hood sealed class Stability { class Certain(…) : Stability() class Parameter(…) : Stability() class Combined(…) : Stability() class Runtime(…) : Stability() class Unknown(…) : Stability() … } Internal to Compiler
64. Stability Under the Hood sealed class Stability { class Certain(…) : Stability() class Parameter(…) : Stability() class Combined(…) : Stability() class Runtime(…) : Stability() class Unknown(…) : Stability() … }
65. Stability Under the Hood sealed class Stability { class Certain(…) : Stability() class Parameter(…) : Stability() class Combined(…) : Stability() class Runtime(…) : Stability() class Unknown(…) : Stability() … }
66. Stability Under the Hood unstable class User { unstable name: String unstable friends: List<String> unstable lastLoggedIn: LocalDateTime } Stability.Certain(false)
67. Stability Under the Hood unstable class User { unstable name: String unstable friends: List<String> unstable lastLoggedIn: LocalDateTime } Stability.Runtime
68. Compiler Report Inferred Stable Classes Marked Stable Classes Inferred Unstable Classes 70 0 Total Classes 61 9 Memoized Lambdas 76 Inferred Uncertain Classes 15
69. Stability Under the Hood class StabilityInferencer( ... ) { fun stabilityOf( declaration: IrClass ): Stability { ... } } What are the rules for stability?
70. Stability Under the Hood fun stabilityOf( declaration: IrClass ): Stability { val fqName = declaration.fqNameWhenAvailable if (KnownStableConstructs.stableTypes.contains(fqName)) { stability = Stability.Stable } }
71. Stability Under the Hood fun stabilityOf( declaration: IrClass ): Stability { val fqName = declaration.fqNameWhenAvailable if (KnownStableConstructs.stableTypes.contains(fqName)) { stability = Stability.Stable } } Known Stable Types
72. Known Stable Types • Primitive types • Pair, Triple • Comparator, ClosedRange, • Result
73. Stability Under the Hood class Foo<T>(val a: List<T>)
74. Stability Under the Hood // Stability.Certain(false) class Foo<T>(val a: List<T>)
75. Known Stable Types • Guava Collections • Kotlinx Immutable Collections • Dagger Lazy
76. Stability Under the Hood message User name: String location: String lastLoggedIn: LocalDataTime } @Composable fun Profile(modifier: Modifier, user: User) { ... } Protobuff
77. Stability Under the Hood @Composable fun Profile(modifier: Modifier, user: User) { ... } message User name: String location: String lastLoggedIn: LocalDataTime } import com.google.protobuf.GeneratedMessageLite
78. Stability Under the Hood @Composable restartable fun Profile(modifier: Modifier, unstable user: User) { ... } message User name: String location: String lastLoggedIn: LocalDataTime } import com.google.protobuf.GeneratedMessageLite
79. https: / / / androidx/platform/frameworks/support/ Compose
80. Stability Under the Hood fun IrClass.isProtobufType(): Boolean { val directParentClassName = superTypes.lastOrNull { … }.fqNameWhenAvailable return directParentClassName == "com.google.protobuf.GeneratedMessageLite" || directParentClassName == "com.google.protobuf.GeneratedMessage" }
81. Stability Under the Hood fun IrClass.isProtobufType(): Boolean { val directParentClassName = superTypes.lastOrNull { … }.fqNameWhenAvailable return directParentClassName == "com.google.protobuf.GeneratedMessageLite" || directParentClassName == "com.google.protobuf.GeneratedMessage" }
82. Stability Under the Hood interface Foo { val value: Int }
83. Stability Under the Hood fun stabilityOf( declaration: IrClass ): Stability { }
84. Stability Under the Hood fun stabilityOf( declaration: IrClass ): Stability { ... if (declaration.isInterface) { return Stability.Unknown(declaration) } }
85. Stability Under the Hood class A class B class Foo(val pair: Pair<A, B>)
86. Stability Under the Hood // Stability.Runtime class A class B class Foo(val pair: Pair<A, B>)
87. Stable Markers Performance Tip: Use @Stable or @Immutable markers
88. Stable Markers unstable class User { unstable name: String unstable friends: List<String> unstable lastLoggedIn: LocalDateTime } data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime )
89. Stability Markers fun stabilityOf( declaration: IrClass ): Stability { if (declaration.hasStableMarkedDescendant()) { return Stability.Stable } … }
90. Stability Markers fun stabilityOf( declaration: IrClass ): Stability { if (declaration.hasStableMarkedDescendant()) { return Stability.Stable } … } Stability Marker Check
91. Stability Markers • @Stable • @Immutability
92. Stability Markers @Stable data class UserModel( val name: String, val friends: ImmutableList<User>, val lastLoggedIn: LocalDateTime )
93. Stability Markers @StabilityInferred(parameters = 3) stable class UserModel { stable name: String stable friends: ImmutableList<String> stable lastLoggedIn: LocalDateTime }
94. Stability Markers @Composable restartable fun Profile(…, stable user: UserModel) @Composable fun Profile(modifier: Modifier, user: UserModel) { ... }
95. Stability Markers @Composable restartable skippable fun Profile(…, stable user: UserModel) @Composable fun Profile(modifier: Modifier, user: UserModel) { ... }
96. Stability Module A (Compose) Module B (Compose not enabled) Unstable
97. Stability Under the Hood • How is stability tested?
98. Stability Under the Hood data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) @StabilityInferred(parameters = 0) unstable class User { unstable name: String unstable friends: List<String> unstable lastLoggedIn: LocalDateTime } Stability Inferencer
99. Testing Stability data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) Compose Compiler Plugin @Composable fun Profile( ... ) IR
100. Testing Stability data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) @Composable fun Profile( ... ) K1Compiler Facade K2Compiler Facade
101. Testing Stability class K2CompilerFacade { ... fun compileToIr(source): IrModuleFragment ... }
102. Testing Stability class Foo<T>( val x: kotlinx.collections.immutable.ImmutableList<T> )
103. Testing Stability val irModule = compileToIr(source) val stabilityInferencer = StabilityInferencer(irModule.descriptor) val classStability = stabilityInferencer.stabilityOf(irClass) // Stability.Stable
104. Testing Stability val irModule = compileToIr(source) val stabilityInferencer = StabilityInferencer(irModule.descriptor) val classStability = stabilityInferencer.stabilityOf(irClass) // Stability.Stable
105. Testing Stability val irModule = compileToIr(source) val stabilityInferencer = StabilityInferencer(irModule.descriptor) val classStability = stabilityInferencer.stabilityOf(irClass) // Stability.Stable
106. Testing Stability @Test fun testSingleValPrimitiveIsStable() = assertStability( "class Foo(val value: Int)", "Stable" ) Utility converts to IR
107. Testing Stability @Test fun testSingleValPrimitiveIsStable() = assertStability( "class Foo(val value: Int)", "Stable" )
108. Strategies • Use stable types
109. Strategies • Use stable types • Use @Stable or @Immutable markers
110. Strategies • Use stable types • Use @Stable or @Immutable markers • Mark NonRestartableComposable for “root”
111. Guide to Compose Performance Performance Tip: Mark NonRestartableComposable for “root” Composables.
112. Non Restartable Composable @Composable fun example(model: Unstable) { remember(model) { 1 } }
113. Non Restartable Composable @Composable fun example(model: Unstable) { remember(model) { 1 } } restartable fun example(unstable model: Unstable)
114. Non Restartable Composable @Composable fun example(model: Unstable, %composer: Composer?, %changed: Int) { %composer.startRestartGroup() val tmp0_group = %composer.cache(%composer.changed(model)) { 1 } ... %composer.endRestartGroup().updateScope({…}) }
115. Non Restartable Composable @Composable fun example(model: Unstable, %composer: Composer?, %changed: Int) { %composer.startRestartGroup() val tmp0_group = %composer.cache(%composer.changed(model)) { 1 } ... %composer.endRestartGroup().updateScope({…}) }
116. Non Restartable Composable @Composable @NonRestartableComposable fun example(model: Unstable) { remember(model) { 1 } }
117. Non Restartable Composable @Composable @NonRestartableComposable fun example(model: Unstable) { remember(model) { 1 } } fun example(unstable model: Unstable) Not restartable nor skippable
118. Non Restartable Composable @Composable fun example(model: Unstable, %composer: Composer?, %changed: Int) { val tmp0_group = %composer.cache(%composer.changedInstance(model)) { 1 } ... } No restart group created
119. ! Only apply NonRestartableComposable to Composable not reading state value.
120. Experimental Features
121. Strong Skipping • Enabled in Compose 1.7 alpha
122. Strong Skipping tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>() { compilerOptions.freeCompilerArgs.addAll( "-P", "…featureFlag=StrongSkipping" ) }
123. Without Strong Skipping @Composable fun Profile(modifier: Modifier, user: User) { ... } restartable fun Profile( stable modifier: Modifier? = @static Companion unstable user: User ) Only restartable
124. With Strong Skipping @Composable fun Profile(modifier: Modifier, user: User) { ... } restartable skippable fun Profile( stable modifier: Modifier? = @static Companion unstable user: User ) All restartable functions are skippable
125. Strong Skipping • Unstable —> Instance Equality • Stable —> Object Equality
126. @Composable fun Profile(user, %composer: Composer?, %changed: Int) { } if (%changed and 0b0110 == 0) { %dirty = %dirty or if (%composer.changedInstance(users)) } if (dirty and !%composer.skipping) { … } %composer = %composer.startRestartGroup( <> ) enum class StabilityBits(val bits: Int) { UNSTABLE(0b100), STABLE(0b000); fun bitsForSlot(slot: Int): Int }
127. Strong Skipping (Opt out) @Composable @NonSkippableComposable fun Profile(modifier: Modifier, user: User) { ... }
128. Strong Skipping Lambdas class Unstable(var value: Int = 0) @Composable fun example() { val unstableObject = Unstable(0) val lambda = { unstableObject } }
129. Strong Skipping Lambdas @Composable fun example(%composer: Composer?, %changed: Int) { … if (%changed) { val foo = Unstable(0) val lambda = %composer.cache( %composer.changedInstance(unstableObject)) { { unstableObject } } … } Memoize Lambda
130. Strong Skipping Lambdas (Opt out) class Unstable(var value: Int = 0) @Composable fun example() { val unstableObject = Unstable(0) val lambda = @DontMemoize { unstableObject } }
131. Strong Skipping Lambdas (Opt out) @Composable fun example(%composer: Composer?, %changed: Int) { ... if (%changed) { val unstableObject = Unstable(0) val lambda = { { unstableObject } } } ... } Not Memoized
132. Strong Skipping tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>() { compilerOptions.freeCompilerArgs.addAll( "-P", "…featureFlag=StrongSkipping" ) }
133. • Undocumented feature flag Non Skipping Group Optimization
134. • Before turning on feature flag Non Skipping Group Optimization
135. Non Restartable Composable @Composable @NonRestartableComposable fun example(model: Unstable)
136. @Composable @NonRestartableComposable fun example(model, %composer: Composer?) { } %composer = %composer.startReplaceGroup() gets a replace group placed around the body
137. @Composable @NonRestartableComposable fun example(model, %composer: Composer?) { } %composer = %composer.startReplaceGroup() if (%changed) { %dirty = %dirty or if (%composer.changedInstance(…)) } Never calls `$composer.changed( ... )` with its parameters
138. @Composable @NonRestartableComposable fun example(model, %composer: Composer?) { } %composer = %composer.startReplaceGroup() if (show) { %composer.startMoveableGroup() … %composer.endMovableGroup() } Proper groups around control flow
139. • After turning on feature flag Non Skipping Group Optimization
140. @Composable @NonRestartableComposable fun example(model, %composer: Composer?) { } %composer = %composer.startReplaceGroup() if (show) { %composer.startMoveableGroup() … %composer.endMovableGroup() } Not necessary
141. @Composable @NonRestartableComposable fun example(model, %composer: Composer?) { … } Never omit if (show) { %composer.startMoveableGroup() … %composer = %composer.endMovableGroup() }
142. • Strong skipping • Non Skipping Group Optimization Experimental features
143. Guide to Improving Compose Performance Performance Tip: Reduce recompositions by reusing moveContentOf
144. moveableContentOf val content = remember { content } if (showVertical) { Column { content() } } else { Row { content() } }
145. moveableContentOf val content = remember { content } if (portrait) { Column { content() } } else { Row { content() } }
146. moveableContentOf val content = remember { moveableContentOf(content) } if (showVertical) { Column { content() } } else { Row { content() } }
147. moveableContentOf • Nodes are preserved.
148. moveableContentOf Column Content Text Image
149. moveableContentOf Row Content Text Image
150. moveableContentOf • Moves all remembered state.
151. Inside Compiler Plugin Compose Compiler Plugin Test Recompositions val content = remember { content } if (showVertical) { Column { content() } } else { Row { content() } }
152. Inside Compiler Plugin interface CompositionTestScope : CoroutineScope { fun compose(block: @Composable () -> Unit) fun revalidate() ... }
153. Inside Compiler Plugin val content = movableContentOf { val privateState = remember { mutableStateOf(0) } Text("Heading") Text("Content") }
154. Inside Compiler Plugin var portrait by mutableStateOf(false) val content = movableContentOf { val privateState = remember { mutableStateOf(0) } Text("Heading") Text(“Content") }
155. Inside Compiler Plugin @Composable fun example() { if (portrait) { Column { content() } } else { Row { content() } } }
156. Inside Compiler Plugin var lastPrivateState: State<Int> = mutableStateOf(0) var portrait by mutableStateOf(false) val content = movableContentOf { val privateState = remember { mutableStateOf(0) } lastPrivateState = privateState Text("Heading") Text(“Content") }
157. Inside Compiler Plugin interface CompositionTestScope : CoroutineScope { ... fun compose(block: @Composable () -> Unit) fun revalidate() ... }
158. Inside Compiler Plugin compose { val firstPrivateState = lastPrivateState Content() portrait = true Snapshot.sendApplyNotifications() revalidate() assertSame(firstPrivateState, lastPrivateState) }
159. Inside Compiler Plugin compose { val firstPrivateState = lastPrivateState example() portrait = true Snapshot.sendApplyNotifications() revalidate() assertSame(firstPrivateState, lastPrivateState) }
160. Inside Compiler Plugin compose { val firstPrivateState = lastPrivateState example() portrait = true Snapshot.sendApplyNotifications() revalidate() assertSame(firstPrivateState, lastPrivateState) }
161. Inside Compiler Plugin compose { val firstPrivateState = lastPrivateState example() portrait = true Snapshot.sendApplyNotifications() revalidate() assertSame(firstPrivateState, lastPrivateState) }
162. Inside Compiler Plugin compose { val firstPrivateState = lastPrivateState example() portrait = true Snapshot.sendApplyNotifications() revalidate() assertSame(firstPrivateState, lastPrivateState) }
163. Inside Compiler Plugin compose { val firstPrivateState = lastPrivateState example() portrait = true Snapshot.sendApplyNotifications() revalidate() assertSame(firstPrivateState, lastPrivateState) }
164. Inside Compiler Plugin var portrait by mutableStateOf(false) val content = movableContentOf { val privateState = remember { mutableStateOf(0) } lastPrivateState = privateState Text("Heading") Text(“Content") }
165. moveableContentOf • Nodes are preserved. • State is remembered as groups are moved.
166. Guide to Improving Compose Performance Performance Tip: Use derivedStateOf for frequently changing state
167. derivedStateOf @Composable fun Profile() { var shouldShowFab = remember(lazyListState.firstVisibleItemIndex) { lazyListState.firstVisibleItemIndex > 10 } if(shouldShowFab){ /* Display the floating action button */ } }
168. derivedStateOf @Composable fun Profile() { var shouldShowFab = remember(lazyListState.firstVisibleItemIndex) { lazyListState.firstVisibleItemIndex > 10 } if(shouldShowFab){ /* Display the floating action button */ } }
169. derivedStateOf @Composable fun Profile() { var shouldShowFab = remember(lazyListState.firstVisibleItemIndex) { lazyListState.firstVisibleItemIndex > 10 } if(shouldShowFab){ /* Display the floating action button */ } }
170. derivedStateOf Frame 1 Frame 2 Frame 3
171. derivedStateOf Profile Frame 1 Frame 2 Frame 3 Frame 4 Recompose Recomposition count increase Pro .. Pro. Pro. Pro. Pro. Pro. Pro. Pro. Pro.
172. derivedStateOf @Composable fun Profile() { var shouldShowFab = remember(lazyListState.firstVisibleItemIndex) { lazyListState.firstVisibleItemIndex > 10 } if(shouldShowFab){ /* Display the floating action button */ } } Value changes very frequently
173. derivedStateOf @Composable fun Profile() { val shouldShowFab = remember(lazyListState.firstVisibleItemIndex){ derivedStateOf { lazyListState.firstVisibleItemIndex > 10 } } … }
174. derivedStateOf fun <T> derivedStateOf( policy: SnapshotMutationPolicy<T>, calculation: () -> T, ): State<T>
175. derivedStateOf fun <T> derivedStateOf( policy: SnapshotMutationPolicy<T>, calculation: () -> T, ): State<T> How do we compare previous values?
176. Snapshot Mutation Policy • Referential Equality Policy • Structural Equality Policy
177. Inside Compiler Plugin @Composable fun UsersScreen(…) { … } @Composable fun UserRow() { … } data class UserModel( var name: String, val friends: List<User>, val lastLoggedIn: LocalDateTime ) Compose Compiler Plugin Test Snapshot changes
178. Inside Compiler Plugin class SnapshotStateObserver(…) { fun observeReads(…) fun start() fun stop() fun notifyChanges() … }
179. Inside Compiler Plugin class SnapshotStateObserver(…) { fun observeReads(…) fun start() fun stop() fun notifyChanges() … }
180. Inside Compiler Plugin fun runSimpleTest( block: (…) -> Unit ) { val stateObserver = SnapshotStateObserver { it() } try { stateObserver.start() block(stateObserver,…) Snapshot.sendApplyNotifications() } finally { stateObserver.stop() } }
181. Inside Compiler Plugin fun runSimpleTest( block: (…) -> Unit ) { val stateObserver = SnapshotStateObserver { it() } try { stateObserver.start() block(stateObserver,…) Snapshot.sendApplyNotifications() } finally { stateObserver.stop() } }
182. Referential Equality Policy runSimpleTest { stateObserver, _ -> val state = mutableStateOf(mutableListOf(1)) val derivedState = derivedStateOf(referentialEqualityPolicy()) { state.value } }
183. Referential Equality Policy runSimpleTest { stateObserver, _ -> val state = mutableStateOf(mutableListOf(1)) val derivedState = derivedStateOf(referentialEqualityPolicy()) { state.value } }
184. Referential Equality Policy runSimpleTest { stateObserver, _ -> val state = mutableStateOf(mutableListOf(1)) val derivedState = derivedStateOf(referentialEqualityPolicy()) { state.value } }
185. Referential Equality Policy runSimpleTest { stateObserver, _ -> … var changes = 0 stateObserver.observeReads(…, { changes ++ }) { derivedState.value } }
186. Referential Equality Policy runSimpleTest { stateObserver, _ -> val state = mutableStateOf(mutableListOf(1)) var changes = 0 stateObserver.observeReads(…, { changes ++ }) { derivedState.value } state.value = mutableListOf(1) } Update State
187. Referential Equality Policy runSimpleTest { stateObserver, _ -> val state = mutableStateOf(mutableListOf(1)) val derivedState = derivedStateOf(referentialEqualityPolicy()) { state.value } state.value = mutableListOf(1) } State will observe read due to ref check
188. Referential Equality Policy runSimpleTest { stateObserver, _ -> var changes = 0 stateObserver.observeReads(…, { changes ++ }) { derivedState.value } state.value = mutableListOf(1) assertEquals(1, changes) } Changes is updated
189. Referential Equality Policy runSimpleTest { stateObserver, _ -> var changes = 0 stateObserver.observeReads(…, { changes ++ }) { derivedState.value } state.value = mutableListOf(1) assertEquals(1, changes) }
190. Snapshot Mutation Policy • Referential Equality Policy • Structural Equality Policy
191. Structural Equality Policy runSimpleTest { stateObserver, _ -> val state = mutableStateOf(mutableListOf(1)) val derivedState = derivedStateOf(structureEqualityPolicy()) { state.value } }
192. Structural Equality Policy runSimpleTest { stateObserver, _ -> var changes = 0 stateObserver.observeReads(…, { changes ++ }) { derivedState.value } state.value = mutableListOf(1) assertEquals(0, changes) // changes = 0 } Value is not emitted by derived state
193. Structural Equality Policy runSimpleTest { stateObserver, _ -> var changes = 0 stateObserver.observeReads(…, { changes ++ }) { derivedState.value } state.value = mutableListOf(1) assertEquals(0, changes) // changes = 0 }
194. Guide to Improving Compose Performance Performance Tip: Avoid premature optimizations
195. Guide to Improving Compose Performance Measure Improve Inspect
196. Guide to Improving Compose Performance • Recomposition performance • Compiler Plugin Internals • Compiler Plugin Tests • Experimental features
197. Thank You! www.codingwithmohit.com @heyitsmohit