# HG changeset patch
# User brutisso
# Date 1435229557 0
# Node ID d48b9b0a06bf62343800cf498f682271b96798a7
# Parent  64bfaa6d10a9c95843842b8e0a8092cccfad3710# Parent  f63dde8cc8f7f3982f52b0b32ceec4e1a9ae6ac4
Merge

diff -r 64bfaa6d10a9 -r d48b9b0a06bf hotspot/src/share/vm/gc/g1/concurrentMarkThread.cpp
--- a/hotspot/src/share/vm/gc/g1/concurrentMarkThread.cpp	Thu Jun 25 08:30:23 2015 +0000
+++ b/hotspot/src/share/vm/gc/g1/concurrentMarkThread.cpp	Thu Jun 25 10:52:37 2015 +0000
@@ -44,8 +44,7 @@
 ConcurrentMarkThread::ConcurrentMarkThread(ConcurrentMark* cm) :
   ConcurrentGCThread(),
   _cm(cm),
-  _started(false),
-  _in_progress(false),
+  _state(Idle),
   _vtime_accum(0.0),
   _vtime_mark_accum(0.0) {
 
@@ -307,7 +306,6 @@
 
   if (started()) {
     set_in_progress();
-    clear_started();
   }
 }
 
diff -r 64bfaa6d10a9 -r d48b9b0a06bf hotspot/src/share/vm/gc/g1/concurrentMarkThread.hpp
--- a/hotspot/src/share/vm/gc/g1/concurrentMarkThread.hpp	Thu Jun 25 08:30:23 2015 +0000
+++ b/hotspot/src/share/vm/gc/g1/concurrentMarkThread.hpp	Thu Jun 25 10:52:37 2015 +0000
@@ -47,8 +47,14 @@
 
  private:
   ConcurrentMark*                  _cm;
-  volatile bool                    _started;
-  volatile bool                    _in_progress;
+
+  enum State {
+    Idle,
+    Started,
+    InProgress
+  };
+
+  volatile State _state;
 
   void sleepBeforeNextCycle();
 
@@ -68,23 +74,22 @@
 
   ConcurrentMark* cm()     { return _cm; }
 
-  void set_started()       { assert(!_in_progress, "cycle in progress"); _started = true;  }
-  void clear_started()     { assert(_in_progress, "must be starting a cycle"); _started = false; }
-  bool started()           { return _started;  }
+  void set_idle()          { assert(_state != Started, "must not be starting a new cycle"); _state = Idle; }
+  bool idle()              { return _state == Idle; }
+  void set_started()       { assert(_state == Idle, "cycle in progress"); _state = Started; }
+  bool started()           { return _state == Started; }
+  void set_in_progress()   { assert(_state == Started, "must be starting a cycle"); _state = InProgress; }
+  bool in_progress()       { return _state == InProgress; }
 
-  void set_in_progress()   { assert(_started, "must be starting a cycle"); _in_progress = true;  }
-  void clear_in_progress() { assert(!_started, "must not be starting a new cycle"); _in_progress = false; }
-  bool in_progress()       { return _in_progress;  }
-
-  // This flag returns true from the moment a marking cycle is
+  // Returns true from the moment a marking cycle is
   // initiated (during the initial-mark pause when started() is set)
   // to the moment when the cycle completes (just after the next
   // marking bitmap has been cleared and in_progress() is
-  // cleared). While this flag is true we will not start another cycle
+  // cleared). While during_cycle() is true we will not start another cycle
   // so that cycles do not overlap. We cannot use just in_progress()
   // as the CM thread might take some time to wake up before noticing
   // that started() is set and set in_progress().
-  bool during_cycle()      { return started() || in_progress(); }
+  bool during_cycle()      { return !idle(); }
 
   // shutdown
   void stop();
diff -r 64bfaa6d10a9 -r d48b9b0a06bf hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp
--- a/hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp	Thu Jun 25 08:30:23 2015 +0000
+++ b/hotspot/src/share/vm/gc/g1/g1CollectedHeap.cpp	Thu Jun 25 10:52:37 2015 +0000
@@ -2487,7 +2487,7 @@
   // is set) so that if a waiter requests another System.gc() it doesn't
   // incorrectly see that a marking cycle is still in progress.
   if (concurrent) {
-    _cmThread->clear_in_progress();
+    _cmThread->set_idle();
   }
 
   // This notify_all() will ensure that a thread that called