Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
16 commits
Select commit Hold shift + click to select a range
00c214e
perf(android): pass Java to JS call arguments as primitive arrays
ammarahm-ed Nov 9, 2026
7d420a3
perf(android): keep the cached JNIEnv and its pinned flag in one thre…
ammarahm-ed Nov 11, 2026
4d4c290
perf(android): resolve cached method signatures without allocating
ammarahm-ed Nov 11, 2026
da925f0
perf(android): look up a base method's counterpart by name hash
ammarahm-ed Nov 11, 2026
3f389a4
perf(android): pack the call argument type ids into the values array
ammarahm-ed Nov 11, 2026
288354b
perf(android): keep Java objects in one id-indexed table instead of f…
ammarahm-ed Nov 11, 2026
0765188
perf(android): hand finalized object ids to Java in one batched upcall
ammarahm-ed Nov 11, 2026
da5aebc
perf(android): register a constructed instance and read the heap size…
ammarahm-ed Nov 11, 2026
fd129ff
fix(android): only an instance of the class JS is constructing takes …
ammarahm-ed Nov 11, 2026
0a675e2
perf(android): pass the method name id so native keeps each name once…
ammarahm-ed Nov 11, 2026
3c5b34e
perf(android): bind the runtime's own exported functions locally
ammarahm-ed Nov 11, 2026
d2ade0b
perf(android): send a dense class index with each object so native ca…
ammarahm-ed Nov 11, 2026
3e08da1
perf(android): tag each binding with its runtime and object id and in…
ammarahm-ed Nov 11, 2026
56281b4
perf(android): switch large static field sets to dictionary mode and …
ammarahm-ed Nov 11, 2026
124bf43
perf(android): create Java instance methods as non-constructors on V8
ammarahm-ed Nov 11, 2026
58ef716
test(android): add specs and benchmark rows for the JNI bridge changes
ammarahm-ed Nov 11, 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
119 changes: 76 additions & 43 deletions NativeScript/ffi/jni/jsi/callbackhandlers/CallbackHandlers.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -112,9 +112,12 @@ void CallbackHandlers::Init(JsRuntime &rt) {
CURRENT_OBJECTID_FIELD_ID = jEnv.GetFieldID(RUNTIME_CLASS, "currentObjectId", "I");
assert(CURRENT_OBJECTID_FIELD_ID != nullptr);

MAKE_INSTANCE_STRONG_ID = jEnv.GetMethodID(RUNTIME_CLASS, "makeInstanceStrong",
"(Ljava/lang/Object;I)V");
assert(MAKE_INSTANCE_STRONG_ID != nullptr);
CURRENT_OBJECTCLASS_FIELD_ID = jEnv.GetFieldID(RUNTIME_CLASS, "currentObjectClass", "Ljava/lang/Class;");
assert(CURRENT_OBJECTCLASS_FIELD_ID != nullptr);

REGISTER_CONSTRUCTED_INSTANCE_ID = jEnv.GetMethodID(RUNTIME_CLASS, "registerConstructedInstance",
"(Ljava/lang/Object;I)J");
assert(REGISTER_CONSTRUCTED_INSTANCE_ID != nullptr);

GET_TYPE_METADATA = jEnv.GetStaticMethodID(RUNTIME_CLASS, "getTypeMetadata",
"(Ljava/lang/String;I)[Ljava/lang/String;");
Expand Down Expand Up @@ -164,10 +167,10 @@ JsValue CallbackHandlers::CallJavaMethod(JsRuntime &rt, const JsValue &caller, c
JEnv jEnv;
jclass clazz;
jmethodID mid;
string *sig = nullptr;
string *returnType = nullptr;
const string *sig = nullptr;
const string *returnType = nullptr;
auto retType = MethodReturnType::Unknown;
MethodCache::CacheMethodInfo mi;
const MethodCache::CacheMethodInfo *mi = nullptr;
bool isSuper = false;

if (metadataSignatureIsUnambiguous && entry != nullptr &&
Expand Down Expand Up @@ -287,8 +290,8 @@ JsValue CallbackHandlers::CallJavaMethod(JsRuntime &rt, const JsValue &caller, c

clazz = jEnv.FindClass(className);
if (clazz != nullptr) {
mi = MethodCache::ResolveMethodSignature(rt, className, methodName, argc, argv, isStatic);
if (mi.mid == nullptr) {
mi = &MethodCache::ResolveMethodSignature(rt, className, methodName, argc, argv, isStatic);
if (mi->mid == nullptr) {
DEBUG_WRITE("Cannot resolve class=%s, method=%s, isStatic=%d, isSuper=%d",
className.c_str(), methodName.c_str(), isStatic, isSuper);
return js_util::undefined();
Expand All @@ -298,9 +301,9 @@ JsValue CallbackHandlers::CallJavaMethod(JsRuntime &rt, const JsValue &caller, c
const string callerClassName = callerNode->GetName();
DEBUG_WRITE("Resolving method on caller class: %s.%s on className %s",
callerClassName.c_str(), methodName.c_str(), className.c_str());
mi = MethodCache::ResolveMethodSignature(rt, callerClassName, methodName, argc, argv,
mi = &MethodCache::ResolveMethodSignature(rt, callerClassName, methodName, argc, argv,
isStatic);
if (mi.mid == nullptr) {
if (mi->mid == nullptr) {
DEBUG_WRITE(
"Cannot resolve class=%s, method=%s, isStatic=%d, isSuper=%d, callerClass=%s",
className.c_str(), methodName.c_str(), isStatic, isSuper,
Expand All @@ -309,11 +312,11 @@ JsValue CallbackHandlers::CallJavaMethod(JsRuntime &rt, const JsValue &caller, c
}
}

clazz = mi.clazz;
mid = mi.mid;
sig = &mi.signature;
returnType = &mi.returnType;
retType = mi.retType;
clazz = mi->clazz;
mid = mi->mid;
sig = &mi->signature;
returnType = &mi->returnType;
retType = mi->retType;
}

if (!isStatic) {
Expand Down Expand Up @@ -513,14 +516,15 @@ JsValue CallbackHandlers::CallJavaMethod(JsRuntime &rt, const JsValue &caller, c
if (isString) {
returnValue = ArgConverter::jstringToJsString(rt, (jstring) result);
} else {
jint javaObjectID = objectManager->GetOrCreateObjectId(result);
jlong packed = objectManager->GetOrCreateObjectIdAndClass(result);
jint javaObjectID = ObjectManager::IdOf(packed);
returnValue = objectManager->GetJsObjectByJavaObject(javaObjectID);

if (js_util::is_null_or_undefined(returnValue)) {
MetadataNode *returnNode = ResolveDeclaredReturnNode(jEnv, entry, result);
returnValue = returnNode != nullptr
? objectManager->CreateJSWrapper(javaObjectID, returnNode, entry->returnClass)
: objectManager->CreateJSWrapper(javaObjectID, *returnType, result);
: objectManager->CreateJSWrapper(javaObjectID, ObjectManager::ClassIndexOf(packed), result);
}
}

Expand All @@ -536,6 +540,44 @@ JsValue CallbackHandlers::CallJavaMethod(JsRuntime &rt, const JsValue &caller, c
}


class CallbackHandlers::ConstructionScope {
public:
struct Construction {
int id;
jclass clazz;
};

ConstructionScope(jobject javaRuntime, int javaObjectId, jclass clazz)
: _javaRuntime(javaRuntime), _previous(s_current) {
Publish({javaObjectId, clazz});
}

~ConstructionScope() {
Publish(_previous);
}

ConstructionScope(const ConstructionScope &) = delete;

ConstructionScope &operator=(const ConstructionScope &) = delete;

private:
void Publish(const Construction &construction) {
s_current = construction;
JNIEnv *env = JEnv();
if (construction.id != -1) {
env->SetObjectField(_javaRuntime, CURRENT_OBJECTCLASS_FIELD_ID, construction.clazz);
}
env->SetIntField(_javaRuntime, CURRENT_OBJECTID_FIELD_ID, construction.id);
}

static thread_local Construction s_current;

jobject _javaRuntime;
Construction _previous;
};

thread_local CallbackHandlers::ConstructionScope::Construction CallbackHandlers::ConstructionScope::s_current = {-1, nullptr};

bool CallbackHandlers::RegisterInstance(JsRuntime &rt, const JsValue &jsObject,
const std::string &fullClassName,
const ArgsWrapper &argWrapper,
Expand All @@ -562,15 +604,12 @@ bool CallbackHandlers::RegisterInstance(JsRuntime &rt, const JsValue &jsObject,
objectManager->Link(jsObject, javaObjectID, nullptr, node);

// resolve constructor
auto mi = MethodCache::ResolveConstructorSignature(rt, argWrapper, fullClassName,
const auto &mi = MethodCache::ResolveConstructorSignature(rt, argWrapper, fullClassName,
generatedJavaClass, isInterface);

// while the "instance" is being created, if an exception is thrown during the construction
// this scope will guarantee the "javaObjectID" will be set to -1 and won't have an invalid value
jobject instance;
{
JavaObjectIdScope objIdScope(jEnv, CURRENT_OBJECTID_FIELD_ID, runtime->GetJavaRuntime(),
javaObjectID);
ConstructionScope construction(runtime->GetJavaRuntime(), javaObjectID, generatedJavaClass);

if (argWrapper.type == ArgType::Interface) {
instance = jEnv.NewObject(generatedJavaClass, mi.mid);
Expand Down Expand Up @@ -601,10 +640,10 @@ bool CallbackHandlers::RegisterInstance(JsRuntime &rt, const JsValue &jsObject,
}
}

jEnv.CallVoidMethod(runtime->GetJavaRuntime(), MAKE_INSTANCE_STRONG_ID, instance, javaObjectID);
jlong usedMemory = jEnv.CallLongMethod(runtime->GetJavaRuntime(), REGISTER_CONSTRUCTED_INSTANCE_ID, instance, javaObjectID);

// Reuse the runtime we already resolved instead of re-querying via rt.
runtime->AdjustAmountOfExternalAllocatedMemory();
runtime->AdjustAmountOfExternalAllocatedMemory(usedMemory);
runtime->TryCallGC();

JniLocalRef localInstance(instance);
Expand Down Expand Up @@ -1133,26 +1172,26 @@ vector<string> CallbackHandlers::GetTypeMetadata(const string &name, int index)

JsValue CallbackHandlers::CallJSMethod(JsRuntime &rt, JNIEnv *_jEnv,
const JsValue &jsObject, jclass claz,
const string &methodName, int javaObjectId,
jobjectArray args) {
const JSMethodCache::MethodName &methodName, int javaObjectId,
const JavaCallArgs &args) {
JEnv jEnv(_jEnv);

auto runtime = Runtime::GetRuntime(rt);
JsValue method = runtime->js_method_cache->getCachedMethod(javaObjectId, methodName);
JsValue method = runtime->js_method_cache->getCachedMethod(javaObjectId, methodName.id);
if (method.isUndefined()) {
method = jsObject.asObjectBorrowed(rt).getProperty(rt, methodName);
method = jsObject.asObjectBorrowed(rt).getProperty(rt, methodName.value);
if (method.isObject() && method.asObjectBorrowed(rt).isFunction(rt)) {
runtime->js_method_cache->cacheMethod(javaObjectId, methodName, method);
runtime->js_method_cache->cacheMethod(javaObjectId, methodName.id, method);
}
}

if (!method.isObject() || !method.asObjectBorrowed(rt).isFunction(rt)) {
stringstream ss;
ss << "Cannot find method '" << methodName << "' implementation";
ss << "Cannot find method '" << methodName.name << "' implementation";
throw NativeScriptException(ss.str());
}

DEBUG_WRITE("Calling JS Method %s", methodName.c_str());
DEBUG_WRITE("Calling JS Method %s", methodName.name.c_str());

auto fn = method.asObjectBorrowed(rt).asFunction(rt);
auto receiver = jsObject.asObjectBorrowed(rt);
Expand All @@ -1161,7 +1200,7 @@ JsValue CallbackHandlers::CallJSMethod(JsRuntime &rt, JNIEnv *_jEnv,
// a throw. engine:: propagates a JS throw as a JSError, so the equivalent is
// to let it unwind and convert it here.
try {
int argc = jEnv.GetArrayLength(args) / 3;
int argc = args.count;
if (argc > 0) {
JsValue *jsArgs = nullptr;
JsValue stack_args[8];
Expand All @@ -1179,9 +1218,9 @@ JsValue CallbackHandlers::CallJSMethod(JsRuntime &rt, JNIEnv *_jEnv,
return fn.callWithThis(rt, receiver);
} catch (JsError &e) {
if (e.value() != nullptr) {
throw NativeScriptException(rt, *e.value(), "Error calling js method: " + methodName);
throw NativeScriptException(rt, *e.value(), "Error calling js method: " + methodName.name);
}
throw NativeScriptException("Error calling js method: " + methodName + ": " + e.what());
throw NativeScriptException("Error calling js method: " + methodName.name + ": " + e.what());
}
}

Expand All @@ -1192,14 +1231,7 @@ JsValue CallbackHandlers::FindClass(JsRuntime &rt, const char *name) {
auto runtime = Runtime::GetRuntime(rt);
auto objectManager = runtime->GetObjectManager();

jint javaObjectID = objectManager->GetOrCreateObjectId(javaClass);
JsValue clazz = objectManager->GetJsObjectByJavaObject(javaObjectID);

if (js_util::is_null_or_undefined(clazz)) {
clazz = objectManager->CreateJSWrapper(javaObjectID, "Ljava/lang/Class;", javaClass);
}

return clazz;
return objectManager->GetOrCreateJSWrapper(javaClass);
}
return js_util::undefined();
}
Expand Down Expand Up @@ -1806,8 +1838,9 @@ short CallbackHandlers::MAX_JAVA_STRING_ARRAY_LENGTH = 100;
jclass CallbackHandlers::RUNTIME_CLASS = nullptr;
jclass CallbackHandlers::JAVA_LANG_STRING = nullptr;
jfieldID CallbackHandlers::CURRENT_OBJECTID_FIELD_ID = nullptr;
jfieldID CallbackHandlers::CURRENT_OBJECTCLASS_FIELD_ID = nullptr;
jmethodID CallbackHandlers::RESOLVE_CLASS_METHOD_ID = nullptr;
jmethodID CallbackHandlers::MAKE_INSTANCE_STRONG_ID = nullptr;
jmethodID CallbackHandlers::REGISTER_CONSTRUCTED_INSTANCE_ID = nullptr;
jmethodID CallbackHandlers::GET_TYPE_METADATA = nullptr;
jmethodID CallbackHandlers::ENABLE_VERBOSE_LOGGING_METHOD_ID = nullptr;
jmethodID CallbackHandlers::DISABLE_VERBOSE_LOGGING_METHOD_ID = nullptr;
Expand Down
22 changes: 5 additions & 17 deletions NativeScript/ffi/jni/jsi/callbackhandlers/CallbackHandlers.h
Original file line number Diff line number Diff line change
Expand Up @@ -68,7 +68,7 @@ namespace tns {

static JsValue
CallJSMethod(JsRuntime &rt, JNIEnv *jEnv, const JsValue &jsObject, jclass claz,
const std::string &methodName, int javaObjectId, jobjectArray args);
const JSMethodCache::MethodName &methodName, int javaObjectId, const JavaCallArgs &args);

static JsValue
GetJavaField(JsRuntime &rt, const JsValue &caller,
Expand Down Expand Up @@ -251,7 +251,9 @@ namespace tns {

static jfieldID CURRENT_OBJECTID_FIELD_ID;

static jmethodID MAKE_INSTANCE_STRONG_ID;
static jfieldID CURRENT_OBJECTCLASS_FIELD_ID;

static jmethodID REGISTER_CONSTRUCTED_INSTANCE_ID;

static jmethodID GET_TYPE_METADATA;

Expand All @@ -265,21 +267,7 @@ namespace tns {

static FieldAccessor fieldAccessor;

struct JavaObjectIdScope {
JavaObjectIdScope(JEnv &_jEnv, jfieldID fieldId, jobject runtime, int javaObjectId)
: jEnv(_jEnv), _fieldID(fieldId), _runtime(runtime) {
jEnv.SetIntField(_runtime, _fieldID, javaObjectId);
}

~JavaObjectIdScope() {
jEnv.SetIntField(_runtime, _fieldID, -1);
}

private:
JEnv jEnv;
jfieldID _fieldID;
jobject _runtime;
};
class ConstructionScope;

static std::atomic_int64_t count_;

Expand Down
69 changes: 39 additions & 30 deletions NativeScript/ffi/jni/jsi/conversion/ArgConverter.cpp
Original file line number Diff line number Diff line change
@@ -1,4 +1,6 @@
#include "ArgConverter.h"
#include <cstring>
#include <vector>
#include "ObjectManager.h"
#include "Util.h"
#include "NativeScriptException.h"
Expand Down Expand Up @@ -137,58 +139,66 @@ JsValue ArgConverter::NativeScriptLongFunctionCallback(JsRuntime &rt, const JsVa
}
}

void ArgConverter::ConvertJavaArgsToJsArgs(JsRuntime &rt, jobjectArray args, size_t argc,
void ArgConverter::ConvertJavaArgsToJsArgs(JsRuntime &rt, const JavaCallArgs &args, size_t argc,
JsValue *arr) {
JEnv jenv;

auto runtime = Runtime::GetRuntime(rt);
auto objectManager = runtime->GetObjectManager();
constexpr size_t kInlineArgs = 16;
jlong inlineValues[JavaCallArgs::PackedLength(kInlineArgs)];
std::vector<jlong> heapValues;
jlong *values = inlineValues;
if (argc > kInlineArgs) {
heapValues.resize(JavaCallArgs::PackedLength(argc));
values = heapValues.data();
}

int jArrayIndex = 0;
for (int i = 0; i < argc; i++) {
JniLocalRef argTypeIDObj(jenv.GetObjectArrayElement(args, jArrayIndex++));
JniLocalRef arg(jenv.GetObjectArrayElement(args, jArrayIndex++));
JniLocalRef argJavaClassPath(jenv.GetObjectArrayElement(args, jArrayIndex++));
JNIEnv *jni = jenv;
jni->GetLongArrayRegion(args.values, 0, JavaCallArgs::PackedLength(argc), values);

Type argTypeID = (Type) JType::IntValue(jenv, argTypeIDObj);
auto runtime = Runtime::GetRuntime(rt);
auto objectManager = runtime->GetObjectManager();

for (size_t i = 0; i < argc; i++) {
jlong bits = values[i];
JsValue jsArg;
switch (argTypeID) {
switch (JavaCallArgs::TypeAt(values, argc, i)) {
case Type::Boolean:
jsArg = JsValue(JType::BooleanValue(jenv, arg) == JNI_TRUE);
jsArg = JsValue(bits != 0);
break;
case Type::Char:
jsArg = jcharToJsString(rt, JType::CharValue(jenv, arg));
jsArg = jcharToJsString(rt, static_cast<jchar>(bits));
break;
case Type::Byte:
jsArg = JsValue((double) JType::ByteValue(jenv, arg));
break;
case Type::Short:
jsArg = JsValue((double) JType::ShortValue(jenv, arg));
break;
case Type::Int:
jsArg = JsValue((double) JType::IntValue(jenv, arg));
break;
case Type::Long:
jsArg = JsValue((double) JType::LongValue(jenv, arg));
jsArg = JsValue(static_cast<double>(bits));
break;
case Type::Float:
jsArg = JsValue((double) JType::FloatValue(jenv, arg));
case Type::Float: {
auto raw = static_cast<int32_t>(bits);
float value;
memcpy(&value, &raw, sizeof(value));
jsArg = JsValue(static_cast<double>(value));
break;
case Type::Double:
jsArg = JsValue((double) JType::DoubleValue(jenv, arg));
}
case Type::Double: {
double value;
memcpy(&value, &bits, sizeof(value));
jsArg = JsValue(value);
break;
case Type::String:
jsArg = jstringToJsString(rt, (jstring) arg);
}
case Type::String: {
JniLocalRef str(jni->GetObjectArrayElement(args.refs, i));
jsArg = jstringToJsString(rt, (jstring) str);
break;
}
case Type::JsObject: {
jint javaObjectID = JType::IntValue(jenv, arg);
auto javaObjectID = ObjectManager::IdOf(bits);
jsArg = objectManager->GetJsObjectByJavaObject(javaObjectID);

if (js_util::is_null_or_undefined(jsArg)) {
string argClassName = jstringToString(ObjectToString(argJavaClassPath));
argClassName = Util::ConvertFromCanonicalToJniName(argClassName);
jsArg = objectManager->CreateJSWrapper(javaObjectID, argClassName);
JniLocalRef arg(jni->GetObjectArrayElement(args.refs, i));
jsArg = objectManager->CreateJSWrapper(javaObjectID, ObjectManager::ClassIndexOf(bits), arg);
}
break;
}
Expand All @@ -199,7 +209,6 @@ void ArgConverter::ConvertJavaArgsToJsArgs(JsRuntime &rt, jobjectArray args, siz

arr[i] = jsArg;
}

}

JsValue ArgConverter::ConvertFromJavaLong(JsRuntime &rt, jlong value) {
Expand Down
Loading
Loading