expo-benchmark 0.1.0 → 0.2.0

package/android/build.gradle

@@ -43,6 +43,6 @@ android {
 }
 
 dependencies {
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
-  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")
+  implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
 }

package/android/src/main/java/expo/modules/benchmark/ExpoBenchmarkModule.kt

@@ -2,12 +2,15 @@ package expo.modules.benchmark
 
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
-import kotlinx.coroutines.*
+import expo.modules.kotlin.Promise
 import java.security.MessageDigest
+import java.util.concurrent.Executors
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.random.Random
 
 class ExpoBenchmarkModule : Module() {
+  private val executor = Executors.newCachedThreadPool()
+
   override fun definition() = ModuleDefinition {
     Name("ExpoBenchmark")
 
@@ -20,28 +23,50 @@ class ExpoBenchmarkModule : Module() {
     }
 
     // Run a configurable benchmark
-    AsyncFunction("runBenchmarkAsync") { options: Map<String, Any>? ->
+    AsyncFunction("runBenchmarkAsync") { options: Map<String, Any>?, promise: Promise ->
       val durationSeconds = (options?.get("durationSeconds") as? Number)?.toDouble() ?: 5.0
       val threads = (options?.get("threads") as? Number)?.toInt() ?: 1
       val actualThreads = if (threads == 0) Runtime.getRuntime().availableProcessors() else threads
 
-      runBenchmark(durationSeconds, actualThreads)
+      executor.execute {
+        try {
+          val result = runBenchmark(durationSeconds, actualThreads)
+          promise.resolve(result)
+        } catch (e: Exception) {
+          promise.reject("BENCHMARK_ERROR", e.message, e)
+        }
+      }
     }
 
     // Quick single-threaded benchmark
-    AsyncFunction("runQuickBenchmarkAsync") {
-      runBenchmark(1.0, 1)
+    AsyncFunction("runQuickBenchmarkAsync") { promise: Promise ->
+      executor.execute {
+        try {
+          val result = runBenchmark(1.0, 1)
+          promise.resolve(result)
+        } catch (e: Exception) {
+          promise.reject("BENCHMARK_ERROR", e.message, e)
+        }
+      }
     }
 
     // Multi-threaded benchmark using all cores
-    AsyncFunction("runMultiThreadedBenchmarkAsync") { durationSeconds: Double? ->
+    AsyncFunction("runMultiThreadedBenchmarkAsync") { durationSeconds: Double?, promise: Promise ->
       val duration = durationSeconds ?: 5.0
       val threads = Runtime.getRuntime().availableProcessors()
-      runBenchmark(duration, threads)
+      
+      executor.execute {
+        try {
+          val result = runBenchmark(duration, threads)
+          promise.resolve(result)
+        } catch (e: Exception) {
+          promise.reject("BENCHMARK_ERROR", e.message, e)
+        }
+      }
     }
   }
 
-  private suspend fun runBenchmark(durationSeconds: Double, threads: Int): Map<String, Any> {
+  private fun runBenchmark(durationSeconds: Double, threads: Int): Map<String, Any> {
     val durationMs = (durationSeconds * 1000).toLong()
     val startTime = System.currentTimeMillis()
     val endTime = startTime + durationMs
@@ -50,58 +75,56 @@ class ExpoBenchmarkModule : Module() {
 
     if (threads == 1) {
       // Single-threaded benchmark
-      totalHashes = withContext(Dispatchers.Default) {
-        var hashCount = 0L
-        var data = ByteArray(32)
-        Random.nextBytes(data)
-
-        val digest = MessageDigest.getInstance("SHA-256")
-
-        while (System.currentTimeMillis() < endTime) {
-          data = digest.digest(data)
-          hashCount++
-
-          // Report progress every 100000 hashes
-          if (hashCount % 100000 == 0L) {
-            val elapsed = System.currentTimeMillis() - startTime
-            val currentHashrate = hashCount.toDouble() / (elapsed.toDouble() / 1000)
-
-            sendEvent("onProgress", mapOf(
-              "currentHashCount" to hashCount,
-              "elapsedMs" to elapsed,
-              "currentHashrate" to currentHashrate
-            ))
-          }
+      var hashCount = 0L
+      var data = ByteArray(32)
+      Random.nextBytes(data)
+
+      val digest = MessageDigest.getInstance("SHA-256")
+
+      while (System.currentTimeMillis() < endTime) {
+        data = digest.digest(data)
+        hashCount++
+
+        // Report progress every 100000 hashes
+        if (hashCount % 100000 == 0L) {
+          val elapsed = System.currentTimeMillis() - startTime
+          val currentHashrate = hashCount.toDouble() / (elapsed.toDouble() / 1000)
+
+          sendEvent("onProgress", mapOf(
+            "currentHashCount" to hashCount,
+            "elapsedMs" to elapsed,
+            "currentHashrate" to currentHashrate
+          ))
         }
-
-        hashCount
       }
+
+      totalHashes = hashCount
     } else {
       // Multi-threaded benchmark
-      totalHashes = withContext(Dispatchers.Default) {
-        val hashCounts = Array(threads) { AtomicLong(0) }
-        
-        val jobs = (0 until threads).map { threadIndex ->
-          async {
-            var hashCount = 0L
-            var data = ByteArray(32)
-            Random.nextBytes(data)
-
-            val digest = MessageDigest.getInstance("SHA-256")
-
-            while (System.currentTimeMillis() < endTime) {
-              data = digest.digest(data)
-              hashCount++
-            }
-
-            hashCounts[threadIndex].set(hashCount)
+      val hashCounts = Array(threads) { AtomicLong(0) }
+      val threadPool = Executors.newFixedThreadPool(threads)
+      val futures = (0 until threads).map { threadIndex ->
+        threadPool.submit {
+          var hashCount = 0L
+          var data = ByteArray(32)
+          Random.nextBytes(data)
+
+          val digest = MessageDigest.getInstance("SHA-256")
+
+          while (System.currentTimeMillis() < endTime) {
+            data = digest.digest(data)
+            hashCount++
           }
+
+          hashCounts[threadIndex].set(hashCount)
         }
+      }
 
-        jobs.awaitAll()
+      // Wait for all threads to complete
+      futures.forEach { it.get() }
+      threadPool.shutdown()
 
-        hashCounts.sumOf { it.get() }
-      }
+      totalHashes = hashCounts.sumOf { it.get() }
     }
 
     val actualEndTime = System.currentTimeMillis()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "expo-benchmark",
-  "version": "0.1.0",
-  "description": "My new module",
+  "version": "0.2.0",
+  "description": "Benchmark module to measure SHA-256 hashrate performance on mobile devices",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "scripts": {