expo-benchmark 0.1.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/README.md

@@ -0,0 +1,35 @@
+# expo-benchmark
+
+My new module
+
+# API documentation
+
+- [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/benchmark/)
+- [Documentation for the main branch](https://docs.expo.dev/versions/unversioned/sdk/benchmark/)
+
+# Installation in managed Expo projects
+
+For [managed](https://docs.expo.dev/archive/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](#api-documentation). If you follow the link and there is no documentation available then this library is not yet usable within managed projects — it is likely to be included in an upcoming Expo SDK release.
+
+# Installation in bare React Native projects
+
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing.
+
+### Add the package to your npm dependencies
+
+```
+npm install expo-benchmark
+```
+
+### Configure for Android
+
+
+
+
+### Configure for iOS
+
+Run `npx pod-install` after installing the npm package.
+
+# Contributing
+
+Contributions are very welcome! Please refer to guidelines described in the [contributing guide]( https://github.com/expo/expo#contributing).

package/android/build.gradle

@@ -0,0 +1,48 @@
+apply plugin: 'com.android.library'
+
+group = 'expo.modules.benchmark'
+version = '0.1.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useExpoPublishing()
+
+// If you want to use the managed Android SDK versions from expo-modules-core, set this to true.
+// The Android SDK versions will be bumped from time to time in SDK releases and may introduce breaking changes in your module code.
+// Most of the time, you may like to manage the Android SDK versions yourself.
+def useManagedAndroidSdkVersions = false
+if (useManagedAndroidSdkVersions) {
+  useDefaultAndroidSdkVersions()
+} else {
+  buildscript {
+    // Simple helper that allows the root project to override versions declared by this library.
+    ext.safeExtGet = { prop, fallback ->
+      rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+  }
+  project.android {
+    compileSdkVersion safeExtGet("compileSdkVersion", 36)
+    defaultConfig {
+      minSdkVersion safeExtGet("minSdkVersion", 24)
+      targetSdkVersion safeExtGet("targetSdkVersion", 36)
+    }
+  }
+}
+
+android {
+  namespace "expo.modules.benchmark"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+  lintOptions {
+    abortOnError false
+  }
+}
+
+dependencies {
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3"
+  implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest>
+</manifest>

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

@@ -0,0 +1,125 @@
+package expo.modules.benchmark
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.*
+import java.security.MessageDigest
+import java.util.concurrent.atomic.AtomicLong
+import kotlin.random.Random
+
+class ExpoBenchmarkModule : Module() {
+  override fun definition() = ModuleDefinition {
+    Name("ExpoBenchmark")
+
+    // Events for progress updates
+    Events("onProgress", "onComplete")
+
+    // Get the number of CPU cores
+    Function("getCpuCoreCount") {
+      Runtime.getRuntime().availableProcessors()
+    }
+
+    // Run a configurable benchmark
+    AsyncFunction("runBenchmarkAsync") { options: Map<String, Any>? ->
+      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)
+    }
+
+    // Quick single-threaded benchmark
+    AsyncFunction("runQuickBenchmarkAsync") {
+      runBenchmark(1.0, 1)
+    }
+
+    // Multi-threaded benchmark using all cores
+    AsyncFunction("runMultiThreadedBenchmarkAsync") { durationSeconds: Double? ->
+      val duration = durationSeconds ?: 5.0
+      val threads = Runtime.getRuntime().availableProcessors()
+      runBenchmark(duration, threads)
+    }
+  }
+
+  private suspend fun runBenchmark(durationSeconds: Double, threads: Int): Map<String, Any> {
+    val durationMs = (durationSeconds * 1000).toLong()
+    val startTime = System.currentTimeMillis()
+    val endTime = startTime + durationMs
+
+    val totalHashes: Long
+
+    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
+            ))
+          }
+        }
+
+        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)
+          }
+        }
+
+        jobs.awaitAll()
+
+        hashCounts.sumOf { it.get() }
+      }
+    }
+
+    val actualEndTime = System.currentTimeMillis()
+    val actualDurationMs = (actualEndTime - startTime).toDouble()
+    val hashesPerSecond = totalHashes.toDouble() / (actualDurationMs / 1000)
+
+    val result = mapOf(
+      "hashCount" to totalHashes,
+      "durationMs" to actualDurationMs,
+      "hashesPerSecond" to hashesPerSecond,
+      "kiloHashesPerSecond" to hashesPerSecond / 1000,
+      "megaHashesPerSecond" to hashesPerSecond / 1_000_000,
+      "threads" to threads,
+      "algorithm" to "SHA-256"
+    )
+
+    sendEvent("onComplete", result)
+
+    return result
+  }
+}

