Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
33 commits
Select commit Hold shift + click to select a range
7e7ec25
feat(runtime): find JS/native cycles that wrapper lifetime modes leak
edusperoni Nov 13, 2026
e2bb1cd
test(runtime): leak probe on in-flight requests and self-referencing …
edusperoni Nov 13, 2026
cd10175
feat(runtime): inspect leak-probe classes from a Darwin notification
edusperoni Nov 13, 2026
1b95cc8
fix(runtime): leak probe reads no class from objects other threads ma…
edusperoni Nov 14, 2026
d48a479
fix(runtime): leak probe reads retain counts without messaging classes
edusperoni Nov 17, 2026
7159f73
fix(runtime): leak probe follows a WeakMap value from its key only
edusperoni Nov 17, 2026
1a14627
fix(runtime): leak probe reads memory other threads may free, and cle…
edusperoni Nov 17, 2026
caa6dfd
fix(runtime): leak probe skips pointers that do not own
edusperoni Nov 17, 2026
881a31e
fix(runtime): leak probe models the handles ReconcileOwnership keeps …
edusperoni Nov 17, 2026
481a3d1
fix(runtime): stable leak signatures, and strict reports every defaul…
edusperoni Nov 17, 2026
8a6616c
test(runtime): leak probe inspect, UIKit, notification and accounting…
edusperoni Nov 17, 2026
a4e126f
docs(runtime): leak probe report fields, limits and blind spots
edusperoni Nov 17, 2026
de9f62c
fix(runtime): leak probe keeps an attached layer's delegate edge
edusperoni Nov 17, 2026
bfff74e
test(runtime): exact leak probe notification spec, calibration-agnost…
edusperoni Nov 17, 2026
d78a2a8
style(runtime): clang-format
edusperoni Nov 17, 2026
d5b253b
feat(runtime): move the leak probe into NativeScriptLeakProbe.framework
edusperoni Nov 17, 2026
c86ea8e
test(runtime): leak diagnostics in workers, with and without the prob…
edusperoni Nov 17, 2026
4fcc911
build: ship NativeScriptLeakProbe.xcframework next to TKLiveSync
edusperoni Nov 17, 2026
98b5417
feat(templates): leave NativeScriptLeakProbe out of release builds
edusperoni Nov 17, 2026
ca47522
docs(runtime): leak diagnostics need the debug-only NativeScriptLeakP…
edusperoni Nov 17, 2026
4c92c72
test(runtime): gesture recognizer leak cycle exists only when every w…
edusperoni Nov 17, 2026
1b28630
fix(runtime): canary state enumeration skips objects whose -dealloc s…
edusperoni Nov 18, 2026
cdd14c5
test(runtime): leak probe notification spec is pending while triggers…
edusperoni Nov 18, 2026
e9033cf
docs(runtime): JS block callback edges come only from findLeakCycles …
edusperoni Nov 18, 2026
2e02250
fix(runtime): leak probe marking skips the root edges of objects that…
edusperoni Nov 18, 2026
e990ed9
fix(runtime): leak probe counts a reference an object holds to itself…
edusperoni Nov 18, 2026
645b902
fix(runtime): leak probe bounds the storage one object's scan reads
edusperoni Nov 18, 2026
7487f59
fix(runtime): leak probe keeps a WeakMap value alive only while its k…
edusperoni Nov 18, 2026
5224ecc
fix(runtime): leak probe reads retain counts only where a freed objec…
edusperoni Nov 18, 2026
1dd20d4
fix(runtime): leak probe pairs a WeakMap entry's edges whatever V8 nu…
edusperoni Nov 18, 2026
2ffc322
docs(leak-probe): note gesture recognizer cycles are missed before iO…
edusperoni Nov 18, 2026
53548a0
build: link and embed NativeScriptLeakProbe in Mac Catalyst TestRunne…
edusperoni Nov 18, 2026
7669cfc
fix(runtime): leak probe visits canary states outside the registry lo…
edusperoni Nov 18, 2026
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions NativeScript/runtime/Interop.h
Original file line number Diff line number Diff line change
Expand Up @@ -169,6 +169,14 @@ class Interop {
const TypeEncoding* typeEncoding, void* dest,
v8::Local<v8::Value> arg);
static id ToObject(v8::Local<v8::Context> context, v8::Local<v8::Value> arg);
// The JS function `block` calls when CreateBlock built it for this isolate,
// held strongly until the block is disposed; empty for any other block and
// once disposal has started. `block` must be alive, and the caller must
// hold the isolate's Locker.
static v8::Local<v8::Value> JSBlockCallback(v8::Isolate* isolate,
const void* block);
// Whether CreateBlock built `block` (for any isolate). `block` must be alive.
static bool IsJSBlock(const void* block);
static v8::Local<v8::Value> GetPrimitiveReturnType(
v8::Local<v8::Context> context, BinaryTypeEncodingType type,
BaseCall* call);
Expand Down
21 changes: 21 additions & 0 deletions NativeScript/runtime/Interop.mm
Original file line number Diff line number Diff line change
Expand Up @@ -92,6 +92,27 @@
static constexpr int32_t kBlockDeallocating = 0x0001;
static constexpr int32_t kBlockRefcountMask = 0xfffe;

