< prev index next >
src/hotspot/share/gc/shared/satbMarkQueue.cpp
Print this page
rev 53862 : [mq]: java_attach_protocol
rev 53865 : imported patch njt_iterate
rev 53867 : imported patch remove_shared_satb
rev 53868 : imported patch remove_shared_satb_lock
*** 39,49 ****
// SATB queues are only active during marking cycles. We create
// them with their active field set to false. If a thread is
// created during a cycle and its SATB queue needs to be activated
// before the thread starts running, we'll need to set its active
// field to true. This must be done in the collector-specific
! // BarrierSet::on_thread_attach() implementation.
PtrQueue(qset, permanent, false /* active */)
{ }
void SATBMarkQueue::flush() {
// Filter now to possibly save work later. If filtering empties the
--- 39,49 ----
// SATB queues are only active during marking cycles. We create
// them with their active field set to false. If a thread is
// created during a cycle and its SATB queue needs to be activated
// before the thread starts running, we'll need to set its active
// field to true. This must be done in the collector-specific
! // BarrierSet thread attachment protocol.
PtrQueue(qset, permanent, false /* active */)
{ }
void SATBMarkQueue::flush() {
// Filter now to possibly save work later. If filtering empties the
*** 55,67 ****
// This method will first apply filtering to the buffer. If filtering
// retains a small enough collection in the buffer, we can continue to
// use the buffer as-is, instead of enqueueing and replacing it.
bool SATBMarkQueue::should_enqueue_buffer() {
- assert(_lock == NULL || _lock->owned_by_self(),
- "we should have taken the lock before calling this");
-
// This method should only be called if there is a non-NULL buffer
// that is full.
assert(index() == 0, "pre-condition");
assert(_buf != NULL, "pre-condition");
--- 55,64 ----
*** 105,126 ****
#endif // PRODUCT
SATBMarkQueueSet::SATBMarkQueueSet() :
PtrQueueSet(),
- _shared_satb_queue(this, true /* permanent */),
_buffer_enqueue_threshold(0)
{}
void SATBMarkQueueSet::initialize(Monitor* cbl_mon,
BufferNode::Allocator* allocator,
size_t process_completed_buffers_threshold,
! uint buffer_enqueue_threshold_percentage,
! Mutex* lock) {
PtrQueueSet::initialize(cbl_mon, allocator);
set_process_completed_buffers_threshold(process_completed_buffers_threshold);
- _shared_satb_queue.set_lock(lock);
assert(buffer_size() != 0, "buffer size not initialized");
// Minimum threshold of 1 ensures enqueuing of completely full buffers.
size_t size = buffer_size();
size_t enqueue_qty = (size * buffer_enqueue_threshold_percentage) / 100;
_buffer_enqueue_threshold = MAX2(size - enqueue_qty, (size_t)1);
--- 102,120 ----
#endif // PRODUCT
SATBMarkQueueSet::SATBMarkQueueSet() :
PtrQueueSet(),
_buffer_enqueue_threshold(0)
{}
void SATBMarkQueueSet::initialize(Monitor* cbl_mon,
BufferNode::Allocator* allocator,
size_t process_completed_buffers_threshold,
! uint buffer_enqueue_threshold_percentage) {
PtrQueueSet::initialize(cbl_mon, allocator);
set_process_completed_buffers_threshold(process_completed_buffers_threshold);
assert(buffer_size() != 0, "buffer size not initialized");
// Minimum threshold of 1 ensures enqueuing of completely full buffers.
size_t size = buffer_size();
size_t enqueue_qty = (size * buffer_enqueue_threshold_percentage) / 100;
_buffer_enqueue_threshold = MAX2(size - enqueue_qty, (size_t)1);
*** 129,184 ****
#ifdef ASSERT
void SATBMarkQueueSet::dump_active_states(bool expected_active) {
log_error(gc, verify)("Expected SATB active state: %s", expected_active ? "ACTIVE" : "INACTIVE");
log_error(gc, verify)("Actual SATB active states:");
log_error(gc, verify)(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
! for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
! log_error(gc, verify)(" Thread \"%s\" queue: %s", t->name(), satb_queue_for_thread(t).is_active() ? "ACTIVE" : "INACTIVE");
}
! log_error(gc, verify)(" Shared queue: %s", shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE");
}
void SATBMarkQueueSet::verify_active_states(bool expected_active) {
// Verify queue set state
if (is_active() != expected_active) {
dump_active_states(expected_active);
! guarantee(false, "SATB queue set has an unexpected active state");
}
// Verify thread queue states
! for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
! if (satb_queue_for_thread(t).is_active() != expected_active) {
! dump_active_states(expected_active);
! guarantee(false, "Thread SATB queue has an unexpected active state");
}
}
!
! // Verify shared queue state
! if (shared_satb_queue()->is_active() != expected_active) {
! dump_active_states(expected_active);
! guarantee(false, "Shared SATB queue has an unexpected active state");
! }
}
#endif // ASSERT
void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
#ifdef ASSERT
verify_active_states(expected_active);
#endif // ASSERT
_all_active = active;
! for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
! satb_queue_for_thread(t).set_active(active);
}
! shared_satb_queue()->set_active(active);
}
void SATBMarkQueueSet::filter_thread_buffers() {
! for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
! satb_queue_for_thread(t).filter();
}
! shared_satb_queue()->filter();
}
bool SATBMarkQueueSet::apply_closure_to_completed_buffer(SATBBufferClosure* cl) {
BufferNode* nd = get_completed_buffer();
if (nd != NULL) {
--- 123,202 ----
#ifdef ASSERT
void SATBMarkQueueSet::dump_active_states(bool expected_active) {
log_error(gc, verify)("Expected SATB active state: %s", expected_active ? "ACTIVE" : "INACTIVE");
log_error(gc, verify)("Actual SATB active states:");
log_error(gc, verify)(" Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
!
! class DumpThreadStateClosure : public ThreadClosure {
! SATBMarkQueueSet* _qset;
! public:
! DumpThreadStateClosure(SATBMarkQueueSet* qset) : _qset(qset) {}
! virtual void do_thread(Thread* t) {
! SATBMarkQueue& queue = _qset->satb_queue_for_thread(t);
! log_error(gc, verify)(" Thread \"%s\" queue: %s",
! t->name(),
! queue.is_active() ? "ACTIVE" : "INACTIVE");
}
! } closure(this);
! Threads::threads_do(&closure);
}
void SATBMarkQueueSet::verify_active_states(bool expected_active) {
// Verify queue set state
if (is_active() != expected_active) {
dump_active_states(expected_active);
! fatal("SATB queue set has an unexpected active state");
}
// Verify thread queue states
! class VerifyThreadStatesClosure : public ThreadClosure {
! SATBMarkQueueSet* _qset;
! bool _expected_active;
! public:
! VerifyThreadStatesClosure(SATBMarkQueueSet* qset, bool expected_active) :
! _qset(qset), _expected_active(expected_active) {}
! virtual void do_thread(Thread* t) {
! if (_qset->satb_queue_for_thread(t).is_active() != _expected_active) {
! _qset->dump_active_states(_expected_active);
! fatal("Thread SATB queue has an unexpected active state");
}
}
! } closure(this, expected_active);
! Threads::threads_do(&closure);
}
#endif // ASSERT
void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
#ifdef ASSERT
verify_active_states(expected_active);
#endif // ASSERT
_all_active = active;
!
! class SetThreadActiveClosure : public ThreadClosure {
! SATBMarkQueueSet* _qset;
! bool _active;
! public:
! SetThreadActiveClosure(SATBMarkQueueSet* qset, bool active) :
! _qset(qset), _active(active) {}
! virtual void do_thread(Thread* t) {
! _qset->satb_queue_for_thread(t).set_active(_active);
}
! } closure(this, active);
! Threads::threads_do(&closure);
}
void SATBMarkQueueSet::filter_thread_buffers() {
! class FilterThreadBufferClosure : public ThreadClosure {
! SATBMarkQueueSet* _qset;
! public:
! FilterThreadBufferClosure(SATBMarkQueueSet* qset) : _qset(qset) {}
! virtual void do_thread(Thread* t) {
! _qset->satb_queue_for_thread(t).filter();
}
! } closure(this);
! Threads::threads_do(&closure);
}
bool SATBMarkQueueSet::apply_closure_to_completed_buffer(SATBBufferClosure* cl) {
BufferNode* nd = get_completed_buffer();
if (nd != NULL) {
*** 214,238 ****
print_satb_buffer(buffer, buf, nd->index(), buffer_size());
nd = nd->next();
i += 1;
}
! for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
! os::snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Thread: %s", t->name());
! satb_queue_for_thread(t).print(buffer);
}
!
! shared_satb_queue()->print("Shared");
tty->cr();
}
#endif // PRODUCT
void SATBMarkQueueSet::abandon_partial_marking() {
- abandon_completed_buffers();
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
! // So we can safely manipulate these queues.
! for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
! satb_queue_for_thread(t).reset();
}
! shared_satb_queue()->reset();
}
--- 232,269 ----
print_satb_buffer(buffer, buf, nd->index(), buffer_size());
nd = nd->next();
i += 1;
}
! class PrintThreadClosure : public ThreadClosure {
! SATBMarkQueueSet* _qset;
! char* _buffer;
!
! public:
! PrintThreadClosure(SATBMarkQueueSet* qset, char* buffer) :
! _qset(qset), _buffer(buffer) {}
!
! virtual void do_thread(Thread* t) {
! os::snprintf(_buffer, SATB_PRINTER_BUFFER_SIZE, "Thread: %s", t->name());
! _qset->satb_queue_for_thread(t).print(_buffer);
}
! } closure(this, buffer);
! Threads::threads_do(&closure);
tty->cr();
}
#endif // PRODUCT
void SATBMarkQueueSet::abandon_partial_marking() {
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
! abandon_completed_buffers();
!
! class AbandonThreadQueueClosure : public ThreadClosure {
! SATBMarkQueueSet* _qset;
! public:
! AbandonThreadQueueClosure(SATBMarkQueueSet* qset) : _qset(qset) {}
! virtual void do_thread(Thread* t) {
! _qset->satb_queue_for_thread(t).reset();
}
! } closure(this);
! Threads::threads_do(&closure);
}
< prev index next >