elements.cc CopyDoubleToObjectElements: avoid excessive HandleScopes

src/elements.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/elements.h"
 
 #include "src/arguments.h"
 #include "src/conversions.h"
 #include "src/factory.h"
 #include "src/messages.h"
@@ skipping 235 matching lines @@
 
   DCHECK((copy_size + static_cast<int>(to_start)) <= to_base->length() &&
          (copy_size + static_cast<int>(from_start)) <= from_base->length());
   if (copy_size == 0) return;
 
   // From here on, the code below could actually allocate. Therefore the raw
   // values are wrapped into handles.
   Isolate* isolate = from_base->GetIsolate();
   Handle<FixedDoubleArray> from(FixedDoubleArray::cast(from_base), isolate);
   Handle<FixedArray> to(FixedArray::cast(to_base), isolate);
-  for (int i = 0; i < copy_size; ++i) {
+
+  // create an outer loop to not waste too much time on creating HandleScopes
+  // on the other hand we might overflow a single handle scope depending on
+  // the copy_size
+  int offset = 0;
+  while (offset < copy_size) {
     HandleScope scope(isolate);
-    if (IsFastSmiElementsKind(to_kind)) {
-      UNIMPLEMENTED();
-    } else {
-      DCHECK(IsFastObjectElementsKind(to_kind));
-      Handle<Object> value = FixedDoubleArray::get(from, i + from_start);
-      to->set(i + to_start, *value, UPDATE_WRITE_BARRIER);
+    offset += 100;
+    for (int i = offset - 100; i < offset && i < copy_size; ++i) {
+      if (IsFastSmiElementsKind(to_kind)) {
+        UNIMPLEMENTED();
+      } else {
+        DCHECK(IsFastObjectElementsKind(to_kind));
+        Handle<Object> value = FixedDoubleArray::get(from, i + from_start);
+        to->set(i + to_start, *value, UPDATE_WRITE_BARRIER);
+      }
     }
   }
 }
 
 
 static void CopyDoubleToDoubleElements(FixedArrayBase* from_base,
                                        uint32_t from_start,
                                        FixedArrayBase* to_base,
                                        uint32_t to_start, int raw_copy_size) {
   DisallowHeapAllocation no_allocation;
@@ skipping 2133 matching lines @@
     }
   }
 
   DCHECK(j == result_len);
   return result_array;
 }
 
 ElementsAccessor** ElementsAccessor::elements_accessors_ = NULL;
 }  // namespace internal
 }  // namespace v8