bool Interop::IsJSBlock(const void* block) {
return static_cast<const JSBlock*>(block)->descriptor == &JSBlock::kJSBlockDescriptor;
}

Local<Value> Interop::JSBlockCallback(Isolate* isolate, const void* block) {
const JSBlock* jsBlock = static_cast<const JSBlock*>(block);
// Dispose frees the callback wrapper after it releases the Locker, so only
// a block not yet disposing is read; one that starts disposing now waits
// for the caller's Locker before it touches the wrapper.
if (!IsJSBlock(block) ||
(__atomic_load_n(&jsBlock->flags, __ATOMIC_ACQUIRE) & kBlockDeallocating) != 0) {
return Local<Value>();
}
MethodCallbackWrapper* wrapper = static_cast<MethodCallbackWrapper*>(jsBlock->userData);
if (wrapper == nullptr || wrapper->isolateWrapper_.Isolate() != isolate ||
wrapper->callback_ == nullptr || wrapper->callback_->IsEmpty()) {
return Local<Value>();
}
return wrapper->callback_->Get(isolate);
}

// libclosure's increment ignores the deallocating bit, so Block_copy would hand
// out a block whose dispose is already waiting for the isolate's Locker and
// which libclosure frees right after. This CASes the same word libclosure does.
Expand Down
25 changes: 25 additions & 0 deletions NativeScript/runtime/LeakProbe.h
Original file line number Diff line number Diff line change
@@ -0,0 +1,25 @@
#ifndef LeakProbe_h
#define LeakProbe_h

#include "Common.h"

namespace tns {

// The runtime's side of NativeScriptLeakProbe.framework (LeakProbeSPI.h), the
// JS <-> native cycle finder apps embed in debug builds only. Without the
// framework an isolate has no embedder graph in its heap snapshots and no
// leak-probe triggers, and ns:runtime's findLeakCycles and
// getWrapperClassCounts throw.
class LeakProbe {
public:
// Offers the isolate to the framework, when the process has it.
static void Init(v8::Isolate* isolate);

// Adds getWrapperClassCounts and findLeakCycles to the ns:runtime binding.
static bool RegisterFunctions(v8::Local<v8::Context> context,
v8::Local<v8::Object> binding);
};

} // namespace tns

#endif /* LeakProbe_h */
236 changes: 236 additions & 0 deletions NativeScript/runtime/LeakProbe.mm
Original file line number Diff line number Diff line change
@@ -0,0 +1,236 @@
#include "LeakProbe.h"
#include <dlfcn.h>
#include <memory>
#include "Caches.h"
#include "ClassBuilder.h"
#include "DataWrapper.h"
#include "EventLoop.h"
#include "Helpers.h"
#include "Interop.h"
#include "LeakProbeSPI.h"
#include "ObjectManager.h"
#include "Runtime.h"
#include "RuntimeConfig.h"
#include "WrapperLifetime.h"
#include "WrapperLifetimeCanary.h"

