Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/concurrentMarkThread.hpp @ 1359:23b1b27ac76c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6909756: G1: guarantee(G1CollectedHeap::heap()->mark_in_progress(),"Precondition.") Summary: Make sure that two marking cycles do not overlap, i.e., a new one can only start after the concurrent marking thread finishes all its work. In the fix I piggy-back a couple of minor extra fixes: some general code reformatting for consistency (only around the code I modified), the removal of a field (G1CollectorPolicy::_should_initiate_conc_mark) which doesn't seem to be used at all (it's only set but never read), as well as moving the "is GC locker active" test earlier into the G1 pause / Full GC and using a more appropriate method for it. Reviewed-by: johnc, jmasa, jcoomes, ysr
author tonyp
date Tue, 06 Apr 2010 10:59:45 -0400
parents 035d2e036a9b
children c18cbe5936b8
comparison
equal deleted inserted replaced
1358:72f725c5a7be 1359:23b1b27ac76c
40 public: 40 public:
41 virtual void run(); 41 virtual void run();
42 42
43 private: 43 private:
44 ConcurrentMark* _cm; 44 ConcurrentMark* _cm;
45 bool _started; 45 volatile bool _started;
46 bool _in_progress; 46 volatile bool _in_progress;
47 47
48 void sleepBeforeNextCycle(); 48 void sleepBeforeNextCycle();
49 49
50 static SurrogateLockerThread* _slt; 50 static SurrogateLockerThread* _slt;
51 51
65 // Marking virtual time so far 65 // Marking virtual time so far
66 double vtime_mark_accum(); 66 double vtime_mark_accum();
67 // Counting virtual time so far. 67 // Counting virtual time so far.
68 double vtime_count_accum() { return _vtime_count_accum; } 68 double vtime_count_accum() { return _vtime_count_accum; }
69 69
70 ConcurrentMark* cm() { return _cm; } 70 ConcurrentMark* cm() { return _cm; }
71 71
72 void set_started() { _started = true; } 72 void set_started() { _started = true; }
73 void clear_started() { _started = false; } 73 void clear_started() { _started = false; }
74 bool started() { return _started; } 74 bool started() { return _started; }
75 75
76 void set_in_progress() { _in_progress = true; } 76 void set_in_progress() { _in_progress = true; }
77 void clear_in_progress() { _in_progress = false; } 77 void clear_in_progress() { _in_progress = false; }
78 bool in_progress() { return _in_progress; } 78 bool in_progress() { return _in_progress; }
79
80 // This flag returns true from the moment a marking cycle is
81 // initiated (during the initial-mark pause when started() is set)
82 // to the moment when the cycle completes (just after the next
83 // marking bitmap has been cleared and in_progress() is
84 // cleared). While this flag is true we will not start another cycle
85 // so that cycles do not overlap. We cannot use just in_progress()
86 // as the CM thread might take some time to wake up before noticing
87 // that started() is set and set in_progress().
88 bool during_cycle() { return started() || in_progress(); }
79 89
80 // Yield for GC 90 // Yield for GC
81 void yield(); 91 void yield();
82 92
83 // shutdown 93 // shutdown