@keepsnappy/react-native 0.0.0-stage → 0.1.0-alpha.11

package/ios/PerfLabHermes.mm

@@ -0,0 +1,64 @@
+#import "PerfLabHermes.h"
+
+#include <fstream>
+#include <sstream>
+
+#include <hermes/hermes.h>
+#include <jsi/jsi.h>
+
+namespace fh = facebook::hermes;
+namespace jsi = facebook::jsi;
+
+static fh::IHermesRootAPI *rootAPI() {
+  return jsi::castInterface<fh::IHermesRootAPI>(fh::makeHermesRootAPI());
+}
+
+@implementation PerfLabHermes
+
++ (BOOL)startWithHz:(double)hz {
+  auto *api = rootAPI();
+  if (api == nullptr) {
+    return NO;
+  }
+  api->enableSamplingProfiler(hz);
+  return YES;
+}
+
++ (BOOL)stop {
+  auto *api = rootAPI();
+  if (api == nullptr) {
+    return NO;
+  }
+  api->disableSamplingProfiler();
+  return YES;
+}
+
++ (nullable NSDictionary<NSString *, id> *)dumpRuntime:(void *)runtime toPath:(NSString *)path {
+  std::string file = path.UTF8String;
+  NSString *format = nil;
+  auto *jsiRuntime = static_cast<jsi::Runtime *>(runtime);
+  auto *ihermes = jsiRuntime != nullptr ? jsi::castInterface<fh::IHermes>(jsiRuntime) : nullptr;
+  if (ihermes != nullptr) {
+    std::ofstream out(file, std::ios::out | std::ios::trunc);
+    if (!out) {
+      return nil;
+    }
+    ihermes->sampledTraceToStreamInDevToolsFormat(out);
+    format = @"cpuprofile";
+  } else {
+    auto *api = rootAPI();
+    if (api == nullptr) {
+      return nil;
+    }
+    api->dumpSampledTraceToFile(file);
+    format = @"hermes-trace-events";
+  }
+  NSDictionary *attributes = [[NSFileManager defaultManager] attributesOfItemAtPath:path error:nil];
+  return @{
+    @"path" : path,
+    @"bytes" : attributes[NSFileSize] ?: @0,
+    @"format" : format,
+  };
+}
+
+@end

package/ios/PerfLabModule.swift

