Dynamically determine optimal instance size....

src/runtime.cc

 // Copyright 2006-2009 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 6261 matching lines @@
   Handle<Object> result = Execution::New(
       function, fixed_length, *param_data, &exception);
   if (exception) {
       return Failure::Exception();
   }
   ASSERT(!result.is_null());
   return *result;
 }
 
 
-static Code* ComputeConstructStub(Handle<JSFunction> function) {
+static void SetInlineConstructStub(Handle<JSFunction> function) {

[Vitaly Repeshko, 2010/09/22 14:40:25]

This name is misleading. It makes the reader think an inline stub
unconditionally set. Consider adding "IfPossible" suffix or "Maybe" prefix.

[Vladislav Kaznacheev, 2010/09/23 08:38:16]

renamed to TrySettingInlineConstructStub

On 2010/09/22 14:40:25, Vitaly wrote:

   Handle<Object> prototype = Factory::null_value();
   if (function->has_instance_prototype()) {
     prototype = Handle<Object>(function->instance_prototype());
   }
   if (function->shared()->CanGenerateInlineConstructor(*prototype)) {
     ConstructStubCompiler compiler;
     Object* code = compiler.CompileConstructStub(function->shared());
-    if (code->IsFailure()) {
-      return Builtins::builtin(Builtins::JSConstructStubGeneric);
+    if (!code->IsFailure()) {
+      function->shared()->set_construct_stub(Code::cast(code));
     }
-    return Code::cast(code);
   }
-
-  return function->shared()->construct_stub();
 }
 
 
 static Object* Runtime_NewObject(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
 
   Handle<Object> constructor = args.at<Object>(0);
 
   // If the constructor isn't a proper function we throw a type error.
@@ skipping 36 matching lines @@
       // reported the same way whether or not 'Function' is called
       // using 'new'.
       return Top::context()->global();
     }
   }
 
   // The function should be compiled for the optimization hints to be available.
   Handle<SharedFunctionInfo> shared(function->shared());
   EnsureCompiled(shared, CLEAR_EXCEPTION);
 
-  bool first_allocation = !function->has_initial_map();
+  if (!function->has_initial_map() &&
+      shared->IsInobjectSlackTrackingInProgress()) {
+    // The tracking can be in progress only in some other context
+    // (because in the current context the function has no initial_map).
+    // We can only do the tracking in one context at a time, so we force the
+    // completion before the current context starts allocating objects.
+    shared->CompleteInobjectSlackTracking();
+    SetInlineConstructStub(function);
+  }
+
+  bool first_allocation = !shared->live_objects_may_exist();
   Handle<JSObject> result = Factory::NewJSObject(function);
-  if (first_allocation) {
-    Handle<Code> stub = Handle<Code>(
-        ComputeConstructStub(Handle<JSFunction>(function)));
-    shared->set_construct_stub(*stub);
+  // Delay setting the stub if inobject slack tracking is in progress.
+  if (first_allocation && !shared->IsInobjectSlackTrackingInProgress()) {
+    SetInlineConstructStub(function);
   }
 
   Counters::constructed_objects.Increment();
   Counters::constructed_objects_runtime.Increment();
 
   return *result;
 }
 
 
+static Object* Runtime_FinalizeInstanceSize(Arguments args) {
+  HandleScope scope;
+  ASSERT(args.length() == 1);
+
+  Handle<Object> constructor = args.at<Object>(0);
+
+  // If the constructor isn't a proper function we throw a type error.

[Vitaly Repeshko, 2010/09/22 14:40:25]

Why do have to throw this specific error? Why can't CONVERT_ARG_CHECKED be used
here? If there is a reason, please update the comment.

[Vladislav Kaznacheev, 2010/09/23 08:38:16]

I got confused when fuzz natives test failed on this function. Simplified.
On 2010/09/22 14:40:25, Vitaly wrote:

+  if (!constructor->IsJSFunction()) {
+    Vector< Handle<Object> > arguments = HandleVector(&constructor, 1);
+    Handle<Object> type_error =
+        Factory::NewTypeError("not_constructor", arguments);
+    return Top::Throw(*type_error);
+  }
+
+  Handle<JSFunction> function = Handle<JSFunction>::cast(constructor);
+  Handle<SharedFunctionInfo> shared(function->shared());
+
+  ASSERT(shared->IsInobjectSlackTrackingInProgress());
+  shared->CompleteInobjectSlackTracking();
+  SetInlineConstructStub(function);
+
+  return Heap::undefined_value();
+}
+
+
 static Object* Runtime_LazyCompile(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
 
   Handle<JSFunction> function = args.at<JSFunction>(0);
 #ifdef DEBUG
   if (FLAG_trace_lazy && !function->shared()->is_compiled()) {
     PrintF("[lazy: ");
     function->shared()->name()->Print();
     PrintF("]\n");
@@ skipping 3785 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     Heap::CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal