Optimize the size of the coroutines library in Android projects

Includes additional R8 rules to disable debugging & stack-trace recovery in optimized
Android builds.

Author: elizarov

README.md

@@ -164,11 +164,11 @@ threads are handled by Android runtime.
 
 #### R8 and ProGuard
 
-For R8 no actions required, it will take obfuscation rules from the jar.
-
-For Proguard  you need to add options from [coroutines.pro](kotlinx-coroutines-core/jvm/resources/META-INF/proguard/coroutines.pro) to your rules manually.
- 
-R8 is a replacement for ProGuard in Android ecosystem, it is enabled by default since Android gradle plugin 3.4.0 (3.3.0-beta also had it enabled).
+R8 and ProGuard rules are bundled into the [`kotlinx-coroutines-android`](ui/kotlinx-coroutines-android) module.
+For best results it is recommended to use a recent version of R8.
+R8 is a replacement for ProGuard in Android ecosystem, it is enabled by default since Android gradle plugin 3.4.0
+(3.3.0-beta also had it enabled). The upcoming AGP 4.0.0 has never R8 and additional rules enable
+more optimizations, producing smaller binary size. 
 
 ### JS
 

build.gradle

@@ -165,6 +165,8 @@ allprojects {
         kotlinOptions.freeCompilerArgs += "-XXLanguage:+InlineClasses"
         // Binary compatibility support
         kotlinOptions.freeCompilerArgs += ["-Xdump-declarations-to=${buildDir}/visibilities.json"]
+        // Remove null assertions to get smaller bytecode on Android
+        kotlinOptions.freeCompilerArgs += ["-Xno-param-assertions", "-Xno-receiver-assertions", "-Xno-call-assertions"]
     }
 }
 

kotlinx-coroutines-core/common/src/selects/Select.kt

