VM [KERNEL] Fix performance issue in KernelReader

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/longjump.h"
@@ skipping 65 matching lines @@
   dart::Zone* zone() const { return zone_; }
 
  private:
   TranslationHelper translation_helper_;
   dart::Zone* zone_;
   bool is_simple_;
   dart::Instance* simple_value_;
 };
 
 
+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();
 }
 
 
 RawClass* BuildingTranslationHelper::LookupClassByKernelClass(
     CanonicalName* klass) {
   return reader_->LookupClass(klass).raw();
 }
@@ skipping 66 matching lines @@
   // Setup toplevel class (which contains library fields/procedures).
 
   Script& script = ScriptAt(kernel_library->source_uri_index(),
                             kernel_library->import_uri());
   dart::Class& toplevel_class = dart::Class::Handle(
       Z, dart::Class::New(library, Symbols::TopLevel(), script,
                           TokenPosition::kNoSource));
   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);
     const dart::String& name = H.DartFieldName(kernel_field->name());
     const Object& script_class =
         ClassForScriptAt(toplevel_class, kernel_field->source_uri_index());
     dart::Field& field = dart::Field::Handle(
         Z, dart::Field::NewTopLevel(name, kernel_field->IsFinal(),
                                     kernel_field->IsConst(), script_class,
                                     kernel_field->position()));
     field.set_kernel_field(kernel_field);
     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());
 
   // Load all classes.
   for (intptr_t i = 0; i < kernel_library->classes().length(); i++) {
     Class* kernel_klass = kernel_library->classes()[i];
     classes.Add(ReadClass(library, toplevel_class, kernel_klass), Heap::kOld);
   }
 
   classes.Add(toplevel_class, Heap::kOld);
@@ skipping 85 matching lines @@
     klass.set_script(ScriptAt(kernel_klass->source_uri_index()));
   }
   if (klass.token_pos() == TokenPosition::kNoSource) {
     klass.set_token_pos(kernel_klass->position());
   }
   if (!klass.is_cycle_free()) {
     ReadPreliminaryClass(&klass, kernel_klass);
   }
 
   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()) {
     // If this is a dart:internal.ClassID class ignore field declarations
     // contained in the Kernel file and instead inject our own const
     // 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);
 
       const dart::String& name = H.DartFieldName(kernel_field->name());
       const AbstractType& type =
           T.TranslateTypeWithoutFinalization(kernel_field->type());
       const Object& script_class =
           ClassForScriptAt(klass, kernel_field->source_uri_index());
       dart::Field& field = dart::Field::Handle(
           Z,
           dart::Field::New(name, kernel_field->IsStatic(),
                            // In the VM all const fields are implicitly final
                            // whereas in Kernel they are not final because they
                            // are not explicitly declared that way.
                            kernel_field->IsFinal() || kernel_field->IsConst(),
                            kernel_field->IsConst(),
                            false,  // is_reflectable
                            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++) {
     Constructor* kernel_constructor = kernel_klass->constructors()[i];
     ActiveMemberScope active_member_scope(&active_class_, kernel_constructor);
     ActiveFunctionScope active_function_scope(&active_class_,
                                               kernel_constructor->function());
 
     const dart::String& name = H.DartConstructorName(kernel_constructor);
     Function& function = dart::Function::ZoneHandle(
         Z, dart::Function::New(name, RawFunction::kConstructor,
                                false,  // is_static
                                kernel_constructor->IsConst(),
                                false,  // is_abstract
                                kernel_constructor->IsExternal(),
                                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,
                             kernel_constructor->function(),
                             true,    // is_method
                             false);  // is_closure
 
     if (FLAG_enable_mirrors) {
       library.AddFunctionMetadata(function, TokenPosition::kNoSource,
                                   kernel_constructor);
     }
   }
 
   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();
   }
 
   if (FLAG_enable_mirrors) {
     library.AddClassMetadata(klass, toplevel_class, TokenPosition::kNoSource,
                              kernel_klass);
   }
 
   return klass;
 }
 
 
-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_,
                                             kernel_procedure->function());
 
   const dart::String& name = H.DartProcedureName(kernel_procedure);
   bool is_method = kernel_klass != NULL && !kernel_procedure->IsStatic();
   bool is_abstract = kernel_procedure->IsAbstract();
   bool is_external = kernel_procedure->IsExternal();
   dart::String* native_name = NULL;
@@ skipping 31 matching lines @@
   const Object& script_class =
       ClassForScriptAt(owner, kernel_procedure->source_uri_index());
   dart::Function& function = dart::Function::ZoneHandle(
       Z, Function::New(name, GetFunctionType(kernel_procedure),
                        !is_method,  // is_static
                        false,       // is_const
                        is_abstract, is_external,
                        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(
       kernel_procedure->function()->dart_async_marker() == FunctionNode::kSync);
   switch (kernel_procedure->function()->dart_async_marker()) {
     case FunctionNode::kSyncStar:
       function.set_modifier(RawFunction::kSyncGen);
       break;
     case FunctionNode::kAsync:
       function.set_modifier(RawFunction::kAsync);
@@ skipping 113 matching lines @@
     script.set_debug_positions(array_object);
 
     // Create yield_positions array for the script.
     array_object ^= AsSortedDuplicateFreeArray(
         source_uri_index, &program_->yield_token_positions);
     script.set_yield_positions(array_object);
   }
   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.
     field.SetStaticValue(Instance::Handle(Z), true);
     return;
   }
   if (kernel_field->initializer() != NULL) {
     SimpleExpressionConverter converter(H.thread());
     const bool has_simple_initializer =
         converter.IsSimple(kernel_field->initializer());
@@ skipping 32 matching lines @@
           // The functions created by the parser have is_const for static fields
           // that are const (not just final) and they have is_const for
           // non-static
           // fields that are final.
           kernel_field->IsStatic() ? kernel_field->IsConst()
                                    : kernel_field->IsFinal(),
           false,  // is_abstract
           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()));
   getter.set_is_debuggable(false);
   SetupFieldAccessorFunction(klass, getter);
 
   if (!kernel_field->IsStatic() && !kernel_field->IsFinal()) {
     // Only static fields can be const.
     ASSERT(!kernel_field->IsConst());
     const dart::String& setter_name = H.DartSetterName(kernel_field->name());
     Function& setter = Function::ZoneHandle(
         Z, Function::New(setter_name, RawFunction::kImplicitSetter,
                          false,  // is_static
                          false,  // is_const
                          false,  // is_abstract
                          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());
     setter.set_is_debuggable(false);
     SetupFieldAccessorFunction(klass, setter);
   }
 }
 
 
 void KernelReader::SetupFunctionParameters(TranslationHelper translation_helper,
@@ skipping 177 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)