some attempts to not have TAMSes always be updated for all regions

Author: Thomas Schatzl

src/hotspot/share/gc/g1/g1CollectedHeap.cpp

@@ -190,6 +190,9 @@ HeapRegion* G1CollectedHeap::new_region(size_t word_size,
       res = _hrm.allocate_free_region(type, node_index);
     }
   }
+  if (res != nullptr) {
+    concurrent_mark()->clear_statistics(res);
+  }
   return res;
 }
 
@@ -2635,6 +2638,8 @@ void G1CollectedHeap::free_region(HeapRegion* hr, FreeRegionList* free_list) {
   if (free_list != nullptr) {
     free_list->add_ordered(hr);
   }
+
+  concurrent_mark()->clear_statistics(hr);
 }
 
 void G1CollectedHeap::retain_region(HeapRegion* hr) {

src/hotspot/share/gc/g1/g1ConcurrentMark.cpp

@@ -567,7 +567,6 @@ void G1ConcurrentMark::reset() {
 
   uint max_reserved_regions = _g1h->max_reserved_regions();
   for (uint i = 0; i < max_reserved_regions; i++) {
-    _top_at_mark_starts[i] = _g1h->bottom_addr_for_region(i);
     _top_at_rebuild_starts[i] = nullptr;
     _region_mark_stats[i].clear();
   }
@@ -591,16 +590,6 @@ void G1ConcurrentMark::humongous_object_eagerly_reclaimed(HeapRegion* r) {
 
   // Need to clear mark bit of the humongous object. Doing this unconditionally is fine.
   mark_bitmap()->clear(r->bottom());
-
-  if (!_g1h->collector_state()->mark_or_rebuild_in_progress()) {
-    return;
-  }
-
-  // Clear any statistics about the region gathered so far.
-  _g1h->humongous_obj_regions_iterate(r,
-                                      [&] (HeapRegion* r) {
-                                        clear_statistics(r);
-                                      });
 }
 
 void G1ConcurrentMark::reset_marking_for_restart() {
@@ -856,7 +845,7 @@ class G1PreConcurrentStartTask::NoteStartOfMarkTask : public G1AbstractSubTask {
 
 void G1PreConcurrentStartTask::ResetMarkingStateTask::do_work(uint worker_id) {
   // Reset marking state.
-  //_cm->reset();
+  _cm->reset();
 }
 
 class NoteStartOfMarkHRClosure : public HeapRegionClosure {
@@ -868,6 +857,8 @@ class NoteStartOfMarkHRClosure : public HeapRegionClosure {
   bool do_heap_region(HeapRegion* r) override {
     if (r->is_old_or_humongous() && !r->is_collection_set_candidate()) {
       _cm->update_top_at_mark_start(r);
+    } else {
+      _cm->reset_top_at_mark_start(r);
     }
     return false;
   }
@@ -886,16 +877,25 @@ G1PreConcurrentStartTask::G1PreConcurrentStartTask(GCCause::Cause cause, G1Concu
   G1BatchedTask("Pre Concurrent Start", G1CollectedHeap::heap()->phase_times()) {
   add_serial_task(new ResetMarkingStateTask(cm));
   add_parallel_task(new NoteStartOfMarkTask());
+
+  //cm->invalidate_top_at_mark_starts();
 };
 
+#ifdef ASSERT
+void G1ConcurrentMark::invalidate_top_at_mark_starts() {
+  for (uint i = 0; i < G1CollectedHeap::heap()->max_reserved_regions(); i++) {
+    _top_at_mark_starts[i] = nullptr;
+  }
+}
+#endif
+
 void G1ConcurrentMark::pre_concurrent_start(GCCause::Cause cause) {
   assert_at_safepoint_on_vm_thread();
 
   G1CollectedHeap::start_codecache_marking_cycle_if_inactive(true /* concurrent_mark_start */);
 
   ClassLoaderDataGraph::verify_claimed_marks_cleared(ClassLoaderData::_claim_strong);
 
-  reset();
   G1PreConcurrentStartTask cl(cause, this);
   G1CollectedHeap::heap()->run_batch_task(&cl);
 
@@ -1481,7 +1481,6 @@ class G1ReclaimEmptyRegionsTask : public WorkerTask {
           _g1h->free_region(hr, _local_cleanup_list);
         }
         hr->clear_cardtable();
-        _g1h->concurrent_mark()->clear_statistics(hr);
       }
 
       return false;
@@ -1942,7 +1941,6 @@ void G1ConcurrentMark::flush_all_task_caches() {
 void G1ConcurrentMark::clear_bitmap_for_region(HeapRegion* hr) {
   assert_at_safepoint();
   _mark_bitmap.clear_range(MemRegion(hr->bottom(), hr->end()));
-  reset_top_at_mark_start(hr);
 }
 
 HeapRegion* G1ConcurrentMark::claim_region(uint worker_id) {

src/hotspot/share/gc/g1/g1ConcurrentMark.hpp

@@ -568,6 +568,8 @@ class G1ConcurrentMark : public CHeapObj<mtGC> {
   inline HeapWord* top_at_mark_start(uint region) const;
   inline bool obj_allocated_since_mark_start(oop obj) const;
 
+  void invalidate_top_at_mark_starts() NOT_DEBUG_RETURN;
+
   // Sets the internal top_at_region_start for the given region to current top of the region.
   inline void update_top_at_rebuild_start(HeapRegion* r);
   // TARS for the given region during remembered set rebuilding.

src/hotspot/share/gc/g1/g1HeapRegion.cpp

@@ -124,7 +124,6 @@ void HeapRegion::hr_clear(bool clear_space) {
 
   rem_set()->clear();
 
-  G1CollectedHeap::heap()->concurrent_mark()->reset_top_at_mark_start(this); // FIXME
   _parsable_bottom = bottom();
   _garbage_bytes = 0;
 

src/hotspot/share/gc/g1/g1HeapRegion.inline.hpp

@@ -187,9 +187,9 @@ inline void HeapRegion::reset_skip_compacting_after_full_gc() {
 }
 
 inline void HeapRegion::reset_after_full_gc_common() {
-  // After a full gc the mark bitmap in a movable region is invalid.
-  // But all objects are live, we get this by setting TAMS to bottom.
-  G1CollectedHeap::heap()->concurrent_mark()->reset_top_at_mark_start(this); // FIXME
+  // After a full gc the mark bitmap in a movable region is invalid. Reset marking
+  // information.
+  G1CollectedHeap::heap()->concurrent_mark()->clear_statistics(this); // FIXME?
 
   // Everything above bottom() is parsable and live.
   reset_parsable_bottom();

src/hotspot/share/gc/g1/g1YoungGCPostEvacuateTasks.cpp

@@ -550,11 +550,12 @@ class G1PostEvacuateCollectionSetCleanupTask2::ProcessEvacuationFailedRegionsTas
       assert(cm->live_bytes(r->hrm_index()) == 0, "Marking live bytes must not be set for region %u", r->hrm_index());
 
       // Concurrent mark does not mark through regions that we retain (they are root
-      // regions wrt to marking), so we must clear their mark data (tams, bitmap)
+      // regions wrt to marking), so we must clear their mark data (tams, bitmap, ...)
       // set eagerly or during evacuation failure.
       bool clear_mark_data = !g1h->collector_state()->in_concurrent_start_gc() ||
                              g1h->policy()->should_retain_evac_failed_region(r);
 
+      cm->clear_statistics(r);
       if (clear_mark_data) {
         g1h->clear_bitmap_for_region(r);
       } else {