External references should not affect dominance relation.

src/profile-generator.h

 // Copyright 2011 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 459 matching lines @@
     return index_;
   }
   const char* name() {
     ASSERT(type_ == kContextVariable
            || type_ == kProperty
            || type_ == kInternal
            || type_ == kShortcut);
     return name_;
   }
   HeapEntry* to() { return to_; }
-
-  HeapEntry* From();
+  INLINE(HeapEntry* from());
 
  private:
   int child_index_ : 29;
   unsigned type_ : 3;
   union {
     int index_;
     const char* name_;
   };
   HeapEntry* to_;
 
@@ skipping 63 matching lines @@
   Vector<HeapGraphEdge*> retainers() {
     return Vector<HeapGraphEdge*>(retainers_arr(), retainers_count_); }
   HeapEntry* dominator() { return dominator_; }
   void set_dominator(HeapEntry* entry) {
     ASSERT(entry != NULL);
     dominator_ = entry;
   }
   void clear_paint() { painted_ = false; }
   bool painted() { return painted_; }
   void paint() { painted_ = true; }
+  bool reachable_from_window() { return reachable_from_window_; }
+  void set_reachable_from_window() { reachable_from_window_ = true; }
 
   void SetIndexedReference(HeapGraphEdge::Type type,
                            int child_index,
                            int index,
                            HeapEntry* entry,
                            int retainer_index);
   void SetNamedReference(HeapGraphEdge::Type type,
                          int child_index,
                          const char* name,
                          HeapEntry* entry,
@@ skipping 16 matching lines @@
  private:
   HeapGraphEdge* children_arr() {
     return reinterpret_cast<HeapGraphEdge*>(this + 1);
   }
   HeapGraphEdge** retainers_arr() {
     return reinterpret_cast<HeapGraphEdge**>(children_arr() + children_count_);
   }
   const char* TypeAsString();
 
   unsigned painted_: 1;
+  unsigned reachable_from_window_: 1;

[mnaganov (inactive), 2012/04/05 22:00:13]

Do we really need an additional field? It seems that 'painted_' bit is only used
in FillPostorderIndexes. We can first fill the indexes, and then mark reachable
objects, reusing the same bit. 

[alexeif, 2012/04/06 10:04:36]

They both are in use in FillPostorderIndexes.

[mnaganov (inactive), 2012/04/06 14:16:01]

Sorry, didn't realize that. It is queried in IsRetainingEdge.

   unsigned type_: 4;
-  int children_count_: 27;
+  int children_count_: 26;
   int retainers_count_;
   int self_size_;
   union {
     int ordered_index_;  // Used during dominator tree building.
     int retained_size_;  // At that moment, there is no retained size yet.
   };
   SnapshotObjectId id_;
   HeapEntry* dominator_;
   HeapSnapshot* snapshot_;
   const char* name_;
@@ skipping 477 matching lines @@
   HeapSnapshotGenerator(HeapSnapshot* snapshot,
                         v8::ActivityControl* control);
   bool GenerateSnapshot();
 
  private:
   bool BuildDominatorTree(const Vector<HeapEntry*>& entries,
                           Vector<int>* dominators);
   bool CalculateRetainedSizes();
   bool CountEntriesAndReferences();
   bool FillReferences();
-  void FillReversePostorderIndexes(Vector<HeapEntry*>* entries);
+  void FillPostorderIndexes(Vector<HeapEntry*>* entries);

[mnaganov (inactive), 2012/04/05 22:00:13]

Why the rename? "Reverse" means that children will have order indexes in reverse
to their child index, as we are processing them backwards.

[alexeif, 2012/04/06 10:04:36]

This algorithm assigns postorder indexes which means the parent is processed
after its nodes. AFAICT word "Reverse" came from the dominators building
algorithm where we're processing postorder sorted nodes in reverse order. So the
word reverse has no relation to this particular function, thus I removed it.

[alexeif, 2012/04/06 10:07:11]

typo: read "after its children".

+  void MarkWindowReachableObjects();
   void ProgressStep();
   bool ProgressReport(bool force = false);
   bool SetEntriesDominators();
   void SetProgressTotal(int iterations_count);
 
   HeapSnapshot* snapshot_;
   v8::ActivityControl* control_;
   V8HeapExplorer v8_heap_explorer_;
   NativeObjectsExplorer dom_explorer_;
   // Mapping from HeapThing pointers to HeapEntry* pointers.
@@ skipping 54 matching lines @@
 
   friend class HeapSnapshotJSONSerializerEnumerator;
   friend class HeapSnapshotJSONSerializerIterator;
 
   DISALLOW_COPY_AND_ASSIGN(HeapSnapshotJSONSerializer);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_PROFILE_GENERATOR_H_