package/build/ExpoBenchmark.types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Result of a hashrate benchmark
+ */
+export type BenchmarkResult = {
+    /** Total number of hashes computed */
+    hashCount: number;
+    /** Duration of the benchmark in milliseconds */
+    durationMs: number;
+    /** Hashrate in hashes per second */
+    hashesPerSecond: number;
+    /** Hashrate in kilohashes per second */
+    kiloHashesPerSecond: number;
+    /** Hashrate in megahashes per second */
+    megaHashesPerSecond: number;
+    /** Number of threads used */
+    threads: number;
+    /** Algorithm used for hashing */
+    algorithm: string;
+};
+/**
+ * Options for running a benchmark
+ */
+export type BenchmarkOptions = {
+    /** Duration to run the benchmark in seconds (default: 5) */
+    durationSeconds?: number;
+    /** Number of threads to use (default: 1, use 0 for auto/max cores) */
+    threads?: number;
+};
+/**
+ * Progress event payload during benchmark
+ */
+export type BenchmarkProgressPayload = {
+    /** Current hash count */
+    currentHashCount: number;
+    /** Elapsed time in milliseconds */
+    elapsedMs: number;
+    /** Current hashrate */
+    currentHashrate: number;
+};
+/**
+ * Events emitted by the benchmark module
+ */
+export type ExpoBenchmarkModuleEvents = {
+    onProgress: (params: BenchmarkProgressPayload) => void;
+    onComplete: (params: BenchmarkResult) => void;
+};
+//# sourceMappingURL=ExpoBenchmark.types.d.ts.map

package/build/ExpoBenchmark.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBenchmark.types.d.ts","sourceRoot":"","sources":["../src/ExpoBenchmark.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,UAAU,EAAE,MAAM,CAAC;IACnB,oCAAoC;IACpC,eAAe,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,wCAAwC;IACxC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4DAA4D;IAC5D,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,yBAAyB;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB;IACvB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC,UAAU,EAAE,CAAC,MAAM,EAAE,wBAAwB,KAAK,IAAI,CAAC;IACvD,UAAU,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/C,CAAC"}

package/build/ExpoBenchmark.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ExpoBenchmark.types.js.map

package/build/ExpoBenchmark.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBenchmark.types.js","sourceRoot":"","sources":["../src/ExpoBenchmark.types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Result of a hashrate benchmark\n */\nexport type BenchmarkResult = {\n  /** Total number of hashes computed */\n  hashCount: number;\n  /** Duration of the benchmark in milliseconds */\n  durationMs: number;\n  /** Hashrate in hashes per second */\n  hashesPerSecond: number;\n  /** Hashrate in kilohashes per second */\n  kiloHashesPerSecond: number;\n  /** Hashrate in megahashes per second */\n  megaHashesPerSecond: number;\n  /** Number of threads used */\n  threads: number;\n  /** Algorithm used for hashing */\n  algorithm: string;\n};\n\n/**\n * Options for running a benchmark\n */\nexport type BenchmarkOptions = {\n  /** Duration to run the benchmark in seconds (default: 5) */\n  durationSeconds?: number;\n  /** Number of threads to use (default: 1, use 0 for auto/max cores) */\n  threads?: number;\n};\n\n/**\n * Progress event payload during benchmark\n */\nexport type BenchmarkProgressPayload = {\n  /** Current hash count */\n  currentHashCount: number;\n  /** Elapsed time in milliseconds */\n  elapsedMs: number;\n  /** Current hashrate */\n  currentHashrate: number;\n};\n\n/**\n * Events emitted by the benchmark module\n */\nexport type ExpoBenchmarkModuleEvents = {\n  onProgress: (params: BenchmarkProgressPayload) => void;\n  onComplete: (params: BenchmarkResult) => void;\n};\n"]}

package/build/ExpoBenchmarkModule.d.ts

