src/share/vm/gc_implementation/g1/heapRegion.hpp

rev 4802 : imported patch optimize-nmethod-scanning

@@ -50,10 +50,11 @@
 class ContiguousSpace;
 class HeapRegionRemSet;
 class HeapRegionRemSetIterator;
 class HeapRegion;
 class HeapRegionSetBase;
+class nmethod;
 
 #define HR_FORMAT "%u:(%s)["PTR_FORMAT","PTR_FORMAT","PTR_FORMAT"]"
 #define HR_FORMAT_PARAMS(_hr_) \
                 (_hr_)->hrs_index(), \
                 (_hr_)->is_survivor() ? "S" : (_hr_)->is_young() ? "E" : \

@@ -335,10 +336,13 @@
 
   // The predicted number of bytes to copy that was added to
   // the total value for the collection set.
   size_t _predicted_bytes_to_copy;
 
+  // A list of code blobs (nmethods) whose code contains pointers into this region
+  GrowableArray<nmethod*>* _strong_code_root_list;
+
  public:
   HeapRegion(uint hrs_index,
              G1BlockOffsetSharedArray* sharedOffsetArray,
              MemRegion mr);
 

@@ -369,11 +373,12 @@
     ScrubRemSetClaimValue      = 3,
     ParVerifyClaimValue        = 4,
     RebuildRSClaimValue        = 5,
     ParEvacFailureClaimValue   = 6,
     AggregateCountClaimValue   = 7,
-    VerifyCountClaimValue      = 8
+    VerifyCountClaimValue      = 8,
+    ParMarkRootClaimValue      = 9
   };
 
   inline HeapWord* par_allocate_no_bot_updates(size_t word_size) {
     assert(is_young(), "we can only skip BOT updates on young regions");
     return ContiguousSpace::par_allocate(word_size);

@@ -794,10 +799,37 @@
 
   virtual CompactibleSpace* next_compaction_space() const;
 
   virtual void reset_after_compaction();
 
+  // Routines for managing the list of code roots that point into
+  // this heap region.
+  void add_strong_code_root(nmethod* nm);
+  void remove_strong_code_root(nmethod* nm);
+
+  GrowableArray<nmethod*>* strong_code_root_list() {
+    return _strong_code_root_list;
+  }
+
+  // During a collection, migrate successfully evacuated strong
+  // code roots attached to this region to the new regions that
+  // they point into. Unsuccessfully evacuated code roots are
+  // not migrated.
+  void migrate_strong_code_roots();
+
+  // Applies blk->do_code_blob() to each of the entries in
+  // the strong code roots list;
+  void strong_code_roots_do(CodeBlobClosure* blk) const;
+
+  // Returns the amount of memory, in bytes, currently
+  // consumed by the strong code roots.
+  size_t strong_code_root_mem_size();
+
+  // Verify that the entries on the strong code root list are live and
+  // include at least one pointer into this region.
+  void verify_strong_code_roots(VerifyOption vo, bool* failures) const;
+
   void print() const;
   void print_on(outputStream* st) const;
 
   // vo == UsePrevMarking  -> use "prev" marking information,
   // vo == UseNextMarking -> use "next" marking information