[kernel] Cache patch-classes.

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/kernel_binary.h"
@@ skipping 108 matching lines @@
   return reader_->LookupClass(klass).raw();
 }
 
 
 KernelReader::KernelReader(Program* program)
     : program_(program),
       thread_(dart::Thread::Current()),
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
+      patch_classes_(Array::ZoneHandle(zone_)),
       translation_helper_(this, thread_),
       builder_(&translation_helper_,
                zone_,
                program_->kernel_data(),
                program_->kernel_data_size()) {
   T.active_class_ = &active_class_;
   T.finalize_ = false;
 
   scripts_ = Array::New(builder_.SourceTableSize(), Heap::kOld);
+  patch_classes_ = Array::New(builder_.SourceTableSize(), Heap::kOld);
 
   // Copy the Kernel string offsets out of the binary and into the VM's heap.
   ASSERT(program->string_table_offset() >= 0);
   Reader reader(program->kernel_data(), program->kernel_data_size());
   reader.set_offset(program->string_table_offset());
   intptr_t count = reader.ReadUInt() + 1;
   TypedData& offsets = TypedData::Handle(
       Z, TypedData::New(kTypedDataUint32ArrayCid, count, Heap::kOld));
   offsets.SetUint32(0, 0);
   intptr_t end_offset = 0;
@@ skipping 525 matching lines @@
                                 procedure_offset);
   }
 
   procedure_helper.ReadUntilExcluding(ProcedureHelper::kEnd);
 }
 
 const Object& KernelReader::ClassForScriptAt(const dart::Class& klass,
                                              intptr_t source_uri_index) {
   Script& correct_script = ScriptAt(source_uri_index);
   if (klass.script() != correct_script.raw()) {
-    // TODO(jensj): We could probably cache this so we don't create
-    // new PatchClasses all the time
-    return PatchClass::ZoneHandle(Z, PatchClass::New(klass, correct_script));
+    // Use cache for patch classes. This works best for in-order usages.
+    PatchClass& patch_class = PatchClass::ZoneHandle(Z);
+    patch_class ^= patch_classes_.At(source_uri_index);
+    if (patch_class.IsNull() || patch_class.origin_class() != klass.raw()) {
+      patch_class = PatchClass::New(klass, correct_script);
+      patch_classes_.SetAt(source_uri_index, patch_class);
+    }
+    return patch_class;
   }
   return klass;
 }
 
 Script& KernelReader::ScriptAt(intptr_t index, StringIndex import_uri) {
   Script& script = Script::ZoneHandle(Z);
   script ^= scripts_.At(index);
   if (script.IsNull()) {
     // Create script with correct uri(s).
     dart::String& uri_string = builder_.SourceTableUriFor(index);
@@ skipping 210 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)