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

package/ios/PerfLabSampler.swift

@@ -0,0 +1,364 @@
+import Darwin
+import Foundation
+import QuartzCore
+
+// Fallback until the SDK configures the sampler; same value as SAMPLER_MS_DEFAULT in js/sdk/sampler.ts.
+private let samplerMsDefault = 4000.0
+import UIKit
+
+private let jsThreadMarkers = ["com.facebook.react.runtime.JavaScript", "com.facebook.react.JavaScript", "mqt_js", "mqt_v_js"]
+
+private func isJsThreadName(_ name: String) -> Bool {
+  jsThreadMarkers.contains { name == $0 || name.hasPrefix($0) }
+}
+
+private let timebase: mach_timebase_info_data_t = {
+  var info = mach_timebase_info_data_t()
+  mach_timebase_info(&info)
+  return info
+}()
+
+// performance.now() in Hermes on iOS is steady_clock = mach_absolute_time.
+func perfLabMonotonicMs() -> Double {
+  Double(mach_absolute_time()) * Double(timebase.numer) / Double(timebase.denom) / 1_000_000
+}
+
+private func machCount<T>(_ type: T.Type) -> mach_msg_type_number_t {
+  mach_msg_type_number_t(MemoryLayout<T>.size / MemoryLayout<natural_t>.size)
+}
+
+private func threadCpuMs(_ thread: thread_act_t) -> Double? {
+  var info = thread_basic_info()
+  var count = machCount(thread_basic_info.self)
+  let kr = withUnsafeMutablePointer(to: &info) {
+    $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+      thread_info(thread, thread_flavor_t(THREAD_BASIC_INFO), $0, &count)
+    }
+  }
+  guard kr == KERN_SUCCESS else { return nil }
+  let seconds = Double(info.user_time.seconds) + Double(info.system_time.seconds)
+  let micros = Double(info.user_time.microseconds) + Double(info.system_time.microseconds)
+  return seconds * 1000 + micros / 1000
+}
+
+private func threadName(_ thread: thread_act_t) -> String? {
+  var info = thread_extended_info()
+  var count = machCount(thread_extended_info.self)
+  let kr = withUnsafeMutablePointer(to: &info) {
+    $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+      thread_info(thread, thread_flavor_t(THREAD_EXTENDED_INFO), $0, &count)
+    }
+  }
+  guard kr == KERN_SUCCESS else { return nil }
+  let name = withUnsafeBytes(of: info.pth_name) { raw -> String in
+    String(decoding: raw.prefix { $0 != 0 }, as: UTF8.self)
+  }
+  return name.isEmpty ? nil : name
+}
+
+private func processCpuMs() -> Double {
+  var usage = rusage()
+  getrusage(RUSAGE_SELF, &usage)
+  let seconds = Double(usage.ru_utime.tv_sec) + Double(usage.ru_stime.tv_sec)
+  let micros = Double(usage.ru_utime.tv_usec) + Double(usage.ru_stime.tv_usec)
+  return seconds * 1000 + micros / 1000
+}
+
+private func memoryMb() -> (footprint: Double, resident: Double)? {
+  var info = task_vm_info_data_t()
+  var count = machCount(task_vm_info_data_t.self)
+  let kr = withUnsafeMutablePointer(to: &info) {
+    $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+      task_info(mach_task_self_, task_flavor_t(TASK_VM_INFO), $0, &count)
+    }
+  }
+  guard kr == KERN_SUCCESS else { return nil }
+  let mb = 1024.0 * 1024.0
+  return (Double(info.phys_footprint) / mb, Double(info.resident_size) / mb)
+}
+
+// Counts presented and missed frames on the main run loop. A frame's budget is the link's own
+// scheduled cadence (targetTimestamp - timestamp of the previous callback), not link.duration:
+// on ProMotion screens the link runs at 60 Hz while duration reports the 120 Hz budget.
+// The link asks for no frame rate, so it never raises the screen's refresh rate; a single
+// 120 Hz drop between two 60 Hz callbacks is invisible.
+final class PerfLabFrameCounter: NSObject {
+  private var link: CADisplayLink?
+  private var lastTimestamp: CFTimeInterval = 0
+  private var lastBudget: CFTimeInterval = 0
+
+  private let lock: UnsafeMutablePointer<os_unfair_lock> = {
+    let pointer = UnsafeMutablePointer<os_unfair_lock>.allocate(capacity: 1)
+    pointer.initialize(to: os_unfair_lock())
+    return pointer
+  }()
+  private var presentedTotal = 0
+  private var missedTotal = 0
+  private var longestGapMs = 0.0
+  private var budgetMs = 0.0
+
+  private(set) var maxHz = 0
+  // Main thread's port, taken on the main thread when the counter first starts.
+  private var mainPort: thread_act_t = 0
+
+  var mainThread: thread_act_t {
+    os_unfair_lock_lock(lock)
+    defer { os_unfair_lock_unlock(lock) }
+    return mainPort
+  }
+
+  deinit {
+    lock.deinitialize(count: 1)
+    lock.deallocate()
+  }
+
+  func start() {
+    DispatchQueue.main.async {
+      guard self.link == nil else { return }
+      os_unfair_lock_lock(self.lock)
+      if self.mainPort == 0 {
+        self.mainPort = mach_thread_self()
+      }
+      os_unfair_lock_unlock(self.lock)
+      self.maxHz = UIScreen.main.maximumFramesPerSecond
+      self.lastTimestamp = 0
+      let link = CADisplayLink(target: self, selector: #selector(self.tick(_:)))
+      link.add(to: .main, forMode: .common)
+      self.link = link
+      let center = NotificationCenter.default
+      center.addObserver(self, selector: #selector(self.pause), name: UIApplication.willResignActiveNotification, object: nil)
+      center.addObserver(self, selector: #selector(self.pause), name: UIApplication.didBecomeActiveNotification, object: nil)
+    }
+  }
+
+  func stop() {
+    DispatchQueue.main.async {
+      self.link?.invalidate()
+      self.link = nil
+      NotificationCenter.default.removeObserver(self)
+    }
+  }
+
+  // The link stops while the app is inactive; the gap across it is not a stall.
+  @objc private func pause() {
+    lastTimestamp = 0
+  }
+
+  @objc private func tick(_ link: CADisplayLink) {
+    let timestamp = link.timestamp
+    let budget = link.targetTimestamp - timestamp
+    if lastTimestamp > 0 {
+      let gap = timestamp - lastTimestamp
+      let expected = lastBudget > 0 ? lastBudget : budget
+      let missed = expected > 0 ? max(0, Int((gap / expected).rounded()) - 1) : 0
+      os_unfair_lock_lock(lock)
+      presentedTotal += 1
+      missedTotal += missed
+      if gap * 1000 > longestGapMs {
+        longestGapMs = gap * 1000
+      }
+      budgetMs = expected * 1000
+      os_unfair_lock_unlock(lock)
+    }
+    lastTimestamp = timestamp
+    lastBudget = budget
+  }
+
+  // Totals are cumulative; the longest gap restarts with every read.
+  func read() -> (presentedTotal: Int, missedTotal: Int, longestGapMs: Double, budgetMs: Double) {
+    os_unfair_lock_lock(lock)
+    defer { os_unfair_lock_unlock(lock) }
+    let out = (presentedTotal, missedTotal, longestGapMs, budgetMs)
+    longestGapMs = 0
+    return out
+  }
+}
+
+// Off unless configured. `auto` samples on a utility queue every intervalMs and needs no JS;
+// `manual` only keeps the frame counter running and samples when asked. Every sample is logged
+// as `PERF_LAB sample {json}` through the module's native log and kept in a short ring for windows.
+final class PerfLabSampler {
+  private let queue = DispatchQueue(label: "com.gigaverse.perflab.sampler", qos: .utility)
+  private let log: (String) -> Void
+  private let frames = PerfLabFrameCounter()
+
+  private var timer: DispatchSourceTimer?
+  private var mode = "off"
+  private var intervalMs = samplerMsDefault
+  private var seq = 0
+  private var previous: (t: Double, processMs: Double, mainMs: Double?, jsMs: Double?, presented: Int, missed: Int)?
+  private var ring: [[String: Any]] = []
+  private let ringSize = 64
+  // Records of samplerRequest, kept outside the ring until taken, so a long window still finds its open sample.
+  private var pinned: [(reason: String, record: [String: Any])] = []
+  private let pinnedMax = 32
+  private var jsThread: thread_act_t = 0
+  private var jsThreadName: String?
+  private var scans = 0
+
+  init(log: @escaping (String) -> Void) {
+    self.log = log
+  }
+
+  deinit {
+    timer?.cancel()
+    frames.stop()
+    releaseJsThread()
+  }
+
+  func configure(mode newMode: String, intervalMs newInterval: Double) -> [String: Any] {
+    queue.sync {
+      mode = ["auto", "manual"].contains(newMode) ? newMode : "off"
+      intervalMs = max(250, newInterval)
+      timer?.cancel()
+      timer = nil
+      if mode == "off" {
+        frames.stop()
+        previous = nil
+        ring.removeAll()
+        pinned.removeAll()
+        releaseJsThread()
+      } else {
+        frames.start()
+        if mode == "auto" {
+          let source = DispatchSource.makeTimerSource(queue: queue)
+          let interval = DispatchTimeInterval.milliseconds(Int(intervalMs))
+          source.schedule(deadline: .now() + interval, repeating: interval, leeway: .milliseconds(Int(intervalMs / 10)))
+          source.setEventHandler { [weak self] in
+            _ = self?.collect(reason: "auto")
+          }
+          source.resume()
+          timer = source
+        }
+      }
+      return ["mode": mode, "intervalMs": intervalMs, "nowMs": perfLabMonotonicMs()]
+    }
+  }
+
+  func sample(reason: String) -> [String: Any]? {
+    queue.sync { mode == "off" ? nil : collect(reason: reason) }
+  }
+
+  // Returns at once; the sample is taken on the sampler queue (record time is taken there) and lands in the ring.
+  func request(reason: String) {
+    queue.async { [weak self] in
+      guard let self, self.mode != "off" else { return }
+      let record = self.collect(reason: reason)
+      self.pinned.append((reason, record))
+      if self.pinned.count > self.pinnedMax { self.pinned.removeFirst() }
+    }
+  }
+
+  func take(reason: String) -> [String: Any]? {
+    queue.sync {
+      guard let index = pinned.firstIndex(where: { $0.reason == reason }) else { return nil }
+      return pinned.remove(at: index).record
+    }
+  }
+
+  func recent(since t: Double) -> [[String: Any]] {
+    queue.sync { ring.filter { (($0["t"] as? Double) ?? 0) >= t } }
+  }
+
+  private func releaseJsThread() {
+    if jsThread != 0 {
+      mach_port_deallocate(mach_task_self_, jsThread)
+      jsThread = 0
+      jsThreadName = nil
+    }
+  }
+
+  // task_threads hands out a send right per thread; the JS thread's right is kept so its port
+  // stays valid between samples, every other right is released.
+  private func findJsThread() {
+    var list: thread_act_array_t?
+    var count: mach_msg_type_number_t = 0
+    guard task_threads(mach_task_self_, &list, &count) == KERN_SUCCESS, let list else { return }
+    for i in 0..<Int(count) {
+      let thread = list[i]
+      if jsThread == 0, let name = threadName(thread), isJsThreadName(name) {
+        jsThread = thread
+        jsThreadName = name
+      } else {
+        mach_port_deallocate(mach_task_self_, thread)
+      }
+    }
+    vm_deallocate(mach_task_self_, vm_address_t(UInt(bitPattern: list)), vm_size_t(Int(count) * MemoryLayout<thread_t>.stride))
+  }
+
+  private func jsCpuMs() -> Double? {
+    if jsThread != 0, let ms = threadCpuMs(jsThread) {
+      return ms
+    }
+    releaseJsThread()
+    // A missing JS thread is looked for again every 5th sample, not on every one.
+    if scans % 5 == 0 {
+      findJsThread()
+    }
+    scans += 1
+    return jsThread == 0 ? nil : threadCpuMs(jsThread)
+  }
+
+  private func collect(reason: String) -> [String: Any] {
+    let started = perfLabMonotonicMs()
+    let t = started
+    let processMs = processCpuMs()
+    let main = frames.mainThread
+    let mainMs = main == 0 ? nil : threadCpuMs(main)
+    let jsMs = jsCpuMs()
+    let memory = memoryMb()
+    let frame = frames.read()
+    seq += 1
+
+    var cpu: [String: Any] = ["processMs": processMs]
+    if let mainMs { cpu["mainMs"] = mainMs }
+    if let jsMs { cpu["jsMs"] = jsMs }
+    if let jsThreadName { cpu["jsThread"] = jsThreadName }
+    var framesOut: [String: Any] = [
+      "presentedTotal": frame.presentedTotal,
+      "missedTotal": frame.missedTotal,
+      "longestGapMs": frame.longestGapMs,
+      "budgetMs": frame.budgetMs,
+      "maxHz": frames.maxHz,
+    ]
+    var record: [String: Any] = [
+      "v": 1,
+      "platform": "ios",
+      "seq": seq,
+      "reason": reason,
+      "t": t,
+      "wallMs": Date().timeIntervalSince1970 * 1000,
+      "thermal": ProcessInfo.processInfo.thermalState.rawValue,
+      "intervalMs": intervalMs,
+      "mode": mode,
+    ]
+    if let memory {
+      record["mem"] = ["footprintMb": memory.footprint, "residentMb": memory.resident]
+    } else {
+      record["mem"] = [String: Any]()
+    }
+    if let previous, t > previous.t {
+      let dt = t - previous.t
+      record["dtMs"] = dt
+      cpu["processCores"] = (processMs - previous.processMs) / dt
+      if let mainMs, let before = previous.mainMs { cpu["mainCores"] = (mainMs - before) / dt }
+      if let jsMs, let before = previous.jsMs, jsMs >= before { cpu["jsCores"] = (jsMs - before) / dt }
+      framesOut["presented"] = frame.presentedTotal - previous.presented
+      framesOut["missed"] = frame.missedTotal - previous.missed
+    }
+    previous = (t, processMs, mainMs, jsMs, frame.presentedTotal, frame.missedTotal)
+    record["cpu"] = cpu
+    record["frames"] = framesOut
+    record["collectMs"] = perfLabMonotonicMs() - started
+
+    ring.append(record)
+    if ring.count > ringSize {
+      ring.removeFirst(ring.count - ringSize)
+    }
+    if let data = try? JSONSerialization.data(withJSONObject: record),
+       let json = String(data: data, encoding: .utf8) {
+      log("PERF_LAB sample \(json)")
+    }
+    return record
+  }
+}

package/js/babel-transformer.js

@@ -0,0 +1,71 @@
+// Wraps the app's Babel transformer (set by withPerfLab) and adds one import to
+// the entry module: the perf-lab boot module. That import is what puts the SDK
+// in the graph; getModulesRunBeforeMainModule then runs it before the entry.
+//
+// babel-preset-expo inlines EXPO_PUBLIC_* only outside node_modules, and the
+// SDK is installed into node_modules, so this wrapper inlines the SDK's own
+// EXPO_PUBLIC_* reads with the build-time values.
+
+const path = require('path');
+
+const upstreamPath = (process.env.KEEPSNAPPY_UPSTREAM_BABEL_TRANSFORMER ?? process.env.PERFLAB_UPSTREAM_BABEL_TRANSFORMER);
+const entryFile = (process.env.KEEPSNAPPY_ENTRY_FILE ?? process.env.PERFLAB_ENTRY_FILE);
+const bootFile = (process.env.KEEPSNAPPY_BOOT_FILE ?? process.env.PERFLAB_BOOT_FILE);
+
+if (!upstreamPath || !entryFile || !bootFile) {
+  throw new Error(
+    'KeepSnappy Babel transformer loaded without withKeepSnappy env (KEEPSNAPPY_*)',
+  );
+}
+
+const upstream = require(upstreamPath);
+
+const packageRoot = path.resolve(__dirname, '..') + path.sep;
+const ENV_REF = /\bprocess\.env\.(EXPO_PUBLIC_[A-Z0-9_]+)\b/g;
+
+const inlineEnv = src =>
+  src.replace(ENV_REF, (_match, name) =>
+    process.env[name] === undefined ? 'undefined' : JSON.stringify(process.env[name]),
+  );
+
+const envSignature = () =>
+  Object.keys(process.env)
+    .filter(name => (name.startsWith('EXPO_PUBLIC_PERF') || name.startsWith('EXPO_PUBLIC_KEEPSNAPPY')))
+    .sort()
+    .map(name => `${name}=${process.env[name]}`)
+    .join('&');
+
+const bootImport = () => {
+  let rel = path
+    .relative(path.dirname(entryFile), bootFile)
+    .replace(/\\/g, '/')
+    .replace(/\.tsx?$/, '');
+  if (!rel.startsWith('.')) {
+    rel = `./${rel}`;
+  }
+  return `import ${JSON.stringify(rel)};\n`;
+};
+
+const absolute = (filename, options) =>
+  path.resolve(options?.projectRoot ?? process.cwd(), filename);
+
+module.exports = {
+  ...upstream,
+  transform(args) {
+    const file = absolute(args.filename, args.options);
+    if (file === entryFile) {
+      return upstream.transform({ ...args, src: bootImport() + args.src });
+    }
+    if (file.startsWith(packageRoot)) {
+      return upstream.transform({ ...args, src: inlineEnv(args.src) });
+    }
+    return upstream.transform(args);
+  },
+  getCacheKey(...args) {
+    const base =
+      typeof upstream.getCacheKey === 'function'
+        ? upstream.getCacheKey(...args)
+        : '';
+    return `${base}$perflab:${entryFile}:${bootFile}:${envSignature()}`;
+  },
+};