- 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 151 matching lines @@
   // The first argument is Class of the instance to materialize followed by
   // 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 358 matching lines @@
 
   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_;

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

reusable_handles_?

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

Done.

+
   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_;
 
+  friend class ReusableHandleScope;
   DISALLOW_COPY_AND_ASSIGN(Isolate);
 };
 
+// The class ReusableHandleScope is used in regions of the
+// virtual machine where isolate specific reusable handles are used.
+// This class asserts that we do not add code that will result in recursive
+// uses of reusable handles.
+// It is used as follows:
+// {
+//   ReusableHandleScope reused_handles(isolate);
+//   ....
+//   .....
+//   code that uses isolate specific reusable handles.
+//   Array& funcs = reused_handles.ArrayHandle();
+//   ....
+// }
+#if defined(DEBUG)
+class ReusableHandleScope : public StackResource {
+#else
+class ReusableHandleScope : public ValueObject {
+#endif
+
+ public:
+  explicit ReusableHandleScope(Isolate* isolate) : isolate_(isolate) {
+#if defined(DEBUG)
+    ASSERT(!isolate->reusable_handle_scope_active());
+    isolate->set_reusable_handle_scope_active(true);
+#endif  // defined(DEBUG)
+  }
+  ReusableHandleScope() : isolate_(Isolate::Current()) {
+#if defined(DEBUG)
+    ASSERT(!isolate_->reusable_handle_scope_active());
+    isolate_->set_reusable_handle_scope_active(true);
+#endif  // defined(DEBUG)
+  }
+  ~ReusableHandleScope() {
+#if defined(DEBUG)
+    ASSERT(isolate_->reusable_handle_scope_active());
+    isolate_->set_reusable_handle_scope_active(false);
+#endif  // defined(DEBUG)

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

To not keep objects alive longer than needed we should probably set all of the
handles to pointing to null.

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

Done.

+  }
+
+#define REUSABLE_HANDLE_ACCESSORS(object)                                      \
+  object& object##Handle() {                                                   \
+    ASSERT(isolate_->object##_handle_ != NULL);                                \
+    return *isolate_->object##_handle_;                                        \
+  }                                                                            \
+
+  REUSABLE_HANDLE_LIST(REUSABLE_HANDLE_ACCESSORS)
+#undef REUSABLE_HANDLE_ACCESSORS
+
+ private:
+  Isolate* isolate_;
+  DISALLOW_COPY_AND_ASSIGN(ReusableHandleScope);
+};
+
 // When we need to execute code in an isolate, we use the
 // StartIsolateScope.
 class StartIsolateScope {
  public:
   explicit StartIsolateScope(Isolate* new_isolate)
       : new_isolate_(new_isolate), saved_isolate_(Isolate::Current()) {
     ASSERT(new_isolate_ != NULL);
     if (saved_isolate_ != new_isolate_) {
       ASSERT(Isolate::Current() == NULL);
       Isolate::SetCurrent(new_isolate_);
@@ skipping 95 matching lines @@
 
  private:
   Isolate::IsolateRunState saved_state_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateRunStateManager);
 };
 
 }  // namespace dart
 
 #endif  // VM_ISOLATE_H_