Adds Benchmark module to evaluate the SDK's first run performance (#1489)

* Operator.evaluateLibrary function
Generalization of FhirEngineRetrieveProvider

* Fixes from spotlessApply

* Moving COVID tests to its own directory.

* Removing redundant (contextPath != "id")

* Using Truth library and clearing up the logs

* BugFix on assetPath and Organization ID

* New Benchmark Module

* Simplifying tests.

* Deleting covid tests

* Requiring open to be not null

* Updating CQL Evaluation tests

* adding a profilable tag

* Fixing test for the new benchmark

* Renaming tests.

* Enhancing the test coverage

* Sorting dependencies alphabetically

* Spotless apply

* Adding CQL Parser test

* Typo

* Migrating Benchmark Plugin to 1.1.0
Removing unnecessary dependencies on Room
Better describing the role of execution of the tests

* Spotless Apply

* Following the design of the new PR for java versions

* Spotless apply

* Using workflow's minSDK

* multidex is not needed.

* Using workflow-testing

* Upgrading to CQL Combo 2.0 classes.

* Spotless Apply

* order imports alphabetically

* Don't change plugin version (potentially a merge issue)

* Use just one runWithTimingDisabled.

* Adding instructions in how to run the benchmark test

Author: vitorpamplona

benchmark/README.md

