Cache number of type arguments in class object instead of recalculating it.

runtime/vm/object.cc

 // Copyright (c) 2012, 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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 463 matching lines @@
 
     Class fake;
     // Initialization from Class::New<Class>.
     // Directly set raw_ to break a circular dependency: SetRaw will attempt
     // to lookup class class in the class table where it is not registered yet.
     cls.raw_ = class_class_;
     cls.set_handle_vtable(fake.vtable());
     cls.set_instance_size(Class::InstanceSize());
     cls.set_next_field_offset(Class::InstanceSize());
     cls.set_id(Class::kClassId);
-    cls.raw_ptr()->state_bits_ = 0;
+    cls.set_state_bits(0);
     cls.set_is_finalized();
     cls.set_is_type_finalized();
-    cls.raw_ptr()->type_arguments_field_offset_in_words_ =
-        Class::kNoTypeArguments;
-    cls.raw_ptr()->num_native_fields_ = 0;
+    cls.set_type_arguments_field_offset_in_words(Class::kNoTypeArguments);
+    cls.set_num_type_arguments(0);
+    cls.set_num_own_type_arguments(0);
+    cls.set_num_native_fields(0);
     cls.InitEmptyFields();
     isolate->RegisterClass(cls);
   }
 
   // Allocate and initialize the null class.
   cls = Class::New<Instance>(kNullCid);
   isolate->object_store()->set_null_class(cls);
 
   // Allocate and initialize the free list element class.
   cls = Class::New<FreeListElement::FakeInstance>(kFreeListElement);
@@ skipping 130 matching lines @@
     Array::initializeHandle(
         empty_array_,
         reinterpret_cast<RawArray*>(address + kHeapObjectTag));
     empty_array_->raw()->ptr()->length_ = Smi::New(0);
   }
 
   cls = Class::New<Instance>(kDynamicCid);
   cls.set_is_finalized();
   cls.set_is_type_finalized();
   cls.set_is_abstract();
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   dynamic_class_ = cls.raw();
 
   cls = Class::New<Instance>(kVoidCid);
   cls.set_is_finalized();
   cls.set_is_type_finalized();
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   void_class_ = cls.raw();
 
   cls = Class::New<Type>();
   cls.set_is_finalized();
   cls.set_is_type_finalized();
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   isolate->object_store()->set_type_class(cls);
 
   cls = dynamic_class_;
   dynamic_type_ = Type::NewNonParameterizedType(cls);
 
   cls = void_class_;
   void_type_ = Type::NewNonParameterizedType(cls);
 
   // Allocate and initialize singleton true and false boolean objects.
   cls = Class::New<Bool>();
+  cls.set_num_type_arguments(0);
+  cls.set_num_own_type_arguments(0);
   isolate->object_store()->set_bool_class(cls);
   *bool_true_ = Bool::New(true);
   *bool_false_ = Bool::New(false);
 
   *smi_illegal_cid_ = Smi::New(kIllegalCid);
 
   String& error_str = String::Handle();
   error_str = String::New("SnapshotWriter Error");
   *snapshot_writer_error_ = LanguageError::New(error_str);
   error_str = String::New("Branch offset overflow");
@@ skipping 938 matching lines @@
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeObject fake;
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeObject::InstanceSize());
   result.set_next_field_offset(FakeObject::InstanceSize());
   ASSERT((FakeObject::kClassId != kInstanceCid));
   result.set_id(FakeObject::kClassId);
-  result.raw_ptr()->state_bits_ = 0;
+  result.set_state_bits(0);
   // VM backed classes are almost ready: run checks and resolve class
   // references, but do not recompute size.
   result.set_is_prefinalized();
-  result.raw_ptr()->type_arguments_field_offset_in_words_ = kNoTypeArguments;
-  result.raw_ptr()->num_native_fields_ = 0;
-  result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
+  result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
+  result.set_num_type_arguments(kUnknownNumTypeArguments);
+  result.set_num_own_type_arguments(kUnknownNumTypeArguments);
+  result.set_num_native_fields(0);
+  result.set_token_pos(Scanner::kDummyTokenIndex);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
 }
 
 
