Soy nuevo como desarrollador de Node.js cpp-addon, necesito devolver un objeto muy grande de cpp (Node.js cpp-addon) a la lógica de Javascript, pero descubrí que es muy lento generar JsObject en el complemento de C++. que js puro. Aquí está mi código y el resultado de la ejecución:
caso cpp-addon:
var addon = require('bindings')('addon.node') console.time('perf'); console.log('This should be result:', addon.getBigObject('foo bar')); console.timeEnd('perf'); #include <napi.h> Napi::Value GetBigObject(const Napi::CallbackInfo& info) { Napi::Env m_env = info.Env(); Napi::Object node = Napi::Object::New(m_env); node.Set(Napi::String::New(m_env, "foo"), Napi::Number::New(m_env, 1)); node.Set(Napi::String::New(m_env, "body"), Napi::Array::New(m_env)); for (int i = 0; i < 2000000; i++) { Napi::Object stmt = Napi::Object::New(m_env); stmt.Set(Napi::String::New(m_env, "foo"), Napi::Number::New(m_env, 1)); Napi::Array body = node.Get("body").As<Napi::Array>(); auto len = std::to_string(body.Length()); body.Set(Napi::String::New(m_env, len), stmt); } return node; } Napi::Object Init(Napi::Env env, Napi::Object exports) { exports.Set(Napi::String::New(env, "getBigObject"), Napi::Function::New(env, GetBigObject)); return exports; } NODE_API_MODULE(addon, Init)Ejecutar este código cuesta tiempo:
perf: 2.782scaso puro-js:
var addon = require('./addon.js'); console.time('perf'); console.log('This should be result:', addon.getBigObject('var foo = 1;')); console.timeEnd('perf'); module.exports.getBigObject = function() { const node = {}; node.foo = 1; node.body = []; for (let i = 0; i < 2000000; i++) { let body = node.body; body.push({ foo: 1 }); } return node; }Ejecutar este código cuesta tiempo:
perf: 220.973ms¿Por qué es tan lento generar JsObject en cpp-addon? ¿Quizás es relativo a V8 Hidden-Class? ¿Cómo podría generar JsObject en cpp-addon más rápido?
(Desarrollador V8 aquí.)
¿Por qué es tan lento generar JsObject en cpp-addon?
En resumen: porque en JavaScript, te beneficias de las optimizaciones del motor; mientras que en C++, tienes que optimizar las cosas tú mismo.
¿Cómo podría generar JsObject en cpp-addon más rápido?
La respuesta general a "¿cómo puedo hacer algo más rápido?" es: perfilarlo para ver dónde se gasta exactamente el tiempo, y luego ver si puede evitarlo u optimizarlo.
Según su código, puedo hacer algunas conjeturas sobre cosas que vale la pena probar:
for (int i = 0; i < 2000000; i++) {
Ese es un gran recuento de iteraciones; crear tantos identificadores (en el cuerpo del ciclo) en un solo HandleScope probablemente contribuya a la lentitud. Usaría un bucle anidado para crear un nuevo HandleScope en el bucle exterior por cada 1000 o más iteraciones del bucle interior. Ver aquí
Napi::Object stmt = Napi::Object::New(m_env);
stmt.Set(Napi::String::New(m_env, "foo"), Napi::Number::New(m_env, 1));
La API V8 tiene el sistema ObjectTemplate para producir copias nuevas de objetos de apariencia similar lo más rápido posible. Sin embargo, parece que N-API no expone eso; por lo que podría pasar de N-API a usar la API V8 directamente, o simplemente vivir sin ella, con la esperanza de que no suponga una gran diferencia.
Napi::Array body = node.Get("body").As<Napi::Array>();
No es necesario leer la propiedad "body" del node en cada iteración, ya que sabe que devolverá la matriz que asignó anteriormente, así que simplemente guarde eso en una variable local.
auto len = std::to_string(body.Length());
No es necesario leer la longitud en cada iteración, ya que siempre es idéntica a i .
body.Set(Napi::String::New(m_env, len), stmt);
Crear una cadena para un índice de matriz solo para obligar al motor a convertir esa cadena nuevamente en un número es bastante ineficiente. napi_set_element evita el innecesario ir y venir.
Otra cosa que le permite hacer la API V8 (pero no puedo encontrarla en la documentación de N-API) es compilar y ejecutar cualquier código JS que desee. Entonces, si realmente desea el equivalente exacto del fragmento de código JS, puede simplemente llamarlo fragmento de código JS. (Para ahorrar esfuerzo de recompilación, lo compilaría como un paso separado y almacenaría en caché la función resultante si tiene la intención de llamarla repetidamente).