Reuse the top ApiLocalScope so that we do not allocate and free an ApiLocalScope

runtime/vm/dart_api_state.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_DART_API_STATE_H_
 #define VM_DART_API_STATE_H_
 
 #include "include/dart_api.h"
 
 #include "platform/thread.h"
@@ skipping 32 matching lines @@
       OS::PrintErr("*** Starting a new Api zone 0x%"Px"(0x%"Px")\n",
                    reinterpret_cast<intptr_t>(this),
                    reinterpret_cast<intptr_t>(&zone_));
     }
 #endif
   }
 
   // Delete all memory associated with the zone.
   ~ApiZone() {
     Isolate* isolate = Isolate::Current();
-    if (isolate != NULL && isolate->current_zone() == &zone_) {
+    if ((isolate != NULL) && (isolate->current_zone() == &zone_)) {
       isolate->set_current_zone(zone_.previous_);
     }
 #ifdef DEBUG
     if (FLAG_trace_zones) {
       OS::PrintErr("*** Deleting Api zone 0x%"Px"(0x%"Px")\n",
                    reinterpret_cast<intptr_t>(this),
                    reinterpret_cast<intptr_t>(&zone_));
     }
 #endif
   }
@@ skipping 21 matching lines @@
   // check for integer overflow.  If you use AllocUnsafe, you are
   // responsible for avoiding integer overflow yourself.
   uword AllocUnsafe(intptr_t size) { return zone_.AllocUnsafe(size); }
 
   // Compute the total size of this zone. This includes wasted space that is
   // due to internal fragmentation in the segments.
   intptr_t SizeInBytes() const { return zone_.SizeInBytes(); }
 
   Zone* GetZone() { return &zone_; }
 
+  void Reinit(Isolate* isolate) {
+    if (isolate == NULL) {
+      zone_.Link(NULL);
+    } else {
+      zone_.Link(isolate->current_zone());
+      isolate->set_current_zone(&zone_);
+    }
+  }
+
+  void Reset(Isolate* isolate) {
+    if ((isolate != NULL) && (isolate->current_zone() == &zone_)) {
+      isolate->set_current_zone(zone_.previous_);
+    }
+    zone_.DeleteAll();
+  }
+
  private:
   Zone zone_;
 
   template<typename T> friend class ApiGrowableArray;
   DISALLOW_COPY_AND_ASSIGN(ApiZone);
 };
 
 
 // Implementation of local handles which are handed out from every
 // dart API call, these handles are valid only in the present scope
@@ skipping 153 matching lines @@
   }
 
 
   // Visit all object pointers stored in the various handles.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) {
     Handles<kLocalHandleSizeInWords,
             kLocalHandlesPerChunk,
             kOffsetOfRawPtrInLocalHandle>::VisitObjectPointers(visitor);
   }
 