@@ -0,0 +1,28 @@
+import { NativeModule } from 'expo';
+import { ExpoBenchmarkModuleEvents, BenchmarkResult, BenchmarkOptions } from './ExpoBenchmark.types';
+declare class ExpoBenchmarkModule extends NativeModule<ExpoBenchmarkModuleEvents> {
+    /**
+     * Get the number of CPU cores available on the device
+     */
+    getCpuCoreCount(): number;
+    /**
+     * Run a SHA-256 hashrate benchmark
+     * @param options - Benchmark options (duration, threads)
+     * @returns Promise with benchmark results
+     */
+    runBenchmarkAsync(options?: BenchmarkOptions): Promise<BenchmarkResult>;
+    /**
+     * Run a quick single-threaded benchmark (1 second)
+     * @returns Promise with benchmark results
+     */
+    runQuickBenchmarkAsync(): Promise<BenchmarkResult>;
+    /**
+     * Run a multi-threaded benchmark using all available cores
+     * @param durationSeconds - Duration in seconds (default: 5)
+     * @returns Promise with benchmark results
+     */
+    runMultiThreadedBenchmarkAsync(durationSeconds?: number): Promise<BenchmarkResult>;
+}
+declare const _default: ExpoBenchmarkModule;
+export default _default;
+//# sourceMappingURL=ExpoBenchmarkModule.d.ts.map

package/build/ExpoBenchmarkModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBenchmarkModule.d.ts","sourceRoot":"","sources":["../src/ExpoBenchmarkModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EACL,yBAAyB,EACzB,eAAe,EACf,gBAAgB,EACjB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,OAAO,mBAAoB,SAAQ,YAAY,CAAC,yBAAyB,CAAC;IAC/E;;OAEG;IACH,eAAe,IAAI,MAAM;IAEzB;;;;OAIG;IACH,iBAAiB,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAEvE;;;OAGG;IACH,sBAAsB,IAAI,OAAO,CAAC,eAAe,CAAC;IAElD;;;;OAIG;IACH,8BAA8B,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CACnF;;AAGD,wBAAyE"}

package/build/ExpoBenchmarkModule.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo';
+// This call loads the native module object from the JSI.
+export default requireNativeModule('ExpoBenchmark');
+//# sourceMappingURL=ExpoBenchmarkModule.js.map

package/build/ExpoBenchmarkModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBenchmarkModule.js","sourceRoot":"","sources":["../src/ExpoBenchmarkModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAmCzD,yDAAyD;AACzD,eAAe,mBAAmB,CAAsB,eAAe,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from 'expo';\n\nimport {\n  ExpoBenchmarkModuleEvents,\n  BenchmarkResult,\n  BenchmarkOptions,\n} from './ExpoBenchmark.types';\n\ndeclare class ExpoBenchmarkModule extends NativeModule<ExpoBenchmarkModuleEvents> {\n  /**\n   * Get the number of CPU cores available on the device\n   */\n  getCpuCoreCount(): number;\n\n  /**\n   * Run a SHA-256 hashrate benchmark\n   * @param options - Benchmark options (duration, threads)\n   * @returns Promise with benchmark results\n   */\n  runBenchmarkAsync(options?: BenchmarkOptions): Promise<BenchmarkResult>;\n\n  /**\n   * Run a quick single-threaded benchmark (1 second)\n   * @returns Promise with benchmark results\n   */\n  runQuickBenchmarkAsync(): Promise<BenchmarkResult>;\n\n  /**\n   * Run a multi-threaded benchmark using all available cores\n   * @param durationSeconds - Duration in seconds (default: 5)\n   * @returns Promise with benchmark results\n   */\n  runMultiThreadedBenchmarkAsync(durationSeconds?: number): Promise<BenchmarkResult>;\n}\n\n// This call loads the native module object from the JSI.\nexport default requireNativeModule<ExpoBenchmarkModule>('ExpoBenchmark');\n"]}

package/build/index.d.ts

@@ -0,0 +1,11 @@
+import ExpoBenchmarkModule from './ExpoBenchmarkModule';
+export * from './ExpoBenchmark.types';
+export default ExpoBenchmarkModule;
+export declare const getCpuCoreCount: () => number;
+export declare const runBenchmark: (options?: {
+    durationSeconds?: number;
+    threads?: number;
+}) => Promise<import("./ExpoBenchmark.types").BenchmarkResult>;
+export declare const runQuickBenchmark: () => Promise<import("./ExpoBenchmark.types").BenchmarkResult>;
+export declare const runMultiThreadedBenchmark: (durationSeconds?: number) => Promise<import("./ExpoBenchmark.types").BenchmarkResult>;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AAGxD,cAAc,uBAAuB,CAAC;AAGtC,eAAe,mBAAmB,CAAC;AAGnC,eAAO,MAAM,eAAe,cAA8C,CAAC;AAE3E,eAAO,MAAM,YAAY,GAAI,UAAU;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,6DAAmD,CAAC;AAErD,eAAO,MAAM,iBAAiB,gEAAqD,CAAC;AAEpF,eAAO,MAAM,yBAAyB,GAAI,kBAAkB,MAAM,6DACG,CAAC"}

