Active smi-only optimizations for large array literals.

src/runtime.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 404 matching lines @@
   // constant function properties.
   if (should_transform && !has_function_literal) {
     TransformToFastProperties(boilerplate,
                               boilerplate->map()->unused_property_fields());
   }
 
   return boilerplate;
 }
 
 
+static const int kSmiOnlyLiteralMinimumLength = 1024;
+
+
 static Handle<Object> CreateArrayLiteralBoilerplate(
     Isolate* isolate,
     Handle<FixedArray> literals,
     Handle<FixedArray> elements) {
   // Create the JSArray.
   Handle<JSFunction> constructor(
       JSFunction::GlobalContextFromLiterals(*literals)->array_function());
   Handle<Object> object = isolate->factory()->NewJSObject(constructor);
 
+  if (elements->length() > kSmiOnlyLiteralMinimumLength) {
+    Handle<Map> smi_array_map = isolate->factory()->GetElementsTransitionMap(
+        Handle<JSObject>::cast(object),
+        FAST_SMI_ONLY_ELEMENTS);
+    HeapObject::cast(*object)->set_map(*smi_array_map);
+  }
+
   const bool is_cow =
       (elements->map() == isolate->heap()->fixed_cow_array_map());
   Handle<FixedArray> copied_elements =
       is_cow ? elements : isolate->factory()->CopyFixedArray(elements);
 
   Handle<FixedArray> content = Handle<FixedArray>::cast(copied_elements);
   bool has_non_smi = false;
   if (is_cow) {
     // Copy-on-write arrays must be shallow (and simple).
-    if (FLAG_smi_only_arrays) {
-      for (int i = 0; i < content->length(); i++) {
-        Object* current = content->get(i);
-        ASSERT(!current->IsFixedArray());
-        if (!current->IsSmi() && !current->IsTheHole()) {
-          has_non_smi = true;
-        }
+    for (int i = 0; i < content->length(); i++) {
+      Object* current = content->get(i);
+      ASSERT(!current->IsFixedArray());
+      if (!current->IsSmi() && !current->IsTheHole()) {
+        has_non_smi = true;
       }
-    } else {
+    }
 #if DEBUG
-      for (int i = 0; i < content->length(); i++) {
-        ASSERT(!content->get(i)->IsFixedArray());
-      }
+    for (int i = 0; i < content->length(); i++) {
+      ASSERT(!content->get(i)->IsFixedArray());
+    }
 #endif
-    }
   } else {
     for (int i = 0; i < content->length(); i++) {
       Object* current = content->get(i);
       if (current->IsFixedArray()) {
         // The value contains the constant_properties of a
         // simple object or array literal.
         Handle<FixedArray> fa(FixedArray::cast(content->get(i)));
         Handle<Object> result =
             CreateLiteralBoilerplate(isolate, literals, fa);
         if (result.is_null()) return result;
         content->set(i, *result);
         has_non_smi = true;
       } else {
         if (!current->IsSmi() && !current->IsTheHole()) {
           has_non_smi = true;
         }
       }
     }
   }
 
   // Set the elements.
   Handle<JSArray> js_object(Handle<JSArray>::cast(object));
   isolate->factory()->SetContent(js_object, content);
 
-  if (FLAG_smi_only_arrays) {
-    if (has_non_smi && js_object->HasFastSmiOnlyElements()) {
-      isolate->factory()->EnsureCanContainNonSmiElements(js_object);
-    }
+  if (has_non_smi && js_object->HasFastSmiOnlyElements()) {
+    isolate->factory()->EnsureCanContainNonSmiElements(js_object);
   }
 
   return object;
 }
 
 
 static Handle<Object> CreateLiteralBoilerplate(
     Isolate* isolate,
     Handle<FixedArray> literals,
     Handle<FixedArray> array) {
@@ skipping 1158 matching lines @@
   if (object->HasFastProperties()) {
     NormalizeProperties(object, KEEP_INOBJECT_PROPERTIES, properties);
   }
   return *object;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_NonSmiElementStored) {
   ASSERT(args.length() == 1);
   CONVERT_ARG_CHECKED(JSObject, object, 0);
-  if (FLAG_smi_only_arrays && object->HasFastSmiOnlyElements()) {
+  if (object->HasFastSmiOnlyElements()) {
     MaybeObject* maybe_map = object->GetElementsTransitionMap(FAST_ELEMENTS);
     Map* map;
     if (!maybe_map->To<Map>(&map)) return maybe_map;
     object->set_map(Map::cast(map));
   }
   return *object;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_RegExpExec) {
@@ skipping 8066 matching lines @@
         } else if (receiver->HasElement(j)) {
           // Call GetElement on receiver, not its prototype, or getters won't
           // have the correct receiver.
           element_value = GetElement(receiver, j);
           if (element_value.is_null()) return false;
           visitor->visit(j, element_value);
         }
       }
       break;
     }
+    case FAST_DOUBLE_ELEMENTS: {
+      // Run through the elements FixedArray and use HasElement and GetElement
+      // to check the prototype for missing elements.
+      Handle<FixedDoubleArray> elements(
+          FixedDoubleArray::cast(receiver->elements()));
+      int fast_length = static_cast<int>(length);
+      ASSERT(fast_length <= elements->length());
+      for (int j = 0; j < fast_length; j++) {
+        HandleScope loop_scope(isolate);
+        if (!elements->is_the_hole(j)) {
+          MaybeObject* maybe_double_object = elements->get(j);
+          Object* double_object;
+          if (!maybe_double_object->ToObject(&double_object)) {
+            return false;
+          }
+          Handle<Object> element_value(double_object, isolate);
+          visitor->visit(j, element_value);
+        } else if (receiver->HasElement(j)) {
+          // Call GetElement on receiver, not its prototype, or getters won't
+          // have the correct receiver.
+          Handle<Object> element_value = GetElement(receiver, j);
+          if (element_value.is_null()) return false;
+          visitor->visit(j, element_value);
+        }
+      }
+      break;
+    }
     case DICTIONARY_ELEMENTS: {
       Handle<NumberDictionary> dict(receiver->element_dictionary());
       List<uint32_t> indices(dict->Capacity() / 2);
       // Collect all indices in the object and the prototypes less
       // than length. This might introduce duplicates in the indices list.
       CollectElementIndices(receiver, length, &indices);
       indices.Sort(&compareUInt32);
       int j = 0;
       int n = indices.length();
       while (j < n) {
@@ skipping 3478 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags);
   }
 }
 
 
 } }  // namespace v8::internal