VM [KERNEL] Fix performance issue in KernelReader

runtime/vm/kernel_reader.cc

Index: runtime/vm/kernel_reader.cc
diff --git a/runtime/vm/kernel_reader.cc b/runtime/vm/kernel_reader.cc
index 05fecbfb0f7b82299bcdfcbf19f874f4ab9ae5d0..09f1c71e47aacf5d6603152ea317c83c5296bbe4 100644
--- a/runtime/vm/kernel_reader.cc
+++ b/runtime/vm/kernel_reader.cc
@@ -83,6 +83,17 @@ class SimpleExpressionConverter : public ExpressionVisitor {
 };
 
 
+RawArray* KernelReader::MakeFunctionsArray(
+    GrowableArray<const dart::Function*>* functions) {
+  const intptr_t len = functions->length();
+  const Array& res = Array::Handle(zone_, Array::New(len, Heap::kOld));
+  for (intptr_t i = 0; i < len; i++) {
+    res.SetAt(i, *functions->At(i));
+  }
+  return res.raw();
+}
+
+
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
     CanonicalName* library) {
   return reader_->LookupLibrary(library).raw();
@@ -169,9 +180,12 @@ void KernelReader::ReadLibrary(Library* kernel_library) {
   toplevel_class.set_is_cycle_free();
   library.set_toplevel_class(toplevel_class);
 
+  GrowableArray<const dart::Function*> functions;

[Vyacheslav Egorov (Google), 2017/03/27 17:31:55]

Maybe make 

functions_ and fields_ members of the Kernel reader?

that would decrease Zone memory usage because then you can reuse these arrays
and also that would remove the need to explicitly pass them around.

[Dmitry Olshansky, 2017/03/27 18:08:47]

Done.

+  intptr_t num_fields = kernel_library->fields().length();
+  GrowableArray<const dart::Field*> fields(num_fields);
   ActiveClassScope active_class_scope(&active_class_, NULL, &toplevel_class);
   // Load toplevel fields.
-  for (intptr_t i = 0; i < kernel_library->fields().length(); i++) {
+  for (intptr_t i = 0; i < num_fields; i++) {
     Field* kernel_field = kernel_library->fields()[i];
 
     ActiveMemberScope active_member_scope(&active_class_, kernel_field);
@@ -186,17 +200,20 @@ void KernelReader::ReadLibrary(Library* kernel_library) {
     const AbstractType& type = T.TranslateType(kernel_field->type());
     field.SetFieldType(type);
     field.set_has_initializer(kernel_field->initializer() != NULL);
-    GenerateFieldAccessors(toplevel_class, field, kernel_field);
-    toplevel_class.AddField(field);
+    GenerateFieldAccessors(toplevel_class, field, kernel_field, &functions);
+    fields.Add(&field);
     library.AddObject(field, name);
   }
+  toplevel_class.AddFields(fields);
 
   // Load toplevel procedures.
   for (intptr_t i = 0; i < kernel_library->procedures().length(); i++) {
     Procedure* kernel_procedure = kernel_library->procedures()[i];
-    ReadProcedure(library, toplevel_class, kernel_procedure);
+    ReadProcedure(library, toplevel_class, kernel_procedure, NULL, &functions);
   }
 
+  toplevel_class.SetFunctions(Array::Handle(MakeFunctionsArray(&functions)));
+
   const GrowableObjectArray& classes =
       GrowableObjectArray::Handle(I->object_store()->pending_classes());
 
@@ -302,6 +319,7 @@ dart::Class& KernelReader::ReadClass(const dart::Library& library,
   }
 
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &klass);
+  GrowableArray<const dart::Function*> functions;
 
   if (library.raw() == dart::Library::InternalLibrary() &&
       klass.Name() == Symbols::ClassID().raw()) {
@@ -310,7 +328,9 @@ dart::Class& KernelReader::ReadClass(const dart::Library& library,
     // fields.
     klass.InjectCIDFields();
   } else {
-    for (intptr_t i = 0; i < kernel_klass->fields().length(); i++) {
+    intptr_t num_fields = kernel_klass->fields().length();
+    GrowableArray<const dart::Field*> fields(num_fields);
+    for (intptr_t i = 0; i < num_fields; i++) {
       Field* kernel_field = kernel_klass->fields()[i];
       ActiveMemberScope active_member_scope(&active_class_, kernel_field);
 
@@ -331,9 +351,10 @@ dart::Class& KernelReader::ReadClass(const dart::Library& library,
                            script_class, type, kernel_field->position()));
       field.set_kernel_field(kernel_field);
       field.set_has_initializer(kernel_field->initializer() != NULL);
-      GenerateFieldAccessors(klass, field, kernel_field);
-      klass.AddField(field);
+      GenerateFieldAccessors(klass, field, kernel_field, &functions);
+      fields.Add(&field);
     }
+    klass.AddFields(fields);
   }
 
   for (intptr_t i = 0; i < kernel_klass->constructors().length(); i++) {
@@ -352,7 +373,7 @@ dart::Class& KernelReader::ReadClass(const dart::Library& library,
                                false,  // is_native
                                klass, kernel_constructor->position()));
     function.set_end_token_pos(kernel_constructor->end_position());
-    klass.AddFunction(function);
+    functions.Add(&function);
     function.set_kernel_function(kernel_constructor);
     function.set_result_type(T.ReceiverType(klass));
     SetupFunctionParameters(H, T, klass, function,
@@ -369,9 +390,11 @@ dart::Class& KernelReader::ReadClass(const dart::Library& library,
   for (intptr_t i = 0; i < kernel_klass->procedures().length(); i++) {
     Procedure* kernel_procedure = kernel_klass->procedures()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_procedure);
-    ReadProcedure(library, klass, kernel_procedure, kernel_klass);
+    ReadProcedure(library, klass, kernel_procedure, kernel_klass, &functions);
   }
 
+  klass.SetFunctions(Array::Handle(MakeFunctionsArray(&functions)));
+
   if (!klass.is_marked_for_parsing()) {
     klass.set_is_marked_for_parsing();
   }
@@ -385,10 +408,12 @@ dart::Class& KernelReader::ReadClass(const dart::Library& library,
 }
 
 
-void KernelReader::ReadProcedure(const dart::Library& library,
-                                 const dart::Class& owner,
-                                 Procedure* kernel_procedure,
-                                 Class* kernel_klass) {
+void KernelReader::ReadProcedure(
+    const dart::Library& library,
+    const dart::Class& owner,
+    Procedure* kernel_procedure,
+    Class* kernel_klass,
+    GrowableArray<const dart::Function*>* functions) {
   ActiveClassScope active_class_scope(&active_class_, kernel_klass, &owner);
   ActiveMemberScope active_member_scope(&active_class_, kernel_procedure);
   ActiveFunctionScope active_function_scope(&active_class_,
@@ -440,7 +465,7 @@ void KernelReader::ReadProcedure(const dart::Library& library,
                        native_name != NULL,  // is_native
                        script_class, kernel_procedure->position()));
   function.set_end_token_pos(kernel_procedure->end_position());
-  owner.AddFunction(function);
+  functions->Add(&function);
   function.set_kernel_function(kernel_procedure);
 
   function.set_is_debuggable(
@@ -574,9 +599,11 @@ Script& KernelReader::ScriptAt(intptr_t source_uri_index, String* import_uri) {
   return script;
 }
 
-void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
-                                          const dart::Field& field,
-                                          Field* kernel_field) {
+void KernelReader::GenerateFieldAccessors(
+    const dart::Class& klass,
+    const dart::Field& field,
+    Field* kernel_field,
+    GrowableArray<const dart::Function*>* functions) {
   if (kernel_field->IsStatic() && kernel_field->initializer() == NULL) {
     // Static fields without an initializer are implicitly initialized to null.
     // We do not need a getter.
@@ -629,7 +656,7 @@ void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
           false,  // is_external
           false,  // is_native
           script_class, kernel_field->position()));
-  klass.AddFunction(getter);
+  functions->Add(&getter);
   getter.set_end_token_pos(kernel_field->end_position());
   getter.set_kernel_function(kernel_field);
   getter.set_result_type(AbstractType::Handle(Z, field.type()));
@@ -648,7 +675,7 @@ void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
                          false,  // is_external
                          false,  // is_native
                          script_class, kernel_field->position()));
-    klass.AddFunction(setter);
+    functions->Add(&setter);
     setter.set_end_token_pos(kernel_field->end_position());
     setter.set_kernel_function(kernel_field);
     setter.set_result_type(Object::void_type());