+  // Reset the local handles block for reuse.
+  void Reset() {
+    Handles<kLocalHandleSizeInWords,
+            kLocalHandlesPerChunk,
+            kOffsetOfRawPtrInLocalHandle>::Reset();
+  }
+
   // Allocates a handle in the current handle scope. This handle is valid only
   // in the current handle scope and is destroyed when the current handle
   // scope ends.
   LocalHandle* AllocateHandle() {
     return reinterpret_cast<LocalHandle*>(AllocateScopedHandle());
   }
 
   // Validate if passed in handle is a Local Handle.
   bool IsValidHandle(Dart_Handle object) const {
     return IsValidScopedHandle(reinterpret_cast<uword>(object));
@@ skipping 220 matching lines @@
 // Structure used for the implementation of local scopes used in dart_api.
 // These local scopes manage handles and memory allocated in the scope.
 class ApiLocalScope {
  public:
   ApiLocalScope(ApiLocalScope* previous, uword stack_marker) :
       previous_(previous), stack_marker_(stack_marker) { }
   ~ApiLocalScope() {
     previous_ = NULL;
   }
 
+  // Reinit the ApiLocalScope to new values.
+  void Reinit(Isolate* isolate, ApiLocalScope* previous, uword stack_marker) {
+    previous_ = previous;
+    stack_marker_ = stack_marker;
+    zone_.Reinit(isolate);
+  }
+
+  // Reset the ApiLocalScope so that it can be reused again.
+  void Reset(Isolate* isolate) {
+    local_handles_.Reset();
+    zone_.Reset(isolate);
+    previous_ = NULL;
+    stack_marker_ = 0;
+  }
+
   // Accessors.
   ApiLocalScope* previous() const { return previous_; }
   uword stack_marker() const { return stack_marker_; }
   void set_previous(ApiLocalScope* value) { previous_ = value; }
   LocalHandles* local_handles() { return &local_handles_; }
   Zone* zone() { return zone_.GetZone(); }
 
  private:
   ApiLocalScope* previous_;
   uword stack_marker_;
   LocalHandles local_handles_;
   ApiZone zone_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiLocalScope);
 };
 
 
 // Implementation of the API State used in dart api for maintaining
 // local scopes, persistent handles etc. These are setup on a per isolate
 // basis and destroyed when the isolate is shutdown.
 class ApiState {
  public:
-  ApiState() : top_scope_(NULL), delayed_weak_reference_sets_(NULL),
-               null_(NULL), true_(NULL), false_(NULL),
+  ApiState() : persistent_handles_(),
+               weak_persistent_handles_(),
+               prologue_weak_persistent_handles_(),
+               reusable_scope_(NULL),
+               top_scope_(NULL),
+               delayed_weak_reference_sets_(NULL),
+               null_(NULL),
+               true_(NULL),
+               false_(NULL),
                acquired_error_(NULL) {}
   ~ApiState() {
     while (top_scope_ != NULL) {
       ApiLocalScope* scope = top_scope_;
       top_scope_ = top_scope_->previous();
       delete scope;
     }
     if (null_ != NULL) {
       persistent_handles().FreeHandle(null_);
       null_ = NULL;
     }
     if (true_ != NULL) {
       persistent_handles().FreeHandle(true_);
       true_ = NULL;
     }
     if (false_ != NULL) {
       persistent_handles().FreeHandle(false_);
       false_ = NULL;
     }
     if (acquired_error_ != NULL) {
       persistent_handles().FreeHandle(acquired_error_);
       acquired_error_ = NULL;
     }
   }
 
   // Accessors.
+  ApiLocalScope* reusable_scope() const { return reusable_scope_; }
+  void set_reusable_scope(ApiLocalScope* value) {
+    ASSERT(value == NULL || reusable_scope_ == NULL);
+    reusable_scope_ = value;
+  }
   ApiLocalScope* top_scope() const { return top_scope_; }
   void set_top_scope(ApiLocalScope* value) { top_scope_ = value; }
 
   PersistentHandles& persistent_handles() { return persistent_handles_; }
 
   FinalizablePersistentHandles& weak_persistent_handles() {
     return weak_persistent_handles_;
   }
 
   FinalizablePersistentHandles& prologue_weak_persistent_handles() {
@@ skipping 105 matching lines @@
   }
 
   void DelayWeakReferenceSet(WeakReferenceSet* reference_set) {
     WeakReferenceSet::Push(reference_set, &delayed_weak_reference_sets_);
   }
 
  private:
   PersistentHandles persistent_handles_;
   FinalizablePersistentHandles weak_persistent_handles_;
   FinalizablePersistentHandles prologue_weak_persistent_handles_;
+  ApiLocalScope* reusable_scope_;
   ApiLocalScope* top_scope_;
   WeakReferenceSet* delayed_weak_reference_sets_;
 
   // Persistent handles to important objects.
   PersistentHandle* null_;
   PersistentHandle* true_;
   PersistentHandle* false_;
   PersistentHandle* acquired_error_;
 
   DISALLOW_COPY_AND_ASSIGN(ApiState);
@@ skipping 38 matching lines @@
           ApiNativeScope::Current()->zone()) {}
   ApiGrowableArray()
       : BaseGrowableArray<T, ValueObject>(
           ApiNativeScope::Current()->zone()) {}
 };
 
 
 }  // namespace dart
 
 #endif  // VM_DART_API_STATE_H_