@@ -264,7 +264,10 @@ internal class SelectBuilderImpl<in R>(
         assert { isSelected } // "Must be selected first"
         _result.loop { result ->
             when {
-                result === UNDECIDED -> if (_result.compareAndSet(UNDECIDED, value())) return
+                result === UNDECIDED -> {
+                    val update = value()
+                    if (_result.compareAndSet(UNDECIDED, update)) return
+                }
                 result === COROUTINE_SUSPENDED -> if (_result.compareAndSet(COROUTINE_SUSPENDED, RESUMED)) {
                     block()
                     return

kotlinx-coroutines-core/jvm/src/internal/Concurrent.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2016-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package kotlinx.coroutines.internal
@@ -16,7 +16,9 @@ internal actual typealias ReentrantLock = java.util.concurrent.locks.ReentrantLo
 
 internal actual inline fun <T> ReentrantLock.withLock(action: () -> T) = this.withLockJvm(action)
 
-internal actual fun <E> identitySet(expectedSize: Int): MutableSet<E> = Collections.newSetFromMap(IdentityHashMap(expectedSize))
+@Suppress("NOTHING_TO_INLINE") // So that R8 can completely remove ConcurrentKt class
+internal actual inline fun <E> identitySet(expectedSize: Int): MutableSet<E> =
+    Collections.newSetFromMap(IdentityHashMap(expectedSize))
 
 private val REMOVE_FUTURE_ON_CANCEL: Method? = try {
     ScheduledThreadPoolExecutor::class.java.getMethod("setRemoveOnCancelPolicy", Boolean::class.java)

kotlinx-coroutines-core/jvm/src/internal/MainDispatchers.kt

@@ -1,3 +1,7 @@
+/*
+ * Copyright 2016-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
 package kotlinx.coroutines.internal
 
 import kotlinx.coroutines.*
@@ -30,11 +34,12 @@ internal object MainDispatcherLoader {
                         MainDispatcherFactory::class.java.classLoader
                 ).iterator().asSequence().toList()
             }
+            @Suppress("ConstantConditionIf")
             factories.maxBy { it.loadPriority }?.tryCreateDispatcher(factories)
-                ?: MissingMainCoroutineDispatcher(null)
+                ?: createMissingDispatcher()
         } catch (e: Throwable) {
             // Service loader can throw an exception as well
-            MissingMainCoroutineDispatcher(e)
+            createMissingDispatcher(e)
         }
     }
 }
@@ -51,13 +56,30 @@ public fun MainDispatcherFactory.tryCreateDispatcher(factories: List<MainDispatc
     try {
         createDispatcher(factories)
     } catch (cause: Throwable) {
-        MissingMainCoroutineDispatcher(cause, hintOnError())
+        createMissingDispatcher(cause, hintOnError())
     }
 
 /** @suppress */
 @InternalCoroutinesApi
 public fun MainCoroutineDispatcher.isMissing(): Boolean = this is MissingMainCoroutineDispatcher
 
+// R8 optimization hook, not const on purpose to enable R8 optimizations via "assumenosideeffects"
+@Suppress("MayBeConstant")
+val SUPPORT_MISSING = true
+
+@Suppress("ConstantConditionIf")
+private fun createMissingDispatcher(cause: Throwable? = null, errorHint: String? = null) =
+    if (SUPPORT_MISSING) MissingMainCoroutineDispatcher(cause, errorHint) else
+        cause?.let { throw it } ?: throwMissingMainDispatcherException()
+
+internal fun throwMissingMainDispatcherException(): Nothing {
+    throw IllegalStateException(
+        "Module with the Main dispatcher is missing. " +
+            "Add dependency providing the Main dispatcher, e.g. 'kotlinx-coroutines-android' " +
+            "and ensure it has the same version as 'kotlinx-coroutines-core'"
+    )
+}
+
 private class MissingMainCoroutineDispatcher(
     private val cause: Throwable?,
     private val errorHint: String? = null
@@ -85,11 +107,7 @@ private class MissingMainCoroutineDispatcher(
 
     private fun missing(): Nothing {
         if  (cause == null) {
-            throw IllegalStateException(
-                "Module with the Main dispatcher is missing. " +
-                    "Add dependency providing the Main dispatcher, e.g. 'kotlinx-coroutines-android' " +
-                        "and ensure it has the same version as 'kotlinx-coroutines-core'"
-            )
+            throwMissingMainDispatcherException()
         } else {
             val message = "Module with the Main dispatcher had failed to initialize" + (errorHint?.let { ". $it" } ?: "")
             throw IllegalStateException(message, cause)

kotlinx-coroutines-core/jvm/src/internal/StackTraceRecovery.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2016-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
 @file:Suppress("UNCHECKED_CAST")
@@ -52,7 +52,8 @@ private fun <E : Throwable> E.sanitizeStackTrace(): E {
     return this
 }
 
-internal actual fun <E : Throwable> recoverStackTrace(exception: E, continuation: Continuation<*>): E {
+@Suppress("NOTHING_TO_INLINE") // Inline for better R8 optimization
+internal actual inline fun <E : Throwable> recoverStackTrace(exception: E, continuation: Continuation<*>): E {
     if (!RECOVER_STACK_TRACES || continuation !is CoroutineStackFrame) return exception
     return recoverFromStackFrame(exception, continuation)
 }
@@ -155,8 +156,11 @@ internal actual suspend inline fun recoverAndThrow(exception: Throwable): Nothin
     }
 }
 
-internal actual fun <E : Throwable> unwrap(exception: E): E {
-    if (!RECOVER_STACK_TRACES) return exception
+@Suppress("NOTHING_TO_INLINE") // Inline for better R8 optimizations
+internal actual inline fun <E : Throwable> unwrap(exception: E): E =
+    if (!RECOVER_STACK_TRACES) exception else unwrapImpl(exception)
+
+internal fun <E : Throwable> unwrapImpl(exception: E): E {
     val cause = exception.cause
     // Fast-path to avoid array cloning
     if (cause == null || cause.javaClass != exception.javaClass) {

kotlinx-coroutines-core/jvm/src/scheduling/CoroutineScheduler.kt

@@ -73,7 +73,7 @@ import kotlin.random.*
  * Only [corePoolSize] workers can be created for regular CPU tasks)
  *
  * ### Support for blocking tasks
- * The scheduler also supports the notion of [blocking][TaskMode.PROBABLY_BLOCKING] tasks.
+ * The scheduler also supports the notion of [blocking][TASK_PROBABLY_BLOCKING] tasks.
  * When executing or enqueuing blocking tasks, the scheduler notifies or creates one more worker in
  * addition to core pool size, so at any given moment, it has [corePoolSize] threads (potentially not yet created)
  * to serve CPU-bound tasks. To properly guarantee liveness, the scheduler maintains
@@ -387,7 +387,7 @@ internal class CoroutineScheduler(
             }
         }
         // Checking 'task' instead of 'notAdded' is completely okay
-        if (task.mode == TaskMode.NON_BLOCKING) {
+        if (task.mode == TASK_NON_BLOCKING) {
             signalCpuWork()
         } else {
             signalBlockingWork()
@@ -489,7 +489,7 @@ internal class CoroutineScheduler(
          */
         if (worker.state === WorkerState.TERMINATED) return task
         // Do not add CPU tasks in local queue if we are not able to execute it
-        if (task.mode === TaskMode.NON_BLOCKING && worker.state === WorkerState.BLOCKING) {
+        if (task.mode == TASK_NON_BLOCKING && worker.state === WorkerState.BLOCKING) {
             return task
         }
         worker.mayHaveLocalTasks = true
@@ -728,16 +728,16 @@ internal class CoroutineScheduler(
             afterTask(taskMode)
         }
 
-        private fun beforeTask(taskMode: TaskMode) {
-            if (taskMode == TaskMode.NON_BLOCKING) return
+        private fun beforeTask(taskMode: Int) {
+            if (taskMode == TASK_NON_BLOCKING) return
             // Always notify about new work when releasing CPU-permit to execute some blocking task
             if (tryReleaseCpu(WorkerState.BLOCKING)) {
                 signalCpuWork()
             }
         }
 
-        private fun afterTask(taskMode: TaskMode) {
-            if (taskMode == TaskMode.NON_BLOCKING) return
+        private fun afterTask(taskMode: Int) {
+            if (taskMode == TASK_NON_BLOCKING) return
             decrementBlockingTasks()
             val currentState = state
             // Shutdown sequence of blocking dispatcher
@@ -835,10 +835,10 @@ internal class CoroutineScheduler(
         }
 
         // It is invoked by this worker when it finds a task
-        private fun idleReset(mode: TaskMode) {
+        private fun idleReset(mode: Int) {
             terminationDeadline = 0L // reset deadline for termination
             if (state == WorkerState.PARKING) {
-                assert { mode == TaskMode.PROBABLY_BLOCKING }
+                assert { mode == TASK_PROBABLY_BLOCKING }
                 state = WorkerState.BLOCKING
             }
         }
@@ -915,12 +915,12 @@ internal class CoroutineScheduler(
 
     enum class WorkerState {
         /**
-         * Has CPU token and either executes [TaskMode.NON_BLOCKING] task or tries to find one.
+         * Has CPU token and either executes [TASK_NON_BLOCKING] task or tries to find one.
          */
         CPU_ACQUIRED,
 
         /**
-         * Executing task with [TaskMode.PROBABLY_BLOCKING].
+         * Executing task with [TASK_PROBABLY_BLOCKING].
          */
         BLOCKING,
 

kotlinx-coroutines-core/jvm/src/scheduling/Dispatcher.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2016-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package kotlinx.coroutines.scheduling
@@ -85,7 +85,7 @@ open class ExperimentalCoroutineDispatcher(
      */
     public fun blocking(parallelism: Int = BLOCKING_DEFAULT_PARALLELISM): CoroutineDispatcher {
         require(parallelism > 0) { "Expected positive parallelism level, but have $parallelism" }
-        return LimitingDispatcher(this, parallelism, TaskMode.PROBABLY_BLOCKING)
+        return LimitingDispatcher(this, parallelism, TASK_PROBABLY_BLOCKING)
     }
 
     /**
@@ -98,7 +98,7 @@ open class ExperimentalCoroutineDispatcher(
     public fun limited(parallelism: Int): CoroutineDispatcher {
         require(parallelism > 0) { "Expected positive parallelism level, but have $parallelism" }
         require(parallelism <= corePoolSize) { "Expected parallelism level lesser than core pool size ($corePoolSize), but have $parallelism" }
-        return LimitingDispatcher(this, parallelism, TaskMode.NON_BLOCKING)
+        return LimitingDispatcher(this, parallelism, TASK_NON_BLOCKING)
     }
 
     internal fun dispatchWithContext(block: Runnable, context: TaskContext, fair: Boolean) {
@@ -132,7 +132,7 @@ open class ExperimentalCoroutineDispatcher(
 private class LimitingDispatcher(
     val dispatcher: ExperimentalCoroutineDispatcher,
     val parallelism: Int,
-    override val taskMode: TaskMode
+    override val taskMode: Int
 ) : ExecutorCoroutineDispatcher(), TaskContext, Executor {
 
     private val queue = ConcurrentLinkedQueue<Runnable>()

kotlinx-coroutines-core/jvm/src/scheduling/Tasks.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2016-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
 package kotlinx.coroutines.scheduling
@@ -51,26 +51,23 @@ internal val IDLE_WORKER_KEEP_ALIVE_NS = TimeUnit.SECONDS.toNanos(
 @JvmField
 internal var schedulerTimeSource: TimeSource = NanoTimeSource
 
-internal enum class TaskMode {
-
-    /**
-     * Marker indicating that task is CPU-bound and will not block
-     */
-    NON_BLOCKING,
+/**
+ * Marker indicating that task is CPU-bound and will not block
+ */
+internal const val TASK_NON_BLOCKING = 0
 
-    /**
-     * Marker indicating that task may potentially block, thus giving scheduler a hint that additional thread may be required
-     */
-    PROBABLY_BLOCKING,
-}
+/**
+ * Marker indicating that task may potentially block, thus giving scheduler a hint that additional thread may be required
+ */
+internal const val TASK_PROBABLY_BLOCKING = 1
 
 internal interface TaskContext {
-    val taskMode: TaskMode
+    val taskMode: Int // TASK_XXX
     fun afterTask()
 }
 
 internal object NonBlockingContext : TaskContext {
-    override val taskMode: TaskMode = TaskMode.NON_BLOCKING
+    override val taskMode: Int = TASK_NON_BLOCKING
 
     override fun afterTask() {
        // Nothing for non-blocking context
@@ -82,10 +79,10 @@ internal abstract class Task(
     @JvmField var taskContext: TaskContext
 ) : Runnable {
     constructor() : this(0, NonBlockingContext)
-    inline val mode: TaskMode get() = taskContext.taskMode
+    inline val mode: Int get() = taskContext.taskMode // TASK_XXX
 }
 
-internal inline val Task.isBlocking get() = taskContext.taskMode == TaskMode.PROBABLY_BLOCKING
+internal inline val Task.isBlocking get() = taskContext.taskMode == TASK_PROBABLY_BLOCKING
 
 // Non-reusable Task implementation to wrap Runnable instances that do not otherwise implement task
 internal class TaskImpl(

kotlinx-coroutines-core/jvm/test/scheduling/CoroutineSchedulerTest.kt

@@ -12,11 +12,12 @@ import kotlin.coroutines.*
 import kotlin.test.*
 
 class CoroutineSchedulerTest : TestBase() {
+    private val taskModes = listOf(TASK_NON_BLOCKING, TASK_PROBABLY_BLOCKING)
 
     @Test
     fun testModesExternalSubmission() { // Smoke
         CoroutineScheduler(1, 1).use {
-            for (mode in TaskMode.values()) {
+            for (mode in taskModes) {
                 val latch = CountDownLatch(1)
                 it.dispatch(Runnable {
                     latch.countDown()
@@ -30,9 +31,9 @@ class CoroutineSchedulerTest : TestBase() {
     @Test
     fun testModesInternalSubmission() { // Smoke
         CoroutineScheduler(2, 2).use {
-            val latch = CountDownLatch(TaskMode.values().size)
+            val latch = CountDownLatch(taskModes.size)
             it.dispatch(Runnable {
-                for (mode in TaskMode.values()) {
+                for (mode in taskModes) {
                     it.dispatch(Runnable {
                         latch.countDown()
                     }, TaskContextImpl(mode))
@@ -167,7 +168,7 @@ class CoroutineSchedulerTest : TestBase() {
         }
     }
 
-    private class TaskContextImpl(override val taskMode: TaskMode) : TaskContext {
+    private class TaskContextImpl(override val taskMode: Int) : TaskContext {
         override fun afterTask() {}
     }
 }