@@ -0,0 +1,371 @@
+import CryptoKit
+import ExpoModulesCore
+import Foundation
+import UIKit
+import os
+
+private let pointsOfInterest = OSLog(subsystem: "com.gigaverse.perflab", category: .pointsOfInterest)
+private let logger = OSLog(subsystem: "com.gigaverse.perflab", category: "log")
+
+// os_log truncates long messages, so long payloads go out in chunks.
+private let logChunk = 800
+
+// Created by Expo at app start whether or not the SDK measures: nothing here may
+// do work before a function is called (a dormant build calls activationRead only).
+public class PerfLabModule: Module {
+  private lazy var logQueue = DispatchQueue(label: "com.gigaverse.perflab.log")
+  private var logHandle: FileHandle?
+  private var spoolHandle: FileHandle?
+  private var samplerCreated = false
+  private lazy var sampler: PerfLabSampler = {
+    self.samplerCreated = true
+    return PerfLabSampler { [weak self] line in self?.writeLog(line) }
+  }()
+
+  public func definition() -> ModuleDefinition {
+    Name("PerfLab")
+
+    // Signpost names must be static, so the window name travels in the message.
+    Function("beginAsyncSection") { (name: String, cookie: Int) in
+      os_signpost(.begin, log: pointsOfInterest, name: "perf-lab", signpostID: OSSignpostID(UInt64(cookie)), "%{public}s", name)
+    }
+
+    Function("endAsyncSection") { (name: String, cookie: Int) in
+      os_signpost(.end, log: pointsOfInterest, name: "perf-lab", signpostID: OSSignpostID(UInt64(cookie)), "%{public}s", name)
+    }
+
+    Function("setCounter") { (name: String, value: Double) in
+      os_signpost(.event, log: pointsOfInterest, name: "perf-lab-counter", "%{public}s=%f", name, value)
+    }
+
+    Function("isTracing") { () -> Bool in
+      pointsOfInterest.signpostsEnabled
+    }
+
+    Function("log") { (message: String) in
+      self.writeLog(message)
+    }
+
+    Function("samplerConfigure") { (mode: String, intervalMs: Double) -> [String: Any] in
+      self.sampler.configure(mode: mode, intervalMs: intervalMs)
+    }
+
+    Function("samplerSample") { (reason: String) -> [String: Any]? in
+      self.sampler.sample(reason: reason)
+    }
+
+    Function("samplerRequest") { (reason: String) in
+      self.sampler.request(reason: reason)
+    }
+
+    Function("samplerTake") { (reason: String) -> [String: Any]? in
+      self.sampler.take(reason: reason)
+    }
+
+    Function("samplerRecent") { (sinceT: Double) -> [[String: Any]] in
+      self.sampler.recent(since: sinceT)
+    }
+
+    Function("samplerNow") { () -> Double in
+      perfLabMonotonicMs()
+    }
+
+    OnDestroy {
+      if self.samplerCreated {
+        _ = self.sampler.configure(mode: "off", intervalMs: 0)
+      }
+    }
+
+    // Activation of a dormant build (JSON written by the SDK, read once at startup by the
+    // hook polyfill). Plain file read: no directory is created when there is none.
+    Function("activationRead") { () -> String? in
+      guard let file = Self.fileIfPresent("activation.json") else { return nil }
+      return try? String(contentsOf: file, encoding: .utf8)
+    }
+
+    Function("activationWrite") { (json: String) -> Bool in
+      guard let dir = Self.outputDir() else { return false }
+      do {
+        try json.write(to: dir.appendingPathComponent("activation.json"), atomically: true, encoding: .utf8)
+        return true
+      } catch {
+        return false
+      }
+    }
+
+    // os_log only, never the log file: a dormant build's answer to `dump=1`.
+    Function("osLog") { (message: String) in
+      Self.emit(message)
+    }
+
+    // Push journal (perf-lab/push-spool.jsonl): append is queued, read and replace wait for
+    // the queue so they see every earlier append.
+    Function("spoolAppend") { (record: String) in
+      self.logQueue.async {
+        if self.spoolHandle == nil, let dir = Self.outputDir() {
+          let file = dir.appendingPathComponent("push-spool.jsonl")
+          if !FileManager.default.fileExists(atPath: file.path) {
+            FileManager.default.createFile(atPath: file.path, contents: nil)
+          }
+          self.spoolHandle = try? FileHandle(forWritingTo: file)
+          _ = try? self.spoolHandle?.seekToEnd()
+        }
+        if let data = (record + "\n").data(using: .utf8) {
+          try? self.spoolHandle?.write(contentsOf: data)
+        }
+      }
+    }
+
+    // Result of a `flush=1` link for the test driver: a transparent 1x1 pt element at the
+    // top-left of the key window, accessibility id `perflab.flushed`, label ok / error / off.
+    // Only ever created on request in a measuring process; replaced by the next flush.
+    Function("flushSignal") { (status: String, detail: String) in
+      Task { @MainActor in
+        Self.showSignal(tag: Self.flushSignalTag, id: "perflab.flushed", label: status, value: detail)
+      }
+    }
+
+    // The answer to a driver command (GC before the action): the same kind of element, id `perflab.ack`, label `gc:<n> ok`.
+    Function("ackSignal") { (text: String) in
+      Task { @MainActor in
+        Self.showSignal(tag: Self.ackSignalTag, id: "perflab.ack", label: text, value: text)
+      }
+    }
+
+    Function("spoolRead") { () -> String? in
+      self.logQueue.sync {
+        guard let file = Self.fileIfPresent("push-spool.jsonl") else { return nil }
+        return Self.readTail(file, max: Self.spoolReadMax)
+      }
+    }
+
+    Function("spoolReplace") { (content: String) -> Bool in
+      self.logQueue.sync {
+        try? self.spoolHandle?.close()
+        self.spoolHandle = nil
+        guard let dir = Self.outputDir() else { return false }
+        let file = dir.appendingPathComponent("push-spool.jsonl")
+        if content.isEmpty {
+          try? FileManager.default.removeItem(at: file)
+          return true
+        }
+        do {
+          try content.write(to: file, atomically: true, encoding: .utf8)
+          return true
+        } catch {
+          return false
+        }
+      }
+    }
+
+    // performance.now() in Hermes on iOS is steady_clock = mach_absolute_time (stops in sleep);
+    // the snapshot lets a run map it onto wall time and the trace clock.
+    Function("clockSnapshot") { () -> [String: Double] in
+      var info = mach_timebase_info_data_t()
+      mach_timebase_info(&info)
+      let machMs = Double(mach_absolute_time()) * Double(info.numer) / Double(info.denom) / 1_000_000
+      let continuousMs = Double(mach_continuous_time()) * Double(info.numer) / Double(info.denom) / 1_000_000
+      return [
+        "machAbsoluteMs": machMs,
+        "machContinuousMs": continuousMs,
+        "systemUptimeMs": ProcessInfo.processInfo.systemUptime * 1000,
+        "wallMs": Date().timeIntervalSince1970 * 1000,
+        "thermalState": Double(ProcessInfo.processInfo.thermalState.rawValue),
+        "lowPowerMode": ProcessInfo.processInfo.isLowPowerModeEnabled ? 1 : 0,
+      ]
+    }
+
+    // Documents/perf-lab is pulled with `xcrun devicectl device copy from --domain-type appDataContainer`.
+    Function("writeText") { (fileName: String, content: String) -> String? in
+      guard let dir = Self.outputDir() else { return nil }
+      let file = dir.appendingPathComponent(fileName.replacingOccurrences(of: "/", with: "_"))
+      do {
+        try content.write(to: file, atomically: true, encoding: .utf8)
+        return file.path
+      } catch {
+        return nil
+      }
+    }
+
+    // Hermes sampling profiler (PerfLabHermes.mm). Sync functions run on the JS
+    // thread, which the per-runtime dump needs.
+    Function("cpuProfileStart") { (hz: Double) -> Bool in
+      PerfLabHermes.start(withHz: hz)
+    }
+
+    Function("cpuProfileStop") { () -> Bool in
+      PerfLabHermes.stop()
+    }
+
+    // A raw profile file of a run (plan 40 §3.6): gzip, sha256 of the gzip, PUT to the
+    // signed URL the API handed out. Called at flush only, never inside a measured window.
+    // status 0: no HTTP answer (missing file, network error, timeout).
+    // The file is memory-mapped (clean pages, not app memory) and checked against the API's cap
+    // before it is read; only the gzip is built in memory.
+    // NOT YET COMPILED: the size check and the mapped read (night of 2026-10-14).
+    AsyncFunction("artifactUpload") { (fileName: String, url: String, headers: [String: String], timeoutMs: Double, promise: Promise) in
+      guard let file = Self.fileIfPresent(fileName.replacingOccurrences(of: "/", with: "_")) else {
+        promise.resolve(["status": 0, "error": "file missing"])
+        return
+      }
+      let size = ((try? FileManager.default.attributesOfItem(atPath: file.path))?[.size] as? NSNumber)?.int64Value ?? 0
+      if size > Self.artifactMaxBytes {
+        promise.resolve(["status": 413, "error": "file is \(size) bytes, over \(Self.artifactMaxBytes)"])
+        return
+      }
+      guard let raw = try? Data(contentsOf: file, options: .alwaysMapped) else {
+        promise.resolve(["status": 0, "error": "file missing"])
+        return
+      }
+      guard let target = URL(string: url), let gz = Self.gzip(raw) else {
+        promise.resolve(["status": 0, "bytes": raw.count, "error": "gzip or url failed"])
+        return
+      }
+      let sha = SHA256.hash(data: gz).map { String(format: "%02x", $0) }.joined()
+      var request = URLRequest(url: target, timeoutInterval: max(1, timeoutMs / 1000))
+      request.httpMethod = "PUT"
+      for (key, value) in headers {
+        request.setValue(value, forHTTPHeaderField: key)
+      }
+      URLSession.shared.uploadTask(with: request, from: gz) { _, response, error in
+        var out: [String: Any] = [
+          "status": (response as? HTTPURLResponse)?.statusCode ?? 0,
+          "bytes": raw.count,
+          "gzBytes": gz.count,
+          "sha256": sha,
+        ]
+        if let error {
+          out["error"] = error.localizedDescription
+        }
+        promise.resolve(out)
+      }.resume()
+    }
+
+    Function("cpuProfileDump") { (fileName: String) -> [String: Any]? in
+      guard let dir = Self.outputDir() else { return nil }
+      let path = dir.appendingPathComponent(fileName.replacingOccurrences(of: "/", with: "_")).path
+      guard let runtime = try? self.appContext?.runtime else {
+        return PerfLabHermes.dumpRuntime(nil, toPath: path)
+      }
+      return runtime.withUnsafePointee { pointer in
+        PerfLabHermes.dumpRuntime(pointer, toPath: path)
+      }
+    }
+  }
+
+  // The API parses at most 64 MiB of a raw profile file (MAX_RAW_BYTES in apps/api cpu-worker.ts).
+  private static let artifactMaxBytes: Int64 = 64 * 1024 * 1024
+
+  private static func outputDir() -> URL? {
+    guard let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else { return nil }
+    let dir = docs.appendingPathComponent("perf-lab", isDirectory: true)
+    try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+    return dir
+  }
+
+  // RFC 1952 around Foundation's zlib codec, which writes raw DEFLATE (RFC 1951).
+  private static func gzip(_ data: Data) -> Data? {
+    guard let deflated = try? (data as NSData).compressed(using: .zlib) as Data else { return nil }
+    var out = Data([0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff])
+    out.append(deflated)
+    var crc = crc32(data).littleEndian
+    var size = UInt32(truncatingIfNeeded: data.count).littleEndian
+    withUnsafeBytes(of: &crc) { out.append(contentsOf: $0) }
+    withUnsafeBytes(of: &size) { out.append(contentsOf: $0) }
+    return out
+  }
+
+  private static let crcTable: [UInt32] = (0..<256).map { n -> UInt32 in
+    var c = UInt32(n)
+    for _ in 0..<8 {
+      c = (c & 1) != 0 ? 0xEDB8_8320 ^ (c >> 1) : c >> 1
+    }
+    return c
+  }
+
+  private static func crc32(_ data: Data) -> UInt32 {
+    var c: UInt32 = 0xFFFF_FFFF
+    data.withUnsafeBytes { (buffer: UnsafeRawBufferPointer) in
+      for byte in buffer {
+        c = crcTable[Int((c ^ UInt32(byte)) & 0xFF)] ^ (c >> 8)
+      }
+    }
+    return c ^ 0xFFFF_FFFF
+  }
+
+  private static let flushSignalTag = 0x9E7F_1A5
+  private static let ackSignalTag = 0x9E7F_1A6
+
+  @MainActor
+  private static func showSignal(tag: Int, id: String, label status: String, value detail: String) {
+    let windows = UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .flatMap { $0.windows }
+    guard let window = windows.first(where: { $0.isKeyWindow }) ?? windows.first else { return }
+    window.viewWithTag(tag)?.removeFromSuperview()
+    let label = UILabel(frame: CGRect(x: 0, y: 0, width: 1, height: 1))
+    label.tag = tag
+    label.text = status
+    label.textColor = .clear
+    label.backgroundColor = .clear
+    label.isUserInteractionEnabled = false
+    label.isAccessibilityElement = true
+    label.accessibilityIdentifier = id
+    label.accessibilityLabel = status
+    label.accessibilityValue = detail
+    window.addSubview(label)
+  }
+
+  // The SDK keeps the journal near 2x its queue cap (16 MB); a larger file is read from its tail.
+  private static let spoolReadMax: UInt64 = 16 * 1024 * 1024
+
+  private static func readTail(_ file: URL, max: UInt64) -> String? {
+    guard let handle = try? FileHandle(forReadingFrom: file) else { return nil }
+    defer { try? handle.close() }
+    guard let size = try? handle.seekToEnd() else { return nil }
+    let start = size > max ? size - max : 0
+    guard (try? handle.seek(toOffset: start)) != nil else { return nil }
+    let data = (try? handle.readToEnd()) ?? Data()
+    let text = String(decoding: data, as: UTF8.self)
+    if start == 0 { return text }
+    guard let newline = text.firstIndex(of: "\n") else { return "" }
+    return String(text[text.index(after: newline)...])
+  }
+
+  private static func fileIfPresent(_ name: String) -> URL? {
+    guard let docs = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first else { return nil }
+    let file = docs.appendingPathComponent("perf-lab", isDirectory: true).appendingPathComponent(name)
+    return FileManager.default.fileExists(atPath: file.path) ? file : nil
+  }
+
+  private static func emit(_ message: String) {
+    var start = message.startIndex
+    while start < message.endIndex {
+      let end = message.index(start, offsetBy: logChunk, limitedBy: message.endIndex) ?? message.endIndex
+      os_log("%{public}s", log: logger, type: .info, String(message[start..<end]))
+      start = end
+    }
+  }
+
+  private func writeLog(_ message: String) {
+    Self.emit(message)
+    appendToLogFile(message)
+  }
+
+  private func appendToLogFile(_ message: String) {
+    let line = "\(Date().timeIntervalSince1970 * 1000) \(message)\n"
+    logQueue.async {
+      if self.logHandle == nil, let dir = Self.outputDir() {
+        let file = dir.appendingPathComponent("log.txt")
+        if !FileManager.default.fileExists(atPath: file.path) {
+          FileManager.default.createFile(atPath: file.path, contents: nil)
+        }
+        self.logHandle = try? FileHandle(forWritingTo: file)
+        _ = try? self.logHandle?.seekToEnd()
+      }
+      if let data = line.data(using: .utf8) {
+        try? self.logHandle?.write(contentsOf: data)
+      }
+    }
+  }
+}