Почему встроенные функции в Dart такие тяжелые по сравнению с «DEFINE NATIVE ENTRY»? функции, которые очень легкие?

Я не могу понять: «Почему это заверение?».

Это оболочка для собственной нативной функции из dart/runtime/vm/native_entry.cc:

Он предназначен для программистов дартс, которые хотят писать native extensions,

void NativeEntry::NativeCallWrapper(Dart_NativeArguments args,
Dart_NativeFunction func) {
CHECK_STACK_ALIGNMENT;
VERIFY_ON_TRANSITION;
NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
Isolate* isolate = arguments->isolate();
ApiState* state = isolate->api_state();
ASSERT(state != NULL);
ApiLocalScope* current_top_scope = state->top_scope();
ApiLocalScope* scope = state->reusable_scope();
TRACE_NATIVE_CALL("0x%" Px "", reinterpret_cast<uintptr_t>(func));
if (scope == NULL) {
scope = new ApiLocalScope(current_top_scope,
isolate->top_exit_frame_info());
ASSERT(scope != NULL);
} else {
scope->Reinit(isolate,
current_top_scope,
isolate->top_exit_frame_info());
state->set_reusable_scope(NULL);
}
state->set_top_scope(scope);  // New scope is now the top scope.

func(args);

ASSERT(current_top_scope == scope->previous());
state->set_top_scope(current_top_scope);  // Reset top scope to previous.
if (state->reusable_scope() == NULL) {
scope->Reset(isolate);  // Reset the old scope which we just exited.
state->set_reusable_scope(scope);
} else {
ASSERT(state->reusable_scope() != scope);
delete scope;
}
DEOPTIMIZE_ALOT;
VERIFY_ON_TRANSITION;
}

Эта оболочка со всеми ненужными проверками, которые она выполняет при каждом вызове встроенной встроенной функции, делает эти функции неконкурентоспособными по сравнению с тем, что используют разработчики для себя.

Это MACRO для определения нативной функции из dart/runtime/vm/native_entry.h:

#define DEFINE_NATIVE_ENTRY(name, argument_count)                              \
static RawObject* DN_Helper##name(Isolate* isolate,                          \
NativeArguments* arguments);               \
void NATIVE_ENTRY_FUNCTION(name)(Dart_NativeArguments args) {                \
CHECK_STACK_ALIGNMENT;                                                     \
VERIFY_ON_TRANSITION;                                                      \
NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);     \
ASSERT(arguments->NativeArgCount() == argument_count);                     \
TRACE_NATIVE_CALL("%s", ""#name);                                          \
{                                                                          \
StackZone zone(arguments->isolate());                                    \
SET_NATIVE_RETVAL(arguments,                                             \
DN_Helper##name(arguments->isolate(), arguments));     \
DEOPTIMIZE_ALOT;                                                         \
}                                                                          \
VERIFY_ON_TRANSITION;                                                      \
}                                                                            \
static RawObject* DN_Helper##name(Isolate* isolate,                          \
NativeArguments* arguments)

Я знаю, что это работает напрямую с RawObject, Это нормально.

Но я не могу найти в нем все эти тесты, которые выполняются при каждом вызове, как в приведенной выше обертке.

Я унываю, когда вижу, что мои функции работают на 3000% медленнее, чем аналоги, определенные с помощью DEFINE_NATIVE_ENTRY,

P.S

мой native function это делает NOTHING и не returns ANYTHING работает на 500% медленнее, чем (например) эта функция.

#define TYPED_DATA_GETTER(getter, object, access_size)                         \
DEFINE_NATIVE_ENTRY(TypedData_##getter, 2) {                                   \
GET_NON_NULL_NATIVE_ARGUMENT(Instance, instance, arguments->NativeArgAt(0)); \
GET_NON_NULL_NATIVE_ARGUMENT(Smi, offsetInBytes, arguments->NativeArgAt(1)); \
if (instance.IsTypedData()) {                                                \
const TypedData& array = TypedData::Cast(instance);                        \
RangeCheck(offsetInBytes.Value(), access_size,                             \
array.LengthInBytes(), access_size);                            \
return object::New(array.getter(offsetInBytes.Value()));                   \
}                                                                            \
if (instance.IsExternalTypedData()) {                                        \
const ExternalTypedData& array = ExternalTypedData::Cast(instance);        \
RangeCheck(offsetInBytes.Value(), access_size,                             \
array.LengthInBytes(), access_size);                            \
return object::New(array.getter(offsetInBytes.Value()));                   \
}                                                                            \
const String& error = String::Handle(String::NewFormatted(                   \
"Expected a TypedData object but found %s", instance.ToCString()));      \
Exceptions::ThrowArgumentError(error);                                       \
return object::null();                                                       \
}                                                                              \

Есть ли способ написать легкие нативные функции, которые не требуют всех этих scope?