package/build/index.js

@@ -0,0 +1,11 @@
+import ExpoBenchmarkModule from './ExpoBenchmarkModule';
+// Export types
+export * from './ExpoBenchmark.types';
+// Export the native module
+export default ExpoBenchmarkModule;
+// Convenience functions
+export const getCpuCoreCount = () => ExpoBenchmarkModule.getCpuCoreCount();
+export const runBenchmark = (options) => ExpoBenchmarkModule.runBenchmarkAsync(options);
+export const runQuickBenchmark = () => ExpoBenchmarkModule.runQuickBenchmarkAsync();
+export const runMultiThreadedBenchmark = (durationSeconds) => ExpoBenchmarkModule.runMultiThreadedBenchmarkAsync(durationSeconds);
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,mBAAmB,MAAM,uBAAuB,CAAC;AAExD,eAAe;AACf,cAAc,uBAAuB,CAAC;AAEtC,2BAA2B;AAC3B,eAAe,mBAAmB,CAAC;AAEnC,wBAAwB;AACxB,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,EAAE,CAAC,mBAAmB,CAAC,eAAe,EAAE,CAAC;AAE3E,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,OAG5B,EAAE,EAAE,CAAC,mBAAmB,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;AAErD,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,EAAE,CAAC,mBAAmB,CAAC,sBAAsB,EAAE,CAAC;AAEpF,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,eAAwB,EAAE,EAAE,CACpE,mBAAmB,CAAC,8BAA8B,CAAC,eAAe,CAAC,CAAC","sourcesContent":["import ExpoBenchmarkModule from './ExpoBenchmarkModule';\n\n// Export types\nexport * from './ExpoBenchmark.types';\n\n// Export the native module\nexport default ExpoBenchmarkModule;\n\n// Convenience functions\nexport const getCpuCoreCount = () => ExpoBenchmarkModule.getCpuCoreCount();\n\nexport const runBenchmark = (options?: {\n  durationSeconds?: number;\n  threads?: number;\n}) => ExpoBenchmarkModule.runBenchmarkAsync(options);\n\nexport const runQuickBenchmark = () => ExpoBenchmarkModule.runQuickBenchmarkAsync();\n\nexport const runMultiThreadedBenchmark = (durationSeconds?: number) =>\n  ExpoBenchmarkModule.runMultiThreadedBenchmarkAsync(durationSeconds);\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android", "web"],
+  "apple": {
+    "modules": ["ExpoBenchmarkModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.benchmark.ExpoBenchmarkModule"]
+  }
+}

package/ios/ExpoBenchmark.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoBenchmark'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/duychip0909/expo-benchmark' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/ExpoBenchmarkModule.swift

