* ayang review: _initiate_conc_mark_if_possible does not need to be volatile or Atomic at all

Author: tschatzl

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

@@ -26,17 +26,6 @@
 #include "runtime/safepoint.hpp"
 #include "utilities/debug.hpp"
 
-G1CollectorState::G1CollectorState(const G1CollectorState& other) :
-  _phase(other._phase), _initiate_conc_mark_if_possible(other.initiate_conc_mark_if_possible()) { }
-
-G1CollectorState& G1CollectorState::operator=(const G1CollectorState& other) {
-  if (this != &other) {
-    _phase = other._phase;
-    set_initiate_conc_mark_if_possible(other.initiate_conc_mark_if_possible());
-  }
-  return *this;
-}
-
 G1CollectorState::Pause G1CollectorState::gc_pause_type(bool concurrent_operation_is_full_mark) const {
   assert(SafepointSynchronize::is_at_safepoint(), "must be");
   switch (_phase) {

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

@@ -25,7 +25,6 @@
 #ifndef SHARE_GC_G1_G1COLLECTORSTATE_HPP
 #define SHARE_GC_G1_G1COLLECTORSTATE_HPP
 
-#include "runtime/atomic.hpp"
 #include "utilities/debug.hpp"
 #include "utilities/enumIterator.hpp"
 #include "utilities/globalDefinitions.hpp"
@@ -60,16 +59,13 @@ class G1CollectorState {
   // has been in progress when the request came in.
   //
   // This flag remembers that there is an unfullfilled request.
-  Atomic<bool> _initiate_conc_mark_if_possible;
+  bool _initiate_conc_mark_if_possible;
 
 public:
   G1CollectorState() :
     _phase(Phase::YoungNormal),
     _initiate_conc_mark_if_possible(false) { }
 
-  G1CollectorState(const G1CollectorState& other);
-  G1CollectorState& operator=(const G1CollectorState& other);
-
   // Phase setters
   inline void set_in_normal_young_gc();
   inline void set_in_space_reclamation_phase();

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

@@ -49,7 +49,7 @@ inline void G1CollectorState::set_in_prepare_mixed_gc() {
 }
 
 inline void G1CollectorState::set_initiate_conc_mark_if_possible(bool v) {
-  _initiate_conc_mark_if_possible.store_relaxed(v);
+  _initiate_conc_mark_if_possible = v;
 }
 
 inline bool G1CollectorState::is_in_young_only_phase() const {
@@ -72,7 +72,7 @@ inline bool G1CollectorState::is_in_concurrent_start_gc() const {
 }
 
 inline bool G1CollectorState::initiate_conc_mark_if_possible() const {
-  return _initiate_conc_mark_if_possible.load_relaxed();
+  return _initiate_conc_mark_if_possible;
 }
 
 inline bool G1CollectorState::is_in_concurrent_cycle() const {

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

@@ -1253,6 +1253,7 @@ void G1Policy::update_survivors_policy() {
 }
 
 bool G1Policy::force_concurrent_start_if_outside_cycle(GCCause::Cause gc_cause) {
+  assert_at_safepoint_on_vm_thread();
   // We actually check whether we are marking here and not if we are in a
   // reclamation phase. This means that we will schedule a concurrent mark
   // even while we are still in the process of reclaiming memory.

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

@@ -335,9 +335,8 @@ class G1Policy: public CHeapObj<mtGC> {
 
 public:
   // This sets the initiate_conc_mark_if_possible() flag to start a
-  // new cycle, as long as we are not already in one. It's best if it
-  // is called during a safepoint when the test whether a cycle is in
-  // progress or not is stable.
+  // new cycle, as long as we are not already in one. It is called
+  // at a safepoint.
   bool force_concurrent_start_if_outside_cycle(GCCause::Cause gc_cause);
 
   // Decide whether this garbage collection pause should be a concurrent start