Mercurial > hg > truffle

comparison src/share/vm/gc_implementation/g1/concurrentG1RefineThread.hpp @ 794:315a5d70b295

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6484957: G1: parallel concurrent refinement 6826318: G1: remove traversal-based refinement code Summary: Removed traversal-based refinement code as it's no longer used. Made the concurrent refinement (queue-based) parallel. Reviewed-by: tonyp
author iveresov
date Mon, 11 May 2009 16:30:56 -0700
parents 37f87013dfd8
children 215f81b4d9b3
comparison
equal deleted inserted replaced
758:9b3a41ccc927 794:315a5d70b295
31 friend class VMStructs; 31 friend class VMStructs;
32 friend class G1CollectedHeap; 32 friend class G1CollectedHeap;
33 33
34 double _vtime_start; // Initial virtual time. 34 double _vtime_start; // Initial virtual time.
35 double _vtime_accum; // Initial virtual time. 35 double _vtime_accum; // Initial virtual time.
36 int _worker_id;
36 37
38 // The refinement threads collection is linked list. A predecessor can activate a successor
39 // when the number of the rset update buffer crosses a certain threshold. A successor
40 // would self-deactivate when the number of the buffers falls below the threshold.
41 bool _active;
42 ConcurrentG1RefineThread * _next;
37 public: 43 public:
38 virtual void run(); 44 virtual void run();
39 45
46 bool is_active() { return _active; }
47 void activate() { _active = true; }
48 void deactivate() { _active = false; }
49
40 private: 50 private:
41 ConcurrentG1Refine* _cg1r; 51 ConcurrentG1Refine* _cg1r;
42 bool _started;
43 bool _in_progress;
44 volatile bool _restart;
45 52
46 COTracker _co_tracker; 53 COTracker _co_tracker;
47 double _interval_ms; 54 double _interval_ms;
48
49 bool _do_traversal;
50 55
51 void decreaseInterval(int processing_time_ms) { 56 void decreaseInterval(int processing_time_ms) {
52 double min_interval_ms = (double) processing_time_ms; 57 double min_interval_ms = (double) processing_time_ms;
53 _interval_ms = 0.8 * _interval_ms; 58 _interval_ms = 0.8 * _interval_ms;
54 if (_interval_ms < min_interval_ms) 59 if (_interval_ms < min_interval_ms)
61 _interval_ms = max_interval_ms; 66 _interval_ms = max_interval_ms;
62 } 67 }
63 68
64 void sleepBeforeNextCycle(); 69 void sleepBeforeNextCycle();
65 70
66 void traversalBasedRefinement();
67
68 void queueBasedRefinement();
69
70 // For use by G1CollectedHeap, which is a friend. 71 // For use by G1CollectedHeap, which is a friend.
71 static SuspendibleThreadSet* sts() { return &_sts; } 72 static SuspendibleThreadSet* sts() { return &_sts; }
72 73
73 public: 74 public:
74 // Constructor 75 // Constructor
75 ConcurrentG1RefineThread(ConcurrentG1Refine* cg1r); 76 ConcurrentG1RefineThread(ConcurrentG1Refine* cg1r, ConcurrentG1RefineThread* next, int worker_id);
76 77
77 // Printing 78 // Printing
78 void print(); 79 void print();
79 80
80 // Total virtual time so far. 81 // Total virtual time so far.
81 double vtime_accum() { return _vtime_accum; } 82 double vtime_accum() { return _vtime_accum; }
82 83
83 ConcurrentG1Refine* cg1r() { return _cg1r; } 84 ConcurrentG1Refine* cg1r() { return _cg1r; }
84 85
85
86 void set_started() { _started = true; }
87 void clear_started() { _started = false; }
88 bool started() { return _started; }
89
90 void set_in_progress() { _in_progress = true; }
91 void clear_in_progress() { _in_progress = false; }
92 bool in_progress() { return _in_progress; }
93
94 void set_do_traversal(bool b);
95 bool do_traversal() { return _do_traversal; }
96
97 void sample_young_list_rs_lengths(); 86 void sample_young_list_rs_lengths();
98 87
99 // Yield for GC 88 // Yield for GC
100 void yield(); 89 void yield();
101 90
102 // shutdown 91 // shutdown
103 static void stop(); 92 void stop();
104 }; 93 };