@@ -0,0 +1,150 @@
+import ExpoModulesCore
+import CommonCrypto
+import Foundation
+
+public class ExpoBenchmarkModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoBenchmark")
+
+    // Events for progress updates
+    Events("onProgress", "onComplete")
+
+    // Get the number of CPU cores
+    Function("getCpuCoreCount") {
+      return ProcessInfo.processInfo.activeProcessorCount
+    }
+
+    // Run a configurable benchmark
+    AsyncFunction("runBenchmarkAsync") { (options: [String: Any]?) -> [String: Any] in
+      let durationSeconds = (options?["durationSeconds"] as? Double) ?? 5.0
+      let threads = (options?["threads"] as? Int) ?? 1
+      let actualThreads = threads == 0 ? ProcessInfo.processInfo.activeProcessorCount : threads
+      
+      return await self.runBenchmark(durationSeconds: durationSeconds, threads: actualThreads)
+    }
+
+    // Quick single-threaded benchmark
+    AsyncFunction("runQuickBenchmarkAsync") { () -> [String: Any] in
+      return await self.runBenchmark(durationSeconds: 1.0, threads: 1)
+    }
+
+    // Multi-threaded benchmark using all cores
+    AsyncFunction("runMultiThreadedBenchmarkAsync") { (durationSeconds: Double?) -> [String: Any] in
+      let duration = durationSeconds ?? 5.0
+      let threads = ProcessInfo.processInfo.activeProcessorCount
+      return await self.runBenchmark(durationSeconds: duration, threads: threads)
+    }
+  }
+
+  private func runBenchmark(durationSeconds: Double, threads: Int) async -> [String: Any] {
+    let durationNs = UInt64(durationSeconds * 1_000_000_000)
+    let startTime = DispatchTime.now().uptimeNanoseconds
+    let endTime = startTime + durationNs
+    
+    var totalHashes: UInt64 = 0
+    
+    if threads == 1 {
+      // Single-threaded benchmark
+      totalHashes = await withCheckedContinuation { continuation in
+        DispatchQueue.global(qos: .userInitiated).async {
+          var hashCount: UInt64 = 0
+          var data = Data(count: 32)
+          
+          // Initialize with random data
+          for i in 0..<32 {
+            data[i] = UInt8.random(in: 0...255)
+          }
+          
+          while DispatchTime.now().uptimeNanoseconds < endTime {
+            // Perform SHA-256 hash
+            data = self.sha256(data: data)
+            hashCount += 1
+            
+            // Report progress every 100000 hashes
+            if hashCount % 100000 == 0 {
+              let elapsed = DispatchTime.now().uptimeNanoseconds - startTime
+              let elapsedMs = Double(elapsed) / 1_000_000
+              let currentHashrate = Double(hashCount) / (elapsedMs / 1000)
+              
+              self.sendEvent("onProgress", [
+                "currentHashCount": hashCount,
+                "elapsedMs": elapsedMs,
+                "currentHashrate": currentHashrate
+              ])
+            }
+          }
+          
+          continuation.resume(returning: hashCount)
+        }
+      }
+    } else {
+      // Multi-threaded benchmark
+      totalHashes = await withCheckedContinuation { continuation in
+        DispatchQueue.global(qos: .userInitiated).async {
+          let hashCounts = UnsafeMutablePointer<UInt64>.allocate(capacity: threads)
+          hashCounts.initialize(repeating: 0, count: threads)
+          
+          let group = DispatchGroup()
+          let queue = DispatchQueue(label: "benchmark", attributes: .concurrent)
+          
+          for threadIndex in 0..<threads {
+            group.enter()
+            queue.async {
+              var hashCount: UInt64 = 0
+              var data = Data(count: 32)
+              
+              // Initialize with random data for each thread
+              for i in 0..<32 {
+                data[i] = UInt8.random(in: 0...255)
+              }
+              
+              while DispatchTime.now().uptimeNanoseconds < endTime {
+                data = self.sha256(data: data)
+                hashCount += 1
+              }
+              
+              hashCounts[threadIndex] = hashCount
+              group.leave()
+            }
+          }
+          
+          group.wait()
+          
+          var total: UInt64 = 0
+          for i in 0..<threads {
+            total += hashCounts[i]
+          }
+          
+          hashCounts.deallocate()
+          continuation.resume(returning: total)
+        }
+      }
+    }
+    
+    let actualEndTime = DispatchTime.now().uptimeNanoseconds
+    let actualDurationMs = Double(actualEndTime - startTime) / 1_000_000
+    let hashesPerSecond = Double(totalHashes) / (actualDurationMs / 1000)
+    
+    let result: [String: Any] = [
+      "hashCount": totalHashes,
+      "durationMs": actualDurationMs,
+      "hashesPerSecond": hashesPerSecond,
+      "kiloHashesPerSecond": hashesPerSecond / 1000,
+      "megaHashesPerSecond": hashesPerSecond / 1_000_000,
+      "threads": threads,
+      "algorithm": "SHA-256"
+    ]
+    
+    self.sendEvent("onComplete", result)
+    
+    return result
+  }
+
+  private func sha256(data: Data) -> Data {
+    var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+    data.withUnsafeBytes { buffer in
+      _ = CC_SHA256(buffer.baseAddress, CC_LONG(buffer.count), &hash)
+    }
+    return Data(hash)
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "expo-benchmark",
+  "version": "0.1.0",
+  "description": "My new module",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-benchmark",
+    "ExpoBenchmark"
+  ],
+  "repository": "https://github.com/duychip0909/expo-benchmark",
+  "bugs": {
+    "url": "https://github.com/duychip0909/expo-benchmark/issues"
+  },
+  "author": "duychip9901 <duychip9901@gmail.com> (https://github.com/duychip0909)",
+  "license": "MIT",
+  "homepage": "https://github.com/duychip0909/expo-benchmark#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.1.0",
+    "expo-module-scripts": "^5.0.8",
+    "expo": "^54.0.27",
+    "react-native": "0.81.5"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/ExpoBenchmark.types.ts

