- Create isolate specific resuable handles and use them in the hot lookup paths.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 151 matching lines @@
   object() : super() {}                                                        \
   BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
 
 #define HEAP_OBJECT_IMPLEMENTATION(object, super)                              \
   OBJECT_IMPLEMENTATION(object, super);                                        \
   Raw##object* raw_ptr() const {                                               \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
+  friend class Isolate;                                                        \
   friend class StackFrame;                                                     \
 
 // This macro is used to denote types that do not have a sub-type.
 #define FINAL_HEAP_OBJECT_IMPLEMENTATION(object, super)                        \
  public:  /* NOLINT */                                                         \
   void operator=(Raw##object* value) {                                         \
     raw_ = value;                                                              \
     CHECK_HANDLE();                                                            \
   }                                                                            \
   void operator^=(RawObject* value) {                                          \
     raw_ = value;                                                              \
     CHECK_HANDLE();                                                            \
   }                                                                            \
  private:  /* NOLINT */                                                        \
   object() : super() {}                                                        \
   BASE_OBJECT_IMPLEMENTATION(object, super)                                    \
   Raw##object* raw_ptr() const {                                               \
     ASSERT(raw() != null());                                                   \
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
+  friend class Isolate;                                                        \
   friend class StackFrame;                                                     \
 
 class Object {
  public:
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
   void operator=(RawObject* value) {
     initializeHandle(this, value);
   }
@@ skipping 381 matching lines @@
   static LanguageError* snapshot_writer_error_;
 
   friend void ClassTable::Register(const Class& cls);
   friend void RawObject::Validate(Isolate* isolate) const;
   friend class Closure;
   friend class SnapshotReader;
   friend class OneByteString;
   friend class TwoByteString;
   friend class ExternalOneByteString;
   friend class ExternalTwoByteString;
+  friend class Isolate;
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
 
 class Class : public Object {
  public:
   intptr_t instance_size() const {
     ASSERT(is_finalized() || is_prefinalized());
@@ skipping 1743 matching lines @@
   void AddMetadata(const Class& cls,
                    const String& name,
                    intptr_t token_pos) const;
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Library, Object);
 
   friend class Bootstrap;
   friend class Class;
   friend class Debugger;
   friend class DictionaryIterator;
-  friend class Isolate;
   friend class Namespace;
   friend class Object;
 };
 
 
 class LibraryPrefix : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   virtual RawString* DictionaryName() const { return name(); }
 
@@ skipping 15 matching lines @@
   static const int kInitialSize = 2;
   static const int kIncrementSize = 2;
 
   void set_name(const String& value) const;
   void set_imports(const Array& value) const;
   void set_num_imports(intptr_t value) const;
   static RawLibraryPrefix* New();
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(LibraryPrefix, Object);
   friend class Class;
-  friend class Isolate;
 };
 
 
 class Namespace : public Object {
  public:
   RawLibrary* library() const { return raw_ptr()->library_; }
   RawArray* show_names() const { return raw_ptr()->show_names_; }
   RawArray* hide_names() const { return raw_ptr()->hide_names_; }
 
   static intptr_t InstanceSize() {
@@ skipping 3401 matching lines @@
 // Breaking cycles and loops.
 RawClass* Object::clazz() const {
   uword raw_value = reinterpret_cast<uword>(raw_);
   if ((raw_value & kSmiTagMask) == kSmiTag) {
     return Smi::Class();
   }
   return Isolate::Current()->class_table()->At(raw()->GetClassId());
 }
 
 
-void Object::SetRaw(RawObject* value) {
+inline void Object::SetRaw(RawObject* value) {

[Ivan Posva, 2013/06/22 01:01:36]

DART_FORCE_INLINE would be a good alternative here.

[siva, 2013/07/18 20:39:23]

Done.

   // NOTE: The assignment "raw_ = value" should be the first statement in
   // this function. Also do not use 'value' in this function after the
   // assignment (use 'raw_' instead).
   raw_ = value;
-  if ((reinterpret_cast<uword>(raw_) & kSmiTagMask) == kSmiTag) {
-    set_vtable(Smi::handle_vtable_);
-    return;
+  cpp_vtable vtable_ptr;
+  if ((reinterpret_cast<uword>(value) & kSmiTagMask) == kSmiTag) {
+    vtable_ptr = Smi::handle_vtable_;

[Ivan Posva, 2013/06/22 01:01:36]

--verify_handles will fail below when being passed a Smi handle.

[siva, 2013/07/18 20:39:23]

Reverted this change as DART_FORCE_INLINE should make sure this is inlined.

On 2013/06/22 01:01:36, Ivan Posva wrote:

+  } else {
+    intptr_t cid = value->GetClassId();
+    if (cid >= kNumPredefinedCids) {
+      cid = kInstanceCid;
+    }
+    vtable_ptr = builtin_vtables_[cid];
   }
-  intptr_t cid = raw_->GetClassId();
-  if (cid >= kNumPredefinedCids) {
-      cid = kInstanceCid;
-  }
-  set_vtable(builtin_vtables_[cid]);
+  set_vtable(vtable_ptr);
 #if defined(DEBUG)
   if (FLAG_verify_handles) {
     Isolate* isolate = Isolate::Current();
     Heap* isolate_heap = isolate->heap();
     Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
     ASSERT(isolate_heap->Contains(RawObject::ToAddr(raw_)) ||
            vm_isolate_heap->Contains(RawObject::ToAddr(raw_)));
   }
 #endif
 }
@@ skipping 82 matching lines @@
 
 
 RawObject* MegamorphicCache::GetTargetFunction(const Array& array,
                                                intptr_t index) {
   return array.At((index * kEntryLength) + kTargetFunctionIndex);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_