--- old/src/hotspot/share/gc/g1/g1DirtyCardQueue.cpp	2019-08-23 19:41:56.835472018 -0400
+++ new/src/hotspot/share/gc/g1/g1DirtyCardQueue.cpp	2019-08-23 19:41:56.627460836 -0400
@@ -84,12 +84,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)
@@ -133,53 +133,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
 
@@ -190,7 +190,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) {
@@ -203,7 +203,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();
@@ -228,12 +228,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,
@@ -277,9 +277,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;
       }
@@ -358,8 +357,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) {
@@ -372,5 +371,5 @@
   Threads::threads_do(&closure);
 
   G1BarrierSet::shared_dirty_card_queue().flush();
-  set_max_completed_buffers(old_limit);
+  set_max_cards(old_limit);
 }