Generalize map dependent codes array to allow multiple dependency groups.

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 4665 matching lines @@
 
   // Code aging -- platform-specific
   static void PatchPlatformCodeAge(byte* sequence, Age age,
                                    MarkingParity parity);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Code);
 };
 
 
 // This class describes the layout of dependent codes array of a map. The
-// first element contains the number of codes as a Smi. The subsequent
-// elements contain code objects. The suffix of the array can be filled with the
-// undefined value if the number of codes is less than the length of the array.
+// array is partitioned into several groups of dependent codes. Each group
+// contains codes with the same dependency on the map. The array has the
+// following layout for n dependency groups:
+//
+// +----+----+-----+----+---------+----------+-----+---------+-----------+
+// | C1 | C2 | ... | Cn | group 1 |  group 2 | ... | group n | undefined |
+// +----+----+-----+----+---------+----------+-----+---------+-----------+
+//
+// The first n elements are Smis, each of them specifies the number of codes
+// in the corresponding group. The subsequent elements contain grouped code
+// objects. The suffix of the array can be filled with the undefined value if
+// the number of codes is less than the length of the array.

[Michael Starzinger, 2013/02/14 10:40:52]

Can we also add a sentence stating that the order of the code objects within a
group is not preserved by this implementation?

[ulan_google, 2013/02/14 11:59:06]

Done.

+// 
+// All code indexes used in the class are counted starting from the first
+// code object of the first group. In other words, code index 0 corresponds
+// to array index n = kCodesStartIndex.
+
 class DependentCodes: public FixedArray {
  public:
-  inline int number_of_codes();
-  inline void set_number_of_codes(int value);
+  enum DependencyGroup {
+    // Group of codes that weakly embed this map and depend on being
+    // deoptimized when the map is garbage collected.
+    kWeaklyEmbeddedGroup,
+    kGroupCount = kWeaklyEmbeddedGroup + 1
+  };
+  // Array for holding the index of the first code object of each group.
+  // The last element stores the total number of code objects.
+  typedef int GroupStartIndexes[kGroupCount + 1];
+  inline int number_of_codes(DependencyGroup group);
+  inline void set_number_of_codes(DependencyGroup group, int value);
   inline Code* code_at(int i);
   inline void set_code_at(int i, Code* value);
   inline Object** code_slot_at(int i);
   inline void clear_code_at(int i);

[Michael Starzinger, 2013/02/14 10:40:52]

As discussed offline: Can we (visually) separate the low-level from the
high-level accessors? The low-level ones should only be used by the GC, adding a
comment in that regard would help to clarify that.

[ulan_google, 2013/02/14 11:59:06]

Done.

-  static Handle<DependentCodes> Append(Handle<DependentCodes> codes,
+  static inline DependentCodes* cast(Object* object);
+  inline void ComputeGroupStartIndexes(GroupStartIndexes starts);
+  bool Contains(DependencyGroup group, Code* code);
+  static Handle<DependentCodes> Insert(Handle<DependentCodes> codes,
+                                       DependencyGroup group,
                                        Handle<Code> value);
-  static inline DependentCodes* cast(Object* object);
-  bool Contains(Code* code);
+
  private:
-  static const int kNumberOfCodesIndex = 0;
-  static const int kCodesIndex = 1;
+  // Make a room at the end of the given group by moving out the first
+  // code objects of the subsequent groups.
+  inline void ExtendGroup(DependencyGroup group);
+  static const int kCodesStartIndex = kGroupCount;
 };
 
 
 // All heap objects have a Map that describes their structure.
 //  A Map contains information about:
 //  - Size information about the object
 //  - How to iterate over an object (for garbage collection)
 class Map: public HeapObject {
  public:
   // Instance size.
@@ skipping 430 matching lines @@
   // heap verification is turned on.
   void ZapPrototypeTransitions();
   void ZapTransitions();
 
   bool CanTransition() {
     // Only JSObject and subtypes have map transitions and back pointers.
     STATIC_ASSERT(LAST_TYPE == LAST_JS_OBJECT_TYPE);
     return instance_type() >= FIRST_JS_OBJECT_TYPE;
   }
 
-  inline void AddDependentCode(Handle<Code> code);
+  inline void AddDependentCode(DependentCodes::DependencyGroup group,
+                               Handle<Code> code);
 
   // Dispatched behavior.
   DECLARE_PRINTER(Map)
   DECLARE_VERIFIER(Map)
 
 #ifdef VERIFY_HEAP
   void SharedMapVerify();
 #endif
 
   inline int visitor_id();
@@ skipping 3720 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_