Bookkeeping for allocation site pretenuring

src/hydrogen.cc

Index: src/hydrogen.cc
diff --git a/src/hydrogen.cc b/src/hydrogen.cc
index fd93ce3296dd5e75cbf1e733a41b3bdf9903720b..dc47e35de7a2d7e12a80ca3d40426f62273ff626 100644
--- a/src/hydrogen.cc
+++ b/src/hydrogen.cc
@@ -2249,6 +2249,21 @@ HInnerAllocatedObject* HGraphBuilder::BuildJSArrayHeader(HValue* array,
     BuildCreateAllocationMemento(array,

[Hannes Payer (out of office), 2013/11/25 11:45:52]

I guess it would make sense to make the code block below part of
BuildCreateAllocationMemento. WDYT?

[mvstanton, 2013/11/25 13:49:18]

The reason I left it out of there was that constructed arrays don't need this
code until they are participating in the alloc-site-based-pretenuring regime,
and I don't want that code to pay the performance penalty until it's getting the
reward too. The alternative is to add a boolean parameter to
BuildCreateAllocationMemento, like increment_create_count, but it would only be
necessary for a short time in the code base, until constructed arrays are part
of pretenuring.

                                  JSArray::kSize,
                                  allocation_site_payload);
+    if (FLAG_allocation_site_pretenuring) {
+      // TODO(mvstanton): move this code into BuildCreateAllocationMemento when
+      // constructed arrays also pay attention to pretenuring.
+      HObjectAccess access =
+          HObjectAccess::ForAllocationSiteOffset(
+              AllocationSite::kMementoCreateCountOffset);
+      HValue* create_info = Add<HLoadNamedField>(allocation_site_payload,
+                                                 access);
+      HInstruction* new_create_info = Add<HAdd>(create_info,
+                                                graph()->GetConstant1());
+      HStoreNamedField* store = Add<HStoreNamedField>(allocation_site_payload,
+                                                      access, new_create_info);
+      // no write barrier needed to store a smi.

[Hannes Payer (out of office), 2013/11/25 11:45:52]

"No"

[mvstanton, 2013/11/25 13:49:18]

Done.

+      store->SkipWriteBarrier();
+    }
   }
 
   int elements_location = JSArray::kSize;
@@ -9205,8 +9220,26 @@ HInstruction* HOptimizedGraphBuilder::BuildFastLiteral(
       ? HType::JSArray() : HType::JSObject();
   HValue* object_size_constant = Add<HConstant>(
       boilerplate_object->map()->instance_size());
+
+  // We should pull pre-tenure mode from the allocation site.
+  // For now, just see what it says, and remark on it if it sez
+  // we should pretenure. That means the rudimentary counting in the garbage
+  // collector is having an effect.
+  PretenureFlag pretenure_flag = isolate()->heap()->GetPretenureMode();
+  if (FLAG_allocation_site_pretenuring) {
+    pretenure_flag = site_context->current()->GetPretenureMode()
+        ? TENURED
+        : NOT_TENURED;
+    if (FLAG_trace_track_allocation_sites) {
+      PrintF("Hydrogen: AllocationSite %p boilerplate %p %s\n",
+             static_cast<void*>(*(site_context->current())),
+             static_cast<void*>(*boilerplate_object),
+             pretenure_flag == TENURED ? "tenured" : "not tenured");
+    }
+  }
+
   HInstruction* object = Add<HAllocate>(object_size_constant, type,
-      isolate()->heap()->GetPretenureMode(), instance_type);
+      pretenure_flag, instance_type);
 
   BuildEmitObjectHeader(boilerplate_object, object);
 
@@ -9220,10 +9253,10 @@ HInstruction* HOptimizedGraphBuilder::BuildFastLiteral(
     HValue* object_elements_size = Add<HConstant>(elements_size);
     if (boilerplate_object->HasFastDoubleElements()) {
       object_elements = Add<HAllocate>(object_elements_size, HType::JSObject(),
-          isolate()->heap()->GetPretenureMode(), FIXED_DOUBLE_ARRAY_TYPE);
+          pretenure_flag, FIXED_DOUBLE_ARRAY_TYPE);
     } else {
       object_elements = Add<HAllocate>(object_elements_size, HType::JSObject(),
-          isolate()->heap()->GetPretenureMode(), FIXED_ARRAY_TYPE);
+          pretenure_flag, FIXED_ARRAY_TYPE);
     }
   }
   BuildInitElementsInObjectHeader(boilerplate_object, object, object_elements);
@@ -9236,7 +9269,8 @@ HInstruction* HOptimizedGraphBuilder::BuildFastLiteral(
 
   // Copy in-object properties.
   if (boilerplate_object->map()->NumberOfFields() != 0) {
-    BuildEmitInObjectProperties(boilerplate_object, object, site_context);
+    BuildEmitInObjectProperties(boilerplate_object, object, site_context,
+                                pretenure_flag);
   }
   return object;
 }
@@ -9289,7 +9323,8 @@ void HOptimizedGraphBuilder::BuildInitElementsInObjectHeader(
 void HOptimizedGraphBuilder::BuildEmitInObjectProperties(
     Handle<JSObject> boilerplate_object,
     HInstruction* object,
-    AllocationSiteContext* site_context) {
+    AllocationSiteContext* site_context,
+    PretenureFlag pretenure_flag) {
   Handle<DescriptorArray> descriptors(
       boilerplate_object->map()->instance_descriptors());
   int limit = boilerplate_object->map()->NumberOfOwnDescriptors();
@@ -9325,15 +9360,13 @@ void HOptimizedGraphBuilder::BuildEmitInObjectProperties(
       if (representation.IsDouble()) {
         // Allocate a HeapNumber box and store the value into it.
         HValue* heap_number_constant = Add<HConstant>(HeapNumber::kSize);
-        // TODO(mvstanton): This heap number alloc does not have a corresponding
+        // This heap number alloc does not have a corresponding
         // AllocationSite. That is okay because
         // 1) it's a child object of another object with a valid allocation site
         // 2) we can just use the mode of the parent object for pretenuring
-        // The todo is replace GetPretenureMode() with
-        // site_context->top()->GetPretenureMode().
         HInstruction* double_box =
             Add<HAllocate>(heap_number_constant, HType::HeapNumber(),
-                isolate()->heap()->GetPretenureMode(), HEAP_NUMBER_TYPE);
+                pretenure_flag, HEAP_NUMBER_TYPE);
         AddStoreMapConstant(double_box,
             isolate()->factory()->heap_number_map());
         Add<HStoreNamedField>(double_box, HObjectAccess::ForHeapNumberValue(),