61 PtrQueue(qset, perm, false /* active */) { }
62
63 // Overrides PtrQueue::flush() so that it can filter the buffer
64 // before it is flushed.
65 virtual void flush();
66
67 // Overrides PtrQueue::should_enqueue_buffer(). See the method's
68 // definition for more information.
69 virtual bool should_enqueue_buffer();
70
71 #ifndef PRODUCT
72 // Helpful for debugging
73 void print(const char* name);
74 static void print(const char* name, void** buf, size_t index, size_t sz);
75 #endif // PRODUCT
76
77 void verify_oops_in_buffer() NOT_DEBUG_RETURN;
78 };
79
80 class SATBMarkQueueSet: public PtrQueueSet {
81 ObjectClosure* _closure;
82 ObjectClosure** _par_closures; // One per ParGCThread.
83
84 ObjPtrQueue _shared_satb_queue;
85
86 // Utility function to support sequential and parallel versions. If
87 // "par" is true, then "worker" is the par thread id; if "false", worker
88 // is ignored.
89 bool apply_closure_to_completed_buffer_work(bool par, uint worker);
90
91 #ifdef ASSERT
92 void dump_active_states(bool expected_active);
93 void verify_active_states(bool expected_active);
94 #endif // ASSERT
95
96 public:
97 SATBMarkQueueSet();
98
99 void initialize(Monitor* cbl_mon, Mutex* fl_lock,
100 int process_completed_threshold,
101 Mutex* lock);
102
103 static void handle_zero_index_for_thread(JavaThread* t);
104
105 // Apply "set_active(active)" to all SATB queues in the set. It should be
106 // called only with the world stopped. The method will assert that the
107 // SATB queues of all threads it visits, as well as the SATB queue
108 // set itself, has an active value same as expected_active.
109 void set_active_all_threads(bool active, bool expected_active);
110
111 // Filter all the currently-active SATB buffers.
112 void filter_thread_buffers();
113
114 // Register "blk" as "the closure" for all queues. Only one such closure
115 // is allowed. The "apply_closure_to_completed_buffer" method will apply
116 // this closure to a completed buffer, and "iterate_closure_all_threads"
117 // applies it to partially-filled buffers (the latter should only be done
118 // with the world stopped).
119 void set_closure(ObjectClosure* closure);
120 // Set the parallel closures: pointer is an array of pointers to
121 // closures, one for each parallel GC thread.
122 void set_par_closure(int i, ObjectClosure* closure);
123
124 // If there exists some completed buffer, pop it, then apply the
125 // registered closure to all its elements, and return true. If no
126 // completed buffers exist, return false.
127 bool apply_closure_to_completed_buffer() {
128 return apply_closure_to_completed_buffer_work(false, 0);
129 }
130 // Parallel version of the above.
131 bool par_apply_closure_to_completed_buffer(uint worker) {
132 return apply_closure_to_completed_buffer_work(true, worker);
133 }
134
135 // Apply the given closure on enqueued and currently-active buffers
136 // respectively. Both methods are read-only, i.e., they do not
137 // modify any of the buffers.
138 void iterate_completed_buffers_read_only(ObjectClosure* cl);
139 void iterate_thread_buffers_read_only(ObjectClosure* cl);
140
141 #ifndef PRODUCT
142 // Helpful for debugging
143 void print_all(const char* msg);
144 #endif // PRODUCT
145
146 ObjPtrQueue* shared_satb_queue() { return &_shared_satb_queue; }
147
148 // If a marking is being abandoned, reset any unprocessed log buffers.
149 void abandon_partial_marking();
150 };
151
152 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_SATBQUEUE_HPP
|
61 PtrQueue(qset, perm, false /* active */) { }
62
63 // Overrides PtrQueue::flush() so that it can filter the buffer
64 // before it is flushed.
65 virtual void flush();
66
67 // Overrides PtrQueue::should_enqueue_buffer(). See the method's
68 // definition for more information.
69 virtual bool should_enqueue_buffer();
70
71 #ifndef PRODUCT
72 // Helpful for debugging
73 void print(const char* name);
74 static void print(const char* name, void** buf, size_t index, size_t sz);
75 #endif // PRODUCT
76
77 void verify_oops_in_buffer() NOT_DEBUG_RETURN;
78 };
79
80 class SATBMarkQueueSet: public PtrQueueSet {
81 ObjectClosure** _closures; // One per ParGCThread.
82
83 ObjPtrQueue _shared_satb_queue;
84
85 #ifdef ASSERT
86 void dump_active_states(bool expected_active);
87 void verify_active_states(bool expected_active);
88 #endif // ASSERT
89
90 public:
91 SATBMarkQueueSet();
92
93 void initialize(Monitor* cbl_mon, Mutex* fl_lock,
94 int process_completed_threshold,
95 Mutex* lock);
96
97 static void handle_zero_index_for_thread(JavaThread* t);
98
99 // Apply "set_active(active)" to all SATB queues in the set. It should be
100 // called only with the world stopped. The method will assert that the
101 // SATB queues of all threads it visits, as well as the SATB queue
102 // set itself, has an active value same as expected_active.
103 void set_active_all_threads(bool active, bool expected_active);
104
105 // Filter all the currently-active SATB buffers.
106 void filter_thread_buffers();
107
108 // Register "blk" as "the closure" for all queues. Only one such closure
109 // is allowed. The "apply_closure_to_completed_buffer" method will apply
110 // this closure to a completed buffer, and "iterate_closure_all_threads"
111 // applies it to partially-filled buffers (the latter should only be done
112 // with the world stopped).
113 void set_closure(int i, ObjectClosure* closure);
114
115 // If there exists some completed buffer, pop it, then apply the
116 // registered closure to all its elements, and return true. If no
117 // completed buffers exist, return false.
118 bool apply_closure_to_completed_buffer(uint worker);
119
120 // Apply the given closure on enqueued and currently-active buffers
121 // respectively. Both methods are read-only, i.e., they do not
122 // modify any of the buffers.
123 void iterate_completed_buffers_read_only(ObjectClosure* cl);
124 void iterate_thread_buffers_read_only(ObjectClosure* cl);
125
126 #ifndef PRODUCT
127 // Helpful for debugging
128 void print_all(const char* msg);
129 #endif // PRODUCT
130
131 ObjPtrQueue* shared_satb_queue() { return &_shared_satb_queue; }
132
133 // If a marking is being abandoned, reset any unprocessed log buffers.
134 void abandon_partial_marking();
135 };
136
137 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_SATBQUEUE_HPP
|