- Added a map cache for literal objects. This will...

src/runtime.cc

 // Copyright 2006-2008 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 79 matching lines @@
   return Top::Throw(Heap::illegal_access_symbol());
 }
 
 
 static Object* Runtime_CloneObjectLiteralBoilerplate(Arguments args) {
   CONVERT_CHECKED(JSObject, boilerplate, args[0]);
   return boilerplate->Copy();
 }
 
 
+static Handle<Map> ComputeObjectLiteralMap(Handle<Context> context,
+                                    Handle<FixedArray> constant_properties,

[Mads Ager (chromium), 2008/09/25 07:23:19]

Indentation slightly off here.

+                                    bool &is_result_from_cache) {
+  if (FLAG_canonicalize_object_literal_maps) {
+    // First find prefix of consecutive symbol keys.
+    int number_of_properties = constant_properties->length()/2;
+    int number_of_symbol_keys = 0;
+    while ((number_of_symbol_keys < number_of_properties)

[Mads Ager (chromium), 2008/09/25 07:23:19]

How about: 

    while ((number_of_symbol_keys == number_of_properties) &&
           (constant_properties->get(number_of_symbol_keys*2)->IsSymbol())) {

Doesn't that fit in 80 columns?

+           && (constant_properties->get(number_of_symbol_keys*2)
+               ->IsSymbol())) {
+      number_of_symbol_keys++;
+    }
+    // Based on the number of prefix symbols key we decide whether
+    // to use the map cache in the global context.
+    const int kMaxKeys = 10;
+    if ((number_of_symbol_keys == number_of_properties)
+        && (number_of_symbol_keys < kMaxKeys)) {
+    // Create the fixed array with the key.

[Mads Ager (chromium), 2008/09/25 07:23:19]

Indent two more spaces?

+      Handle<FixedArray> keys = Factory::NewFixedArray(number_of_symbol_keys);
+      for (int i = 0; i < number_of_symbol_keys; i++) {
+        keys->set(i, constant_properties->get(i*2));
+      }
+      is_result_from_cache = true;
+      return Factory::ObjectLiteralMapFromCache(context, keys);
+    }
+  }
+  is_result_from_cache = false;
+  return Handle<Map>(context->object_function()->initial_map());
+}
+
+
 static Object* Runtime_CreateObjectLiteralBoilerplate(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 3);
   // Copy the arguments.
   Handle<FixedArray> literals = args.at<FixedArray>(0);
   int literals_index = Smi::cast(args[1])->value();
   Handle<FixedArray> constant_properties = args.at<FixedArray>(2);
+  Handle<Context> context =
+      Handle<Context>(JSFunction::GlobalContextFromLiterals(*literals));
+
+  bool is_result_from_cache;
+  Handle<Map> map = ComputeObjectLiteralMap(context,
+                                            constant_properties,
+                                            is_result_from_cache);
 
   // Get the object function from the literals array.  This is the
   // object function from the context in which the function was
   // created.  We do not use the object function from the current
   // global context because this might be the object function from
   // another context which we should not have access to.
-  const int kObjectFunIndex = JSFunction::kLiteralObjectFunctionIndex;
-  Handle<JSFunction> constructor =
-      Handle<JSFunction>(JSFunction::cast(literals->get(kObjectFunIndex)));
-
-  Handle<JSObject> boilerplate = Factory::NewJSObject(constructor, TENURED);
-
+  Handle<JSObject> boilerplate = Factory::NewJSObjectFromMap(map);
   {  // Add the constant propeties to the boilerplate.
     int length = constant_properties->length();
-    OptimizedObjectForAddingMultipleProperties opt(boilerplate, true);
+    OptimizedObjectForAddingMultipleProperties opt(boilerplate,
+                                                   !is_result_from_cache);
     for (int index = 0; index < length; index +=2) {
       Handle<Object> key(constant_properties->get(index+0));
       Handle<Object> value(constant_properties->get(index+1));
       uint32_t element_index = 0;
       if (key->IsSymbol()) {
         // If key is a symbol it is not an array element.
         Handle<String> name(String::cast(*key));
         ASSERT(!name->AsArrayIndex(&element_index));
         SetProperty(boilerplate, name, value, NONE);
       } else if (Array::IndexFromObject(*key, &element_index)) {
@@ skipping 21 matching lines @@
 
 static Object* Runtime_CreateArrayLiteral(Arguments args) {
   // Takes a FixedArray of elements containing the literal elements of
   // the array literal and produces JSArray with those elements.
   // Additionally takes the literals array of the surrounding function
   // which contains the Array function to use for creating the array
   // literal.
   ASSERT(args.length() == 2);
   CONVERT_CHECKED(FixedArray, elements, args[0]);
   CONVERT_CHECKED(FixedArray, literals, args[1]);
-  const int kArrayFunIndex = JSFunction::kLiteralArrayFunctionIndex;
-  JSFunction* constructor = JSFunction::cast(literals->get(kArrayFunIndex));
-
+  JSFunction* constructor =
+      JSFunction::GlobalContextFromLiterals(literals)->array_function();
   // Create the JSArray.
   Object* object = Heap::AllocateJSObject(constructor);
   if (object->IsFailure()) return object;
 
   // Copy the elements.
   Object* content = elements->Copy();
   if (content->IsFailure()) return content;
 
   // Set the elements.
   JSArray::cast(object)->SetContent(FixedArray::cast(content));
@@ skipping 516 matching lines @@
   CONVERT_ARG_CHECKED(FixedArray, literals, 0);
   int index = Smi::cast(args[1])->value();
   Handle<String> pattern = args.at<String>(2);
   Handle<String> flags = args.at<String>(3);
 
   // Get the RegExp function from the literals array.  This is the
   // RegExp function from the context in which the function was
   // created.  We do not use the RegExp function from the current
   // global context because this might be the RegExp function from
   // another context which we should not have access to.
-  const int kRegexpFunIndex = JSFunction::kLiteralRegExpFunctionIndex;
   Handle<JSFunction> constructor =
-      Handle<JSFunction>(JSFunction::cast(literals->get(kRegexpFunIndex)));
-
+      Handle<JSFunction>(
+          JSFunction::GlobalContextFromLiterals(*literals)->regexp_function());
   // Compute the regular expression literal.
   bool has_pending_exception;
   Handle<Object> regexp =
       RegExpImpl::CreateRegExpLiteral(constructor, pattern, flags,
                                       &has_pending_exception);
   if (has_pending_exception) {
     ASSERT(Top::has_pending_exception());
     return Failure::Exception();
   }
   literals->set(index, *regexp);
@@ skipping 105 matching lines @@
 
     // Make sure we get a fresh copy of the literal vector to avoid
     // cross context contamination.
     int number_of_literals = fun->NumberOfLiterals();
     Handle<FixedArray> literals =
         Factory::NewFixedArray(number_of_literals, TENURED);
     if (number_of_literals > 0) {
       // Insert the object, regexp and array functions in the literals
       // array prefix.  These are the functions that will be used when
       // creating object, regexp and array literals.
-      literals->set(JSFunction::kLiteralObjectFunctionIndex,
-                    context->global_context()->object_function());
-      literals->set(JSFunction::kLiteralRegExpFunctionIndex,
-                    context->global_context()->regexp_function());
-      literals->set(JSFunction::kLiteralArrayFunctionIndex,
-                    context->global_context()->array_function());
+      literals->set(JSFunction::kLiteralGlobalContextIndex,
+                    context->global_context());
     }
     target->set_literals(*literals);
   }
 
   target->set_context(*context);
   return *target;
 }
 
 
 static Object* CharCodeAt(String* subject, Object* index) {
@@ skipping 4129 matching lines @@
 
 void Runtime::PerformGC(Object* result) {
   Failure* failure = Failure::cast(result);
   // Try to do a garbage collection; ignore it if it fails. The C
   // entry stub will throw an out-of-memory exception in that case.
   Heap::CollectGarbage(failure->requested(), failure->allocation_space());
 }
 
 
 } }  // namespace v8::internal