182 "SATB queues must only be processed at safepoints"); 183 if (_buf != NULL) { 184 assert(_index % sizeof(void*) == 0, "invariant"); 185 assert(_sz % sizeof(void*) == 0, "invariant"); 186 assert(_index <= _sz, "invariant"); 187 cl->do_buffer(_buf + byte_index_to_index(_index), 188 byte_index_to_index(_sz - _index)); 189 _index = _sz; 190 } 191 } 192 193 #ifndef PRODUCT 194 // Helpful for debugging 195 196 void SATBMarkQueue::print(const char* name) { 197 print(name, _buf, _index, _sz); 198 } 199 200 void SATBMarkQueue::print(const char* name, 201 void** buf, size_t index, size_t sz) { 202 gclog_or_tty->print_cr(" SATB BUFFER [%s] buf: " PTR_FORMAT " " 203 "index: " SIZE_FORMAT " sz: " SIZE_FORMAT, 204 name, p2i(buf), index, sz); 205 } 206 #endif // PRODUCT 207 208 SATBMarkQueueSet::SATBMarkQueueSet() : 209 PtrQueueSet(), 210 _shared_satb_queue(this, true /* permanent */) { } 211 212 void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock, 213 int process_completed_threshold, 214 Mutex* lock) { 215 PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1); 216 _shared_satb_queue.set_lock(lock); 217 } 218 219 void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) { 220 t->satb_mark_queue().handle_zero_index(); 221 } 222 223 #ifdef ASSERT 224 void SATBMarkQueueSet::dump_active_states(bool expected_active) { 225 gclog_or_tty->print_cr("Expected SATB active state: %s", 226 expected_active ? "ACTIVE" : "INACTIVE"); 227 gclog_or_tty->print_cr("Actual SATB active states:"); 228 gclog_or_tty->print_cr(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE"); 229 for (JavaThread* t = Threads::first(); t; t = t->next()) { 230 gclog_or_tty->print_cr(" Thread \"%s\" queue: %s", t->name(), 231 t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE"); 232 } 233 gclog_or_tty->print_cr(" Shared queue: %s", 234 shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE"); 235 } 236 237 void SATBMarkQueueSet::verify_active_states(bool expected_active) { 238 // Verify queue set state 239 if (is_active() != expected_active) { 240 dump_active_states(expected_active); 241 guarantee(false, "SATB queue set has an unexpected active state"); 242 } 243 244 // Verify thread queue states 245 for (JavaThread* t = Threads::first(); t; t = t->next()) { 246 if (t->satb_mark_queue().is_active() != expected_active) { 247 dump_active_states(expected_active); 248 guarantee(false, "Thread SATB queue has an unexpected active state"); 249 } 250 } 251 252 // Verify shared queue state 253 if (shared_satb_queue()->is_active() != expected_active) { 254 dump_active_states(expected_active); 301 cl->do_buffer(buf + i, limit - i); 302 break; 303 } 304 } 305 deallocate_buffer(buf); 306 return true; 307 } else { 308 return false; 309 } 310 } 311 312 #ifndef PRODUCT 313 // Helpful for debugging 314 315 #define SATB_PRINTER_BUFFER_SIZE 256 316 317 void SATBMarkQueueSet::print_all(const char* msg) { 318 char buffer[SATB_PRINTER_BUFFER_SIZE]; 319 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); 320 321 gclog_or_tty->cr(); 322 gclog_or_tty->print_cr("SATB BUFFERS [%s]", msg); 323 324 BufferNode* nd = _completed_buffers_head; 325 int i = 0; 326 while (nd != NULL) { 327 void** buf = BufferNode::make_buffer_from_node(nd); 328 jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Enqueued: %d", i); 329 SATBMarkQueue::print(buffer, buf, 0, _sz); 330 nd = nd->next(); 331 i += 1; 332 } 333 334 for (JavaThread* t = Threads::first(); t; t = t->next()) { 335 jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Thread: %s", t->name()); 336 t->satb_mark_queue().print(buffer); 337 } 338 339 shared_satb_queue()->print("Shared"); 340 341 gclog_or_tty->cr(); 342 } 343 #endif // PRODUCT 344 345 void SATBMarkQueueSet::abandon_partial_marking() { 346 BufferNode* buffers_to_delete = NULL; 347 { 348 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); 349 while (_completed_buffers_head != NULL) { 350 BufferNode* nd = _completed_buffers_head; 351 _completed_buffers_head = nd->next(); 352 nd->set_next(buffers_to_delete); 353 buffers_to_delete = nd; 354 } 355 _completed_buffers_tail = NULL; 356 _n_completed_buffers = 0; 357 DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked()); 358 } 359 while (buffers_to_delete != NULL) { 360 BufferNode* nd = buffers_to_delete; 361 buffers_to_delete = nd->next(); | 182 "SATB queues must only be processed at safepoints"); 183 if (_buf != NULL) { 184 assert(_index % sizeof(void*) == 0, "invariant"); 185 assert(_sz % sizeof(void*) == 0, "invariant"); 186 assert(_index <= _sz, "invariant"); 187 cl->do_buffer(_buf + byte_index_to_index(_index), 188 byte_index_to_index(_sz - _index)); 189 _index = _sz; 190 } 191 } 192 193 #ifndef PRODUCT 194 // Helpful for debugging 195 196 void SATBMarkQueue::print(const char* name) { 197 print(name, _buf, _index, _sz); 198 } 199 200 void SATBMarkQueue::print(const char* name, 201 void** buf, size_t index, size_t sz) { 202 tty->print_cr(" SATB BUFFER [%s] buf: " PTR_FORMAT " index: " SIZE_FORMAT " sz: " SIZE_FORMAT, 203 name, p2i(buf), index, sz); 204 } 205 #endif // PRODUCT 206 207 SATBMarkQueueSet::SATBMarkQueueSet() : 208 PtrQueueSet(), 209 _shared_satb_queue(this, true /* permanent */) { } 210 211 void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock, 212 int process_completed_threshold, 213 Mutex* lock) { 214 PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1); 215 _shared_satb_queue.set_lock(lock); 216 } 217 218 void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) { 219 t->satb_mark_queue().handle_zero_index(); 220 } 221 222 #ifdef ASSERT 223 void SATBMarkQueueSet::dump_active_states(bool expected_active) { 224 log_info(gc, verify)("Expected SATB active state: %s", expected_active ? "ACTIVE" : "INACTIVE"); 225 log_info(gc, verify)("Actual SATB active states:"); 226 log_info(gc, verify)(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE"); 227 for (JavaThread* t = Threads::first(); t; t = t->next()) { 228 log_info(gc, verify)(" Thread \"%s\" queue: %s", t->name(), t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE"); 229 } 230 log_info(gc, verify)(" Shared queue: %s", shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE"); 231 } 232 233 void SATBMarkQueueSet::verify_active_states(bool expected_active) { 234 // Verify queue set state 235 if (is_active() != expected_active) { 236 dump_active_states(expected_active); 237 guarantee(false, "SATB queue set has an unexpected active state"); 238 } 239 240 // Verify thread queue states 241 for (JavaThread* t = Threads::first(); t; t = t->next()) { 242 if (t->satb_mark_queue().is_active() != expected_active) { 243 dump_active_states(expected_active); 244 guarantee(false, "Thread SATB queue has an unexpected active state"); 245 } 246 } 247 248 // Verify shared queue state 249 if (shared_satb_queue()->is_active() != expected_active) { 250 dump_active_states(expected_active); 297 cl->do_buffer(buf + i, limit - i); 298 break; 299 } 300 } 301 deallocate_buffer(buf); 302 return true; 303 } else { 304 return false; 305 } 306 } 307 308 #ifndef PRODUCT 309 // Helpful for debugging 310 311 #define SATB_PRINTER_BUFFER_SIZE 256 312 313 void SATBMarkQueueSet::print_all(const char* msg) { 314 char buffer[SATB_PRINTER_BUFFER_SIZE]; 315 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint."); 316 317 tty->cr(); 318 tty->print_cr("SATB BUFFERS [%s]", msg); 319 320 BufferNode* nd = _completed_buffers_head; 321 int i = 0; 322 while (nd != NULL) { 323 void** buf = BufferNode::make_buffer_from_node(nd); 324 jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Enqueued: %d", i); 325 SATBMarkQueue::print(buffer, buf, 0, _sz); 326 nd = nd->next(); 327 i += 1; 328 } 329 330 for (JavaThread* t = Threads::first(); t; t = t->next()) { 331 jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Thread: %s", t->name()); 332 t->satb_mark_queue().print(buffer); 333 } 334 335 shared_satb_queue()->print("Shared"); 336 337 tty->cr(); 338 } 339 #endif // PRODUCT 340 341 void SATBMarkQueueSet::abandon_partial_marking() { 342 BufferNode* buffers_to_delete = NULL; 343 { 344 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag); 345 while (_completed_buffers_head != NULL) { 346 BufferNode* nd = _completed_buffers_head; 347 _completed_buffers_head = nd->next(); 348 nd->set_next(buffers_to_delete); 349 buffers_to_delete = nd; 350 } 351 _completed_buffers_tail = NULL; 352 _n_completed_buffers = 0; 353 DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked()); 354 } 355 while (buffers_to_delete != NULL) { 356 BufferNode* nd = buffers_to_delete; 357 buffers_to_delete = nd->next(); |