+static RawError* FormatError(const Error& prev_error,
+                             const Script& script,
+                             intptr_t token_pos,
+                             const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  if (prev_error.IsNull()) {
+    return Parser::FormatError(script, token_pos, "Error", format, args);
+  } else {
+    return Parser::FormatErrorWithAppend(prev_error, script, token_pos,
+                                         "Error", format, args);
+  }
+}
+
+
+static void ReportTooManyTypeArguments(const Class& cls) {
+  const Error& error = Error::Handle(
+      FormatError(Error::Handle(),  // No previous error.
+                  Script::Handle(cls.script()), cls.token_pos(),
+                  "too many type parameters declared in class '%s' or in its "
+                  "super classes",
+                  String::Handle(cls.Name()).ToCString()));
+  Isolate::Current()->long_jump_base()->Jump(1, error);
+  UNREACHABLE();
+}
+
+
+void Class::set_num_type_arguments(intptr_t value) const {
+  if (!Utils::IsInt(16, value)) {
+    ReportTooManyTypeArguments(*this);
+  }
+  raw_ptr()->num_type_arguments_ = value;
+}
+
+
+void Class::set_num_own_type_arguments(intptr_t value) const {
+  if (!Utils::IsInt(16, value)) {
+    ReportTooManyTypeArguments(*this);
+  }
+  raw_ptr()->num_own_type_arguments_ = value;
+}
+
+
 // Initialize class fields of type Array with empty array.
 void Class::InitEmptyFields() {
   if (Object::empty_array().raw() == Array::null()) {
     // The empty array has not been initialized yet.
     return;
   }
   StorePointer(&raw_ptr()->interfaces_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->constants_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->canonical_types_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->functions_, Object::empty_array().raw());
@@ skipping 107 matching lines @@
   }
   if (type_parameters() == TypeArguments::null()) {
     return 0;
   }
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   return type_params.Length();
 }
 
 
 intptr_t Class::NumOwnTypeArguments() const {
+  // Return cached value if already calculated.
+  if (num_own_type_arguments() != kUnknownNumTypeArguments) {
+    return num_own_type_arguments();
+  }
   Isolate* isolate = Isolate::Current();
   const intptr_t num_type_params = NumTypeParameters();
   if (!FLAG_overlap_type_arguments ||
       (num_type_params == 0) ||
       (super_type() == AbstractType::null()) ||
       (super_type() == isolate->object_store()->object_type())) {
+    set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   ASSERT(!IsMixinApplication() || is_mixin_type_applied());
   const AbstractType& sup_type = AbstractType::Handle(isolate, super_type());
   ASSERT(sup_type.IsResolved());
   const AbstractTypeArguments& sup_type_args =
       AbstractTypeArguments::Handle(isolate, sup_type.arguments());
   if (sup_type_args.IsNull()) {
     // The super type is raw or the super class is non generic.
     // In either case, overlapping is not possible.
+    set_num_own_type_arguments(num_type_params);
     return num_type_params;
   }
   const intptr_t num_sup_type_args = sup_type_args.Length();
   // At this point, the super type may or may not be finalized. In either case,
   // the result of this function must remain the same.
   // The value of num_sup_type_args may increase when the super type is
   // finalized, but the last num_sup_type_args type arguments will not be
   // modified by finalization, only shifted to higher indices in the vector.
   // They may however get wrapped in a BoundedType, which we skip.
   const AbstractTypeArguments& type_params =
@@ skipping 19 matching lines @@
           num_sup_type_args - num_overlapping_type_args + i);
       // BoundedType can nest in case the finalized super type has bounded type
       // arguments that overlap multiple times in its own super class chain.
       while (sup_type_arg.IsBoundedType()) {
         sup_type_arg = BoundedType::Cast(sup_type_arg).type();
       }
       if (!type_param.Equals(sup_type_arg)) break;
     }
     if (i == num_overlapping_type_args) {
       // Overlap found.
+      set_num_own_type_arguments(num_type_params - num_overlapping_type_args);
       return num_type_params - num_overlapping_type_args;
     }
   }
   // No overlap found.
