Pretenuring calculation fields in AllocationSite.

src/objects.h

 // Copyright 2012 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 8002 matching lines @@
 
 class AllocationSite: public Struct {
  public:
   static const uint32_t kMaximumArrayBytesToPretransition = 8 * 1024;
 
   DECL_ACCESSORS(transition_info, Object)
   // nested_site threads a list of sites that represent nested literals
   // walked in a particular order. So [[1, 2], 1, 2] will have one
   // nested_site, but [[1, 2], 3, [4]] will have a list of two.
   DECL_ACCESSORS(nested_site, Object)
+  DECL_ACCESSORS(memento_found_count, Smi)
+  DECL_ACCESSORS(memento_create_count, Smi)

[Hannes Payer (out of office), 2013/10/28 10:46:54]

If we encounter that allocation sites are getting too big, we could just use
half a word for the found and create count.

[mvstanton, 2013/10/28 11:29:28]

I actually had something like this for a while, but pulled it out for lack of
evidence in favor of simplicity. How about we'll recognize that the field layout
may be wasteful, or have cache line issues, at the moment we are testing these.
(very soon, but not yet).

+  DECL_ACCESSORS(pretenure_decision, Smi)

[Hannes Payer (out of office), 2013/10/28 10:46:54]

Hmm, maybe this is good enough for this CL but I think this should become a more
general pretenure_status field, where we encode the current state of pretenuring
for the given allocation site:
1-Bit bool pretenure yes/no
3-Bits decision counter, how many times have we changed our mind to pretenure.
If we have done that too often, we should probably stop emitting mementos.
Maybe more stuff... Again, if size is not a problem we can have separate fields
which feel a bit wasteful.

   DECL_ACCESSORS(dependent_code, DependentCode)
   DECL_ACCESSORS(weak_next, Object)
 
   inline void Initialize();
 
   bool HasNestedSites() {
     return nested_site()->IsAllocationSite();
   }
 
   // This method is expensive, it should only be called for reporting.
@@ skipping 19 matching lines @@
   DECLARE_VERIFIER(AllocationSite)
 
   static inline AllocationSite* cast(Object* obj);
   static inline AllocationSiteMode GetMode(
       ElementsKind boilerplate_elements_kind);
   static inline AllocationSiteMode GetMode(ElementsKind from, ElementsKind to);
   static inline bool CanTrack(InstanceType type);
 
   static const int kTransitionInfoOffset = HeapObject::kHeaderSize;
   static const int kNestedSiteOffset = kTransitionInfoOffset + kPointerSize;
-  static const int kDependentCodeOffset = kNestedSiteOffset + kPointerSize;
+  static const int kMementoFoundCountOffset = kNestedSiteOffset + kPointerSize;
+  static const int kMementoCreateCountOffset =
+      kMementoFoundCountOffset + kPointerSize;
+  static const int kPretenureDecisionOffset =
+      kMementoCreateCountOffset + kPointerSize;
+  static const int kDependentCodeOffset =
+      kPretenureDecisionOffset + kPointerSize;
   static const int kWeakNextOffset = kDependentCodeOffset + kPointerSize;
   static const int kSize = kWeakNextOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<HeapObject::kHeaderSize,
                               kDependentCodeOffset + kPointerSize,
                               kSize> BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationSite);
 };
@@ skipping 2354 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_