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() {
+  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_[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);
 
+  fields_.Clear();
+  functions_.Clear();
   ActiveClassScope active_class_scope(&active_class_, NULL, &toplevel_class);
   // Load toplevel fields.
   for (intptr_t i = 0; i < kernel_library->fields().length(); 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);
+    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);

[Vyacheslav Egorov (Google), 2017/03/27 18:19:09]

NULL is a default value. You can remove this change here.

   }
 
+  toplevel_class.SetFunctions(Array::Handle(MakeFunctionsArray()));
+
   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);
+  fields_.Clear();
+  functions_.Clear();
 
   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++) {
       Field* kernel_field = kernel_klass->fields()[i];
@@ skipping 10 matching lines @@
                            // 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);
+      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);
   }
 
+  klass.SetFunctions(Array::Handle(MakeFunctionsArray()));
+
   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;
@@ skipping 48 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 168 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)