--- a/src/hotspot/share/gc/g1/g1DirtyCardQueue.cpp Fri Aug 30 00:03:10 2019 +0200
+++ b/src/hotspot/share/gc/g1/g1DirtyCardQueue.cpp Thu Aug 29 18:35:52 2019 -0400
@@ -85,12 +85,12 @@
_cbl_mon(NULL),
_completed_buffers_head(NULL),
_completed_buffers_tail(NULL),
- _num_entries_in_completed_buffers(0),
- _process_completed_buffers_threshold(ProcessCompletedBuffersThresholdNever),
+ _num_cards(0),
+ _process_cards_threshold(ProcessCardsThresholdNever),
_process_completed_buffers(false),
_notify_when_complete(notify_when_complete),
- _max_completed_buffers(MaxCompletedBuffersUnlimited),
- _completed_buffers_padding(0),
+ _max_cards(MaxCardsUnlimited),
+ _max_cards_padding(0),
_free_ids(NULL),
_processed_buffers_mut(0),
_processed_buffers_rs_thread(0)
@@ -134,53 +134,53 @@
_completed_buffers_tail->set_next(cbn);
_completed_buffers_tail = cbn;
}
- _num_entries_in_completed_buffers += buffer_size() - cbn->index();
+ _num_cards += buffer_size() - cbn->index();
if (!process_completed_buffers() &&
- (num_completed_buffers() > process_completed_buffers_threshold())) {
+ (num_cards() > process_cards_threshold())) {
set_process_completed_buffers(true);
if (_notify_when_complete) {
_cbl_mon->notify_all();
}
}
- verify_num_entries_in_completed_buffers();
+ verify_num_cards();
}
BufferNode* G1DirtyCardQueueSet::get_completed_buffer(size_t stop_at) {
MutexLocker x(_cbl_mon, Mutex::_no_safepoint_check_flag);
- if (num_completed_buffers() <= stop_at) {
+ if (num_cards() <= stop_at) {
return NULL;
}
- assert(num_completed_buffers() > 0, "invariant");
+ assert(num_cards() > 0, "invariant");
assert(_completed_buffers_head != NULL, "invariant");
assert(_completed_buffers_tail != NULL, "invariant");
BufferNode* bn = _completed_buffers_head;
- _num_entries_in_completed_buffers -= buffer_size() - bn->index();
+ _num_cards -= buffer_size() - bn->index();
_completed_buffers_head = bn->next();
if (_completed_buffers_head == NULL) {
- assert(num_completed_buffers() == 0, "invariant");
+ assert(num_cards() == 0, "invariant");
_completed_buffers_tail = NULL;
set_process_completed_buffers(false);
}
- verify_num_entries_in_completed_buffers();
+ verify_num_cards();
bn->set_next(NULL);
return bn;
}
#ifdef ASSERT
-void G1DirtyCardQueueSet::verify_num_entries_in_completed_buffers() const {
+void G1DirtyCardQueueSet::verify_num_cards() const {
size_t actual = 0;
BufferNode* cur = _completed_buffers_head;
while (cur != NULL) {
actual += buffer_size() - cur->index();
cur = cur->next();
}
- assert(actual == _num_entries_in_completed_buffers,
+ assert(actual == _num_cards,
"Num entries in completed buffers should be " SIZE_FORMAT " but are " SIZE_FORMAT,
- _num_entries_in_completed_buffers, actual);
+ _num_cards, actual);
}
#endif
@@ -191,7 +191,7 @@
buffers_to_delete = _completed_buffers_head;
_completed_buffers_head = NULL;
_completed_buffers_tail = NULL;
- _num_entries_in_completed_buffers = 0;
+ _num_cards = 0;
set_process_completed_buffers(false);
}
while (buffers_to_delete != NULL) {
@@ -204,7 +204,7 @@
void G1DirtyCardQueueSet::notify_if_necessary() {
MutexLocker x(_cbl_mon, Mutex::_no_safepoint_check_flag);
- if (num_completed_buffers() > process_completed_buffers_threshold()) {
+ if (num_cards() > process_cards_threshold()) {
set_process_completed_buffers(true);
if (_notify_when_complete)
_cbl_mon->notify();
@@ -229,12 +229,12 @@
_completed_buffers_tail->set_next(from._head);
_completed_buffers_tail = from._tail;
}
- _num_entries_in_completed_buffers += from._entry_count;
+ _num_cards += from._entry_count;
assert(_completed_buffers_head == NULL && _completed_buffers_tail == NULL ||
_completed_buffers_head != NULL && _completed_buffers_tail != NULL,
"Sanity");
- verify_num_entries_in_completed_buffers();
+ verify_num_cards();
}
bool G1DirtyCardQueueSet::apply_closure_to_buffer(G1CardTableEntryClosure* cl,
@@ -278,9 +278,8 @@
// thread do the processing itself. We don't lock to access
// buffer count or padding; it is fine to be imprecise here. The
// add of padding could overflow, which is treated as unlimited.
- size_t max_buffers = max_completed_buffers();
- size_t limit = max_buffers + completed_buffers_padding();
- if ((num_completed_buffers() > limit) && (limit >= max_buffers)) {
+ size_t limit = max_cards() + max_cards_padding();
+ if ((num_cards() > limit) && (limit >= max_cards())) {
if (mut_process_buffer(node)) {
return true;
}
@@ -359,8 +358,8 @@
// the global list of logs. Temporarily turn off the limit on the number
// of outstanding buffers.
assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
- size_t old_limit = max_completed_buffers();
- set_max_completed_buffers(MaxCompletedBuffersUnlimited);
+ size_t old_limit = max_cards();
+ set_max_cards(MaxCardsUnlimited);
struct ConcatenateThreadLogClosure : public ThreadClosure {
virtual void do_thread(Thread* t) {
@@ -373,5 +372,5 @@
Threads::threads_do(&closure);
G1BarrierSet::shared_dirty_card_queue().flush();
- set_max_completed_buffers(old_limit);
+ set_max_cards(old_limit);
}