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

runtime/vm/isolate.h

 // Copyright (c) 2013, 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_ISOLATE_H_
 #define VM_ISOLATE_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/thread.h"
 #include "vm/base_isolate.h"
 #include "vm/class_table.h"
 #include "vm/gc_callbacks.h"
+#include "vm/handles.h"
 #include "vm/megamorphic_cache_table.h"
 #include "vm/store_buffer.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 // Forward declarations.
+class AbstractType;
 class ApiState;
+class Array;
+class Class;
 class CodeIndexTable;
 class Debugger;
+class Field;
 class Function;
 class HandleScope;
 class HandleVisitor;
 class Heap;
 class ICData;
 class Instance;
 class LongJump;
 class MessageHandler;
 class Mutex;
+class Object;
 class ObjectPointerVisitor;
 class ObjectStore;
 class RawInstance;
 class RawArray;
 class RawContext;
 class RawDouble;
 class RawMint;
 class RawObject;
 class RawInteger;
 class RawError;
+class RawFloat32x4;
+class RawUint32x4;
 class Simulator;
 class StackResource;
 class StackZone;
 class StubCode;
-class RawFloat32x4;
-class RawUint32x4;
+class TypeArguments;
+class TypeParameter;
 class ObjectHistogram;
 
 
 // Used by the deoptimization infrastructure to defer allocation of unboxed
 // objects until frame is fully rewritten and GC is safe.
 // Describes a stack slot that should be populated with a reference to the
 // materialized object.
 class DeferredSlot {
  public:
   DeferredSlot(RawInstance** slot, DeferredSlot* next)
@@ skipping 152 matching lines @@
   // Field, value pairs.
   RawObject** args_;
 
   // Object materialized from this description.
   const Instance* object_;
 
   DISALLOW_COPY_AND_ASSIGN(DeferredObject);
 };
 
 
+#define REUSABLE_HANDLE_LIST(V)                                                \
+  V(Object)                                                                    \
+  V(Array)                                                                     \
+  V(String)                                                                    \
+  V(Instance)                                                                  \
+  V(Function)                                                                  \
+  V(Field)                                                                     \
+  V(Class)                                                                     \
+  V(AbstractType)                                                              \
+  V(TypeParameter)                                                             \
+  V(TypeArguments)                                                             \
+
+
 class Isolate : public BaseIsolate {
  public:
   ~Isolate();
 
   static inline Isolate* Current() {
     return reinterpret_cast<Isolate*>(Thread::GetThreadLocal(isolate_key));
   }
 
   static void SetCurrent(Isolate* isolate);
 
@@ skipping 343 matching lines @@
   }
 
   // Populate all deferred slots that contain boxes for double, mint, simd
   // values.
   void MaterializeDeferredBoxes();
 
   // Populate all slots containing references to objects which allocations
   // were eliminated by AllocationSinking pass.
   void MaterializeDeferredObjects();
 
+#define REUSABLE_HANDLE_ACCESSORS(object)                                      \
+  object& object##Handle() {                                                   \
+    ASSERT(object##_handle_ != NULL);                                          \
+    return *object##_handle_;                                                  \
+  }                                                                            \
+
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_ACCESSORS)
+#undef REUSABLE_HANDLE_ACCESSORS
+
   static char* GetStatus(const char* request);
 
  private:
   Isolate();
 
   void BuildName(const char* name_prefix);
   void PrintInvokedFunctions();
 
   static bool FetchStacktrace();
   static bool FetchStackFrameDetails();
   char* GetStatusDetails();
   char* GetStatusStacktrace();
   char* GetStatusStackFrame(intptr_t index);
   char* DoStacktraceInterrupt(Dart_IsolateInterruptCallback cb);
+  template<class T> T* AllocateReusableHandle();
 
   static ThreadLocalKey isolate_key;
   StoreBuffer store_buffer_;
   ClassTable class_table_;
   MegamorphicCacheTable megamorphic_cache_table_;
   Dart_MessageNotifyCallback message_notify_callback_;
   char* name_;
   int64_t start_time_;
   Dart_Port main_port_;
   Heap* heap_;
@@ skipping 28 matching lines @@
   DeferredSlot* deferred_object_refs_;
 
   intptr_t deferred_objects_count_;
   DeferredObject** deferred_objects_;
 
   // Status support.
   char* stacktrace_;
   intptr_t stack_frame_index_;
   ObjectHistogram* object_histogram_;
 
+  // Reusable handles support.
+#define REUSABLE_HANDLE_FIELDS(object)                                         \
+  object* object##_handle_;                                                    \
+
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_FIELDS)
+#undef REUSABLE_HANDLE_FIELDS
+  VMHandles handles_;
+
   static Dart_IsolateCreateCallback create_callback_;
   static Dart_IsolateInterruptCallback interrupt_callback_;
   static Dart_IsolateUnhandledExceptionCallback unhandled_exception_callback_;
   static Dart_IsolateShutdownCallback shutdown_callback_;
   static Dart_FileOpenCallback file_open_callback_;
   static Dart_FileReadCallback file_read_callback_;
   static Dart_FileWriteCallback file_write_callback_;
   static Dart_FileCloseCallback file_close_callback_;
   static Dart_IsolateInterruptCallback vmstats_callback_;
 
@@ skipping 108 matching lines @@
 
  private:
   Isolate::IsolateRunState saved_state_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateRunStateManager);
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_