+  set_num_own_type_arguments(num_type_params);
   return num_type_params;
 }
 
 
 intptr_t Class::NumTypeArguments() const {
+  // Return cached value if already calculated.
+  if (num_type_arguments() != kUnknownNumTypeArguments) {
+    return num_type_arguments();
+  }
   // To work properly, this call requires the super class of this class to be
   // resolved, which is checked by the type_class() call on the super type.
   // Note that calling type_class() on a MixinAppType fails.
   Isolate* isolate = Isolate::Current();
   Class& cls = Class::Handle(isolate);
   AbstractType& sup_type = AbstractType::Handle(isolate);
   cls = raw();
   intptr_t num_type_args = 0;
   do {
     if (cls.IsSignatureClass()) {
       Function& signature_fun = Function::Handle(isolate);
       signature_fun ^= cls.signature_function();
       if (!signature_fun.is_static() &&
           !signature_fun.HasInstantiatedSignature()) {
         cls = signature_fun.Owner();
       }
     }
     // Calling NumOwnTypeArguments() on a mixin application class will setup the
     // type parameters if not already done.
     num_type_args += cls.NumOwnTypeArguments();
     // Super type of Object class is null.
     if ((cls.super_type() == AbstractType::null()) ||
         (cls.super_type() == isolate->object_store()->object_type())) {
       break;
     }
     sup_type = cls.super_type();
     cls = sup_type.type_class();
   } while (true);
+  set_num_type_arguments(num_type_args);
   return num_type_args;
 }
 
 
 // More efficient than calling NumTypeArguments().
 bool Class::HasTypeArguments() const {

[siva, 2013/10/15 00:06:57]

Is this HasTypeArguments optimization necessary anymore. Since we will be paying
the cost of NumTypeArguments only once it maybe equally efficient to check 'if
(NumTypeArguments() > 0)' where ever we are doing 'if HasTypeArguments()'

[regis, 2013/10/15 17:49:15]

You are right. This is now overkill. I have removed this function and updated
(lots) of sources.

+  // Check cached number of type arguments if already calculated.
+  if (num_type_arguments() != kUnknownNumTypeArguments) {
+    return num_type_arguments() > 0;
+  }
   // Fast check for a non-signature finalized class.
   if (!IsSignatureClass() && (is_finalized() || is_prefinalized())) {
     return type_arguments_field_offset() != kNoTypeArguments;
   }
   Isolate* isolate = Isolate::Current();
   Class& cls = Class::Handle(isolate);
   cls = raw();
   do {
     if (cls.IsSignatureClass()) {
       Function& signature_fun = Function::Handle(isolate);
@@ skipping 220 matching lines @@
   // Prefinalized classes have a VM internal representation and no Dart fields.
   // Their instance size  is precomputed and field offsets are known.
   if (!is_prefinalized()) {
     // Compute offsets of instance fields and instance size.
     CalculateFieldOffsets();
   }
   set_is_finalized();
 }
 
 
-static RawError* FormatError(const Error& prev_error,
-                             const Script& script,
-                             intptr_t token_pos,
-                             const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  if (prev_error.IsNull()) {
-    return Parser::FormatError(script, token_pos, "Error", format, args);
-  } else {
-    return Parser::FormatErrorWithAppend(prev_error, script, token_pos,
-                                         "Error", format, args);
-  }
-}
-
-
 // Apply the members from the patch class to the original class.
 bool Class::ApplyPatch(const Class& patch, Error* error) const {
   ASSERT(error != NULL);
   ASSERT(!is_finalized());
   // Shared handles used during the iteration.
   String& member_name = String::Handle();
 
   const PatchClass& patch_class =
       PatchClass::Handle(PatchClass::New(*this, patch));
 
@@ skipping 185 matching lines @@
                                       Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
   }
   FakeInstance fake;
   ASSERT(fake.IsInstance());
   result.set_handle_vtable(fake.vtable());
   result.set_instance_size(FakeInstance::InstanceSize());
   result.set_next_field_offset(FakeInstance::InstanceSize());
   result.set_id(index);
-  result.raw_ptr()->state_bits_ = 0;
-  result.raw_ptr()->type_arguments_field_offset_in_words_ = kNoTypeArguments;
-  result.raw_ptr()->num_native_fields_ = 0;
-  result.raw_ptr()->token_pos_ = Scanner::kDummyTokenIndex;
+  result.set_state_bits(0);
+  result.set_type_arguments_field_offset_in_words(kNoTypeArguments);
+  result.set_num_type_arguments(kUnknownNumTypeArguments);
+  result.set_num_own_type_arguments(kUnknownNumTypeArguments);
+  result.set_num_native_fields(0);
+  result.set_token_pos(Scanner::kDummyTokenIndex);
   result.InitEmptyFields();
   Isolate::Current()->RegisterClass(result);
   return result.raw();
 }
 
 
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
   Class& result = Class::Handle(New<Instance>(kIllegalCid));
@@ skipping 13153 matching lines @@
   return "_MirrorReference";
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   JSONObject jsobj(stream);
 }
 
 
 }  // namespace dart