using namespace v8;

namespace tns {
namespace leakprobe {

struct Poster {
Isolate* isolate;
std::weak_ptr<EventLoop> loop;
};

} // namespace leakprobe

namespace {

using leakprobe::Host;
using leakprobe::Instance;
using leakprobe::Poster;
using leakprobe::Probe;

constexpr const char* kFramework = "NativeScriptLeakProbe.framework";

struct ProbeState {
bool attached = false;
void* state = nullptr;
void (*destroy)(void*) = nullptr;

~ProbeState() {
if (destroy != nullptr) {
destroy(state);
}
}
};

bool ForEachInstance(Isolate* isolate, void* context,
void (*visit)(void* context, const Instance& instance)) {
std::shared_ptr<Caches> cache = Caches::Get(isolate);
if (cache == nullptr || !cache->IsValid()) {
return false;
}
for (auto& entry : cache->Instances) {
const std::shared_ptr<Persistent<Value>>& handle = entry.second;
Instance instance{};
instance.object = (__bridge void*)entry.first;
if (handle != nullptr && !handle->IsEmpty()) {
instance.wrapper = handle->Get(isolate);
BaseDataWrapper* data = GetValue(isolate, instance.wrapper);
if (data != nullptr && data->Type() == WrapperType::ObjCObject) {
ObjCDataWrapper* wrapper = static_cast<ObjCDataWrapper*>(data);
instance.objc = true;
instance.wrapped = (__bridge void*)wrapper->Data();
instance.wrappedClass = wrapper->Klass();
ObjectWeakCallbackState* lifetime = wrapper->LifetimeState();
instance.rootedStrong =
lifetime != nullptr && lifetime->lifetimeTracked_ && lifetime->lifetimeStrong_;
ObjectWeakCallbackState* ownership = wrapper->OwnershipState();
instance.reconciledStrong = ownership != nullptr && !ownership->disposing_ &&
ownership->target_ == handle && !handle->IsWeak();
}
}
visit(context, instance);
}
return true;
}

void ForEachCanaryState(Isolate* isolate, void* context,
void (*visit)(void* context, id object, Local<Object> state)) {
WrapperLifetimeCanary::ForEachState(
isolate, [&](id object, Local<Object> state) { visit(context, object, state); });
}

void* IsolateState(Isolate* isolate) {
ProbeState* probe = Caches::StateFor<ProbeState>(isolate);
return probe != nullptr ? probe->state : nullptr;
}

bool SetIsolateState(Isolate* isolate, void* state, void (*destroy)(void*)) {
ProbeState* probe = Caches::StateFor<ProbeState>(isolate);
if (probe == nullptr) {
return false;
}
if (probe->destroy != nullptr) {
probe->destroy(probe->state);
}
probe->state = state;
probe->destroy = destroy;
return true;
}

Poster* CreatePoster(Isolate* isolate) {
Runtime* runtime = Runtime::GetRuntime(isolate);
if (runtime == nullptr || runtime->GetEventLoop() == nullptr) {
return nullptr;
}
return new Poster{isolate, runtime->GetEventLoop()};
}

bool Post(Poster* poster, void (*task)(Isolate* isolate, void* context), void* context) {
std::shared_ptr<EventLoop> loop = poster->loop.lock();
if (loop == nullptr) {
return false;
}
Isolate* isolate = poster->isolate;
return loop->PostInternal([isolate, task, context]() { task(isolate, context); });
}

bool LifetimeStats(Isolate* isolate, leakprobe::LifetimeStats* out) {
ObjectManager::LifetimeStats* stats = ObjectManager::GetLifetimeStats(isolate);
if (stats == nullptr) {
return false;
}
*out = {
.resurrections = stats->resurrections,
.collected = stats->collected,
.releasedExplicitly = stats->releasedExplicitly,
.releasedAccesses = stats->releasedAccesses,
.queuedReleases = stats->queuedReleases,
.canaryStates = stats->canaryStates,
.canaryNativeDeaths = stats->canaryNativeDeaths,
};
return true;
}

const Host kHost = {
.version = leakprobe::kVersion,
.size = sizeof(Host),
.forEachInstance = ForEachInstance,
.forEachCanaryState = ForEachCanaryState,
.isJSBlock = Interop::IsJSBlock,
.jsBlockCallback = Interop::JSBlockCallback,
.nativeClass = ClassBuilder::FindNativeClass,
.isolateState = IsolateState,
.setIsolateState = SetIsolateState,
.createPoster = CreatePoster,
.post = Post,
.destroyPoster = [](Poster* poster) { delete poster; },
.drainReleases = WrapperLifetime::DrainReleases,
.lifetimeMode = []() { return WrapperLifetimeModeName(GetWrapperLifetimeMode()); },
.lifetimeScope = []() { return WrapperLifetimeScopeName(GetWrapperLifetimeScope()); },
.lifetimeStats = LifetimeStats,
.appConfigValue = [](const char* key) { return Runtime::GetAppConfigValue(key); },
.isDebug = []() { return RuntimeConfig.IsDebug; },
.log = [](const char* message) { Log("%s", message); },
};

// The framework's Probe, once per process: dyld loads the framework, when the
// app embeds it, before the runtime starts.
const Probe* ConnectedProbe() {
static const Probe* probe = []() -> const Probe* {
auto connect = reinterpret_cast<leakprobe::ConnectFunction>(
dlsym(RTLD_DEFAULT, leakprobe::kConnectSymbol));
if (connect == nullptr) {
return nullptr;
}
const Probe* connected = connect(&kHost);
if (connected == nullptr || connected->version != leakprobe::kVersion ||
connected->size != sizeof(Probe)) {
Log("NativeScript: ignoring %s, built for another runtime version", kFramework);
return nullptr;
}
return connected;
}();
return probe;
}

const Probe* AttachedProbe(Isolate* isolate) {
ProbeState* state = Caches::ExistingStateFor<ProbeState>(isolate);
return state != nullptr && state->attached ? ConnectedProbe() : nullptr;
}

void ThrowAbsent(Isolate* isolate, const char* function) {
std::string message = std::string(function) + " needs " + kFramework +
", which apps embed only in debug builds by default. To ship it in "
"other builds, add " +
kFramework + " to NS_SHIP_DEBUG_FRAMEWORKS in the app's build.xcconfig.";
isolate->ThrowException(Exception::Error(ToV8String(isolate, message)));
}

void FindLeakCyclesCallback(const FunctionCallbackInfo<Value>& info) {
if (const Probe* probe = AttachedProbe(info.GetIsolate())) {
probe->findLeakCycles(info);
return;
}
ThrowAbsent(info.GetIsolate(), "findLeakCycles");
}

void GetWrapperClassCountsCallback(const FunctionCallbackInfo<Value>& info) {
if (const Probe* probe = AttachedProbe(info.GetIsolate())) {
probe->getWrapperClassCounts(info);
return;
}
ThrowAbsent(info.GetIsolate(), "getWrapperClassCounts");
}

} // namespace

void LeakProbe::Init(Isolate* isolate) {
const Probe* probe = ConnectedProbe();
if (probe == nullptr) {
return;
}
std::shared_ptr<Caches> cache = Caches::Get(isolate);
ProbeState* state = Caches::StateFor<ProbeState>(isolate);
if (cache == nullptr || state == nullptr) {
return;
}
state->attached = probe->attach(isolate, !cache->isWorker);
}

bool LeakProbe::RegisterFunctions(Local<Context> context, Local<Object> binding) {
Isolate* isolate = Isolate::GetCurrent();
Local<v8::Function> counts;
Local<v8::Function> cycles;
return v8::Function::New(context, GetWrapperClassCountsCallback).ToLocal(&counts) &&
v8::Function::New(context, FindLeakCyclesCallback).ToLocal(&cycles) &&
binding->Set(context, ToV8String(isolate, "getWrapperClassCounts"), counts)
.FromMaybe(false) &&
binding->Set(context, ToV8String(isolate, "findLeakCycles"), cycles).FromMaybe(false);
}

} // namespace tns
Loading
Loading