@@ -0,0 +1,49 @@
+/**
+ * Result of a hashrate benchmark
+ */
+export type BenchmarkResult = {
+  /** Total number of hashes computed */
+  hashCount: number;
+  /** Duration of the benchmark in milliseconds */
+  durationMs: number;
+  /** Hashrate in hashes per second */
+  hashesPerSecond: number;
+  /** Hashrate in kilohashes per second */
+  kiloHashesPerSecond: number;
+  /** Hashrate in megahashes per second */
+  megaHashesPerSecond: number;
+  /** Number of threads used */
+  threads: number;
+  /** Algorithm used for hashing */
+  algorithm: string;
+};
+
+/**
+ * Options for running a benchmark
+ */
+export type BenchmarkOptions = {
+  /** Duration to run the benchmark in seconds (default: 5) */
+  durationSeconds?: number;
+  /** Number of threads to use (default: 1, use 0 for auto/max cores) */
+  threads?: number;
+};
+
+/**
+ * Progress event payload during benchmark
+ */
+export type BenchmarkProgressPayload = {
+  /** Current hash count */
+  currentHashCount: number;
+  /** Elapsed time in milliseconds */
+  elapsedMs: number;
+  /** Current hashrate */
+  currentHashrate: number;
+};
+
+/**
+ * Events emitted by the benchmark module
+ */
+export type ExpoBenchmarkModuleEvents = {
+  onProgress: (params: BenchmarkProgressPayload) => void;
+  onComplete: (params: BenchmarkResult) => void;
+};

package/src/ExpoBenchmarkModule.ts

@@ -0,0 +1,37 @@
+import { NativeModule, requireNativeModule } from 'expo';
+
+import {
+  ExpoBenchmarkModuleEvents,
+  BenchmarkResult,
+  BenchmarkOptions,
+} from './ExpoBenchmark.types';
+
+declare class ExpoBenchmarkModule extends NativeModule<ExpoBenchmarkModuleEvents> {
+  /**
+   * Get the number of CPU cores available on the device
+   */
+  getCpuCoreCount(): number;
+
+  /**
+   * Run a SHA-256 hashrate benchmark
+   * @param options - Benchmark options (duration, threads)
+   * @returns Promise with benchmark results
+   */
+  runBenchmarkAsync(options?: BenchmarkOptions): Promise<BenchmarkResult>;
+
+  /**
+   * Run a quick single-threaded benchmark (1 second)
+   * @returns Promise with benchmark results
+   */
+  runQuickBenchmarkAsync(): Promise<BenchmarkResult>;
+
+  /**
+   * Run a multi-threaded benchmark using all available cores
+   * @param durationSeconds - Duration in seconds (default: 5)
+   * @returns Promise with benchmark results
+   */
+  runMultiThreadedBenchmarkAsync(durationSeconds?: number): Promise<BenchmarkResult>;
+}
+
+// This call loads the native module object from the JSI.
+export default requireNativeModule<ExpoBenchmarkModule>('ExpoBenchmark');

package/src/index.ts

@@ -0,0 +1,20 @@
+import ExpoBenchmarkModule from './ExpoBenchmarkModule';
+
+// Export types
+export * from './ExpoBenchmark.types';
+
+// Export the native module
+export default ExpoBenchmarkModule;
+
+// Convenience functions
+export const getCpuCoreCount = () => ExpoBenchmarkModule.getCpuCoreCount();
+
+export const runBenchmark = (options?: {
+  durationSeconds?: number;
+  threads?: number;
+}) => ExpoBenchmarkModule.runBenchmarkAsync(options);
+
+export const runQuickBenchmark = () => ExpoBenchmarkModule.runQuickBenchmarkAsync();
+
+export const runMultiThreadedBenchmark = (durationSeconds?: number) =>
+  ExpoBenchmarkModule.runMultiThreadedBenchmarkAsync(durationSeconds);

package/tsconfig.json

@@ -0,0 +1,9 @@
+// @generated by expo-module-scripts
+{
+  "extends": "expo-module-scripts/tsconfig.base",
+  "compilerOptions": {
+    "outDir": "./build"
+  },
+  "include": ["./src"],
+  "exclude": ["**/__mocks__/*", "**/__tests__/*", "**/__rsc_tests__/*"]
+}