@@ -0,0 +1,37 @@
+# Android FHIR SDK Benchmark module
+
+Contains test cases that evaluate the performance of individual tasks executed for the first time directly on hardware. 
+
+The test cases are designed to run in sequence of their alphabetic order to make sure larger tasks do not build cache for smaller ones. Their class names are prefixed by an extra letter to inform their position relative to others in the list.
+
+# How to run the benchmark
+
+In Android Studio, set your build variants to `release` and run your benchmark as you would any `@Test` using the gutter action next to your test class or method.
+
+![gutter test action](https://developer.android.com/static/topic/performance/images/benchmark_images/microbenchmark_run.png)
+
+The results will be similar to this:
+```
+   48,093,078   ns    trace    A_JacksonMapperBenchmark.loadJsonMapper
+2,261,548,715   ns    trace    B_FhirContextLoaderBenchmark.loadR4
+2,928,293,365   ns    trace    B_FhirContextLoaderBenchmark.loadR5
+  337,669,721   ns    trace    B_FhirContextLoaderBenchmark.loadDstu2
+1,744,938,507   ns    trace    B_FhirContextLoaderBenchmark.loadDstu3
+6,817,953,752   ns    trace    C_CqlEngineFhirContextLoaderBenchmark.loadDstu2FhirModelResolver
+3,704,489,380   ns    trace    C_CqlEngineFhirContextLoaderBenchmark.loadR4FhirModelResolver
+2,814,451,999   ns    trace    C_CqlEngineFhirContextLoaderBenchmark.loadDstu3FhirModelResolver
+  675,991,839   ns    trace    D_FhirJsonParserBenchmark.parseLightFhirLibrary
+1,238,212,883   ns    trace    D_FhirJsonParserBenchmark.parseLightFhirBundle
+2,785,964,288   ns    trace    E_ElmJsonLibraryLoaderBenchmark.parseImmunityCheckCqlFromFhirLibrary
+  713,779,915   ns    trace    E_ElmJsonLibraryLoaderBenchmark.parseFhirHelpersCqlFromFhirLibrary
+  121,204,232   ns    trace    F_EngineDatabaseBenchmark.createAndGet
+9,833,892,387   ns    trace    G_CqlEvaluatorBenchmark.evaluatesLibrary
+```
+
+Alternatively, from the command line, run the connectedCheck to run all of the tests from specified Gradle module:
+
+```bash
+./gradlew benchmark:connectedReleaseAndroidTest
+```
+
+In this case, results will be saved to the `outputs/androidTest-results/connected/<device>/test-result.pb`. To visualize on Android Studio, click Run / Import Tests From File and find the `.pb` file

benchmark/benchmark-proguard-rules.pro

@@ -0,0 +1,37 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
+
+-dontobfuscate
+
+-ignorewarnings
+
+-keepattributes *Annotation*
+
+-dontnote junit.framework.**
+-dontnote junit.runner.**
+
+-dontwarn androidx.test.**
+-dontwarn org.junit.**
+-dontwarn org.hamcrest.**
+-dontwarn com.squareup.javawriter.JavaWriter
+
+-keepclasseswithmembers @org.junit.runner.RunWith public class *

benchmark/build.gradle.kts

@@ -0,0 +1,96 @@
+plugins {
+  id(Plugins.BuildPlugins.androidLib)
+  id(Plugins.BuildPlugins.kotlinAndroid)
+  id(Plugins.BuildPlugins.kotlinKapt)
+  id(Plugins.BuildPlugins.benchmark)
+  id(Plugins.BuildPlugins.jetbrainsKotlinAndroid)
+}
+
+android {
+  compileSdk = Sdk.compileSdk
+
+  compileOptions {
+    sourceCompatibility = Java.sourceCompatibility
+    targetCompatibility = Java.targetCompatibility
+  }
+
+  kotlinOptions { jvmTarget = Java.kotlinJvmTarget.toString() }
+
+  defaultConfig {
+    minSdk = Sdk.minSdkWorkflow
+    targetSdk = Sdk.targetSdk
+
+    testInstrumentationRunner = "androidx.benchmark.junit4.AndroidBenchmarkRunner"
+    // Runs only once
+    testInstrumentationRunnerArguments["androidx.benchmark.dryRunMode.enable"] = "true"
+    // Includes Startup time
+    testInstrumentationRunnerArguments["androidx.benchmark.startupMode.enable"] = "true"
+  }
+
+  testBuildType = "release"
+  buildTypes {
+    debug {
+      // Since isDebuggable can't be modified by gradle for library modules,
+      // it must be done in a manifest - see src/androidTest/AndroidManifest.xml
+      isMinifyEnabled = true
+      proguardFiles(
+        getDefaultProguardFile("proguard-android-optimize.txt"),
+        "benchmark-proguard-rules.pro"
+      )
+    }
+  }
+  packagingOptions {
+    resources.excludes.addAll(
+      listOf(
+        "license.html",
+        "META-INF/ASL2.0",
+        "META-INF/ASL-2.0.txt",
+        "META-INF/DEPENDENCIES",
+        "META-INF/LGPL-3.0.txt",
+        "META-INF/LICENSE",
+        "META-INF/LICENSE.txt",
+        "META-INF/license.txt",
+        "META-INF/license.html",
+        "META-INF/LICENSE.md",
+        "META-INF/NOTICE",
+        "META-INF/NOTICE.txt",
+        "META-INF/NOTICE.md",
+        "META-INF/notice.txt",
+        "META-INF/LGPL-3.0.txt",
+        "META-INF/sun-jaxb.episode",
+        "META-INF/*.kotlin_module",
+        "readme.html",
+      )
+    )
+  }
+}
+
+configurations {
+  all {
+    exclude(module = "xpp3")
+    exclude(module = "xpp3_min")
+    exclude(module = "xmlpull")
+    exclude(module = "javax.json")
+    exclude(module = "jcl-over-slf4j")
+    exclude(group = "org.apache.httpcomponents")
+    // Remove this after this issue has been fixed:
+    // https://github.com/cqframework/clinical_quality_language/issues/799
+    exclude(module = "antlr4")
+  }
+}
+
+dependencies {
+  androidTestImplementation(Dependencies.AndroidxTest.benchmarkJunit)
+  androidTestImplementation(Dependencies.AndroidxTest.extJunit)
+  androidTestImplementation(Dependencies.AndroidxTest.runner)
+  androidTestImplementation(Dependencies.Cql.engineJackson)
+  androidTestImplementation(Dependencies.Cql.evaluator)
+  androidTestImplementation(Dependencies.Cql.evaluatorBuilder)
+  androidTestImplementation(Dependencies.junit)
+  androidTestImplementation(Dependencies.Kotlin.kotlinCoroutinesAndroid)
+  androidTestImplementation(Dependencies.truth)
+
+  androidTestImplementation(project(":engine"))
+  androidTestImplementation(project(":workflow"))
+  androidTestImplementation(project(":workflow-testing"))
+}

benchmark/src/androidTest/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    package="com.google.android.fhir.benchmark"
+>
+
+    <!--
+      Important: disable debugging for accurate performance results
+
+      In a com.android.library project, this flag must be disabled from this
+      manifest, as it is not possible to override this flag from Gradle.
+    -->
+    <application
+        android:debuggable="false"
+        tools:ignore="HardcodedDebugMode"
+        tools:replace="android:debuggable"
+    >
+        <profileable android:shell="true" />
+    </application>
+</manifest>

benchmark/src/androidTest/java/com/google/android/fhir/benchmark/A_JacksonMapperBenchmark.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.benchmark
+
+import androidx.benchmark.junit4.BenchmarkRule
+import androidx.benchmark.junit4.measureRepeated
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.opencds.cqf.cql.engine.serializing.jackson.JsonCqlMapper
+
+@RunWith(AndroidJUnit4::class)
+class A_JacksonMapperBenchmark {
+  @get:Rule val benchmarkRule = BenchmarkRule()
+
+  /**
+   * The JSONMapper and the XMLMapper take 800ms to initialize the first time on Desktop. They seem
+   * to take less time on mobile or there is something pre-loading this object. Either way, it's
+   * important to keep an eye on it.
+   */
+  @Test
+  fun loadJsonMapper() {
+    benchmarkRule.measureRepeated { assertThat(JsonCqlMapper.getMapper()).isNotNull() }
+  }
+}

benchmark/src/androidTest/java/com/google/android/fhir/benchmark/B_FhirContextLoaderBenchmark.kt

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.benchmark
+
+import androidx.benchmark.junit4.BenchmarkRule
+import androidx.benchmark.junit4.measureRepeated
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import ca.uhn.fhir.context.FhirContext
+import com.google.common.truth.Truth.assertThat
+import org.hl7.fhir.r4.model.Enumerations
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class B_FhirContextLoaderBenchmark {
+
+  @get:Rule val benchmarkRule = BenchmarkRule()
+
+  /**
+   * FhirContexts generally take 2 seconds to load completely. This test mimics that loading time.
+   * getResourceDefinition forces the initialization of the Context.
+   */
+  @Test
+  fun loadDstu2() {
+    benchmarkRule.measureRepeated {
+      assertThat(
+          FhirContext.forDstu2().getResourceDefinition(Enumerations.ResourceType.ACCOUNT.toCode())
+        )
+        .isNotNull()
+    }
+  }
+
+  @Test
+  fun loadDstu3() {
+    benchmarkRule.measureRepeated {
+      assertThat(
+          FhirContext.forDstu3().getResourceDefinition(Enumerations.ResourceType.ACCOUNT.toCode())
+        )
+        .isNotNull()
+    }
+  }
+
+  @Test
+  fun loadR4() {
+    benchmarkRule.measureRepeated {
+      assertThat(
+          FhirContext.forR4().getResourceDefinition(Enumerations.ResourceType.ACCOUNT.toCode())
+        )
+        .isNotNull()
+    }
+  }
+
+  @Test
+  fun loadR5() {
+    benchmarkRule.measureRepeated {
+      assertThat(
+          FhirContext.forR5().getResourceDefinition(Enumerations.ResourceType.ACCOUNT.toCode())
+        )
+        .isNotNull()
+    }
+  }
+}

benchmark/src/androidTest/java/com/google/android/fhir/benchmark/C_CqlEngineFhirContextLoaderBenchmark.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.benchmark
+
+import androidx.benchmark.junit4.BenchmarkRule
+import androidx.benchmark.junit4.measureRepeated
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.opencds.cqf.cql.engine.fhir.model.Dstu2FhirModelResolver
+import org.opencds.cqf.cql.engine.fhir.model.Dstu3FhirModelResolver
+import org.opencds.cqf.cql.engine.fhir.model.R4FhirModelResolver
+
+@RunWith(AndroidJUnit4::class)
+class C_CqlEngineFhirContextLoaderBenchmark {
+
+  @get:Rule val benchmarkRule = BenchmarkRule()
+
+  /**
+   * The CQL engine FhirModelResolvers need a complete FhirContext loaded with added classes. The
+   * loading of the FhirContext has already happen on B, thus this is just for the added classes
+   * from the Engine.
+   */
+  @Test
+  fun loadDstu2FhirModelResolver() {
+    benchmarkRule.measureRepeated { assertThat(Dstu2FhirModelResolver()).isNotNull() }
+  }
+
+  @Test
+  fun loadDstu3FhirModelResolver() {
+    benchmarkRule.measureRepeated { assertThat(Dstu3FhirModelResolver()).isNotNull() }
+  }
+
+  @Test
+  fun loadR4FhirModelResolver() {
+    benchmarkRule.measureRepeated { assertThat(R4FhirModelResolver()).isNotNull() }
+  }
+}