--- a/src/hotspot/share/gc/shared/ptrQueue.cpp	Thu Nov 15 17:55:41 2018 -0500
+++ b/src/hotspot/share/gc/shared/ptrQueue.cpp	Thu Nov 15 19:59:10 2018 -0500
@@ -26,6 +26,7 @@
 #include "gc/shared/ptrQueue.hpp"
 #include "memory/allocation.hpp"
 #include "memory/allocation.inline.hpp"
+#include "runtime/atomic.hpp"
 #include "runtime/mutex.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/thread.inline.hpp"
@@ -90,25 +91,92 @@
   FREE_C_HEAP_ARRAY(char, node);
 }
 
+BufferNode::Allocator::Allocator(size_t buffer_size, Mutex* lock) :
+  _buffer_size(buffer_size),
+  _lock(lock),
+  _free_list(NULL),
+  _free_count(0)
+{
+  assert(lock != NULL, "precondition");
+}
+
+BufferNode::Allocator::~Allocator() {
+  while (_free_list != NULL) {
+    BufferNode* node = _free_list;
+    _free_list = node->next();
+    BufferNode::deallocate(node);
+  }
+}
+
+size_t BufferNode::Allocator::free_count() const {
+  return Atomic::load(&_free_count);
+}
+
+BufferNode* BufferNode::Allocator::allocate() {
+  BufferNode* node = NULL;
+  {
+    MutexLockerEx ml(_lock, Mutex::_no_safepoint_check_flag);
+    node = _free_list;
+    if (node != NULL) {
+      _free_list = node->next();
+      --_free_count;
+      node->set_next(NULL);
+      node->set_index(0);
+      return node;
+    }
+  }
+  return  BufferNode::allocate(_buffer_size);
+}
+
+void BufferNode::Allocator::release(BufferNode* node) {
+  MutexLockerEx ml(_lock, Mutex::_no_safepoint_check_flag);
+  node->set_next(_free_list);
+  _free_list = node;
+  ++_free_count;
+}
+
+void BufferNode::Allocator::reduce_free_list() {
+  BufferNode* head = NULL;
+  {
+    MutexLockerEx ml(_lock, Mutex::_no_safepoint_check_flag);
+    // For now, delete half.
+    size_t remove = _free_count / 2;
+    if (remove > 0) {
+      head = _free_list;
+      BufferNode* tail = head;
+      BufferNode* prev = NULL;
+      for (size_t i = 0; i < remove; ++i) {
+        assert(tail != NULL, "free list size is wrong");
+        prev = tail;
+        tail = tail->next();
+      }
+      assert(prev != NULL, "invariant");
+      assert(prev->next() == tail, "invariant");
+      prev->set_next(NULL);
+      _free_list = tail;
+      _free_count -= remove;
+    }
+  }
+  while (head != NULL) {
+    BufferNode* next = head->next();
+    BufferNode::deallocate(head);
+    head = next;
+  }
+}
+
 PtrQueueSet::PtrQueueSet(bool notify_when_complete) :
-  _buffer_size(0),
+  _allocator(NULL),
   _cbl_mon(NULL),
   _completed_buffers_head(NULL),
   _completed_buffers_tail(NULL),
   _n_completed_buffers(0),
   _process_completed_threshold(0),
   _process_completed(false),
-  _fl_lock(NULL),
-  _buf_free_list(NULL),
-  _buf_free_list_sz(0),
-  _fl_owner(NULL),
   _all_active(false),
   _notify_when_complete(notify_when_complete),
   _max_completed_queue(0),
   _completed_queue_padding(0)
-{
-  _fl_owner = this;
-}
+{}
 
 PtrQueueSet::~PtrQueueSet() {
   // There are presently only a couple (derived) instances ever
@@ -117,59 +185,24 @@
 }
 
 void PtrQueueSet::initialize(Monitor* cbl_mon,
-                             Mutex* fl_lock,
+                             BufferNode::Allocator* allocator,
                              int process_completed_threshold,
-                             int max_completed_queue,
-                             PtrQueueSet *fl_owner) {
+                             int max_completed_queue) {
   _max_completed_queue = max_completed_queue;
   _process_completed_threshold = process_completed_threshold;
   _completed_queue_padding = 0;
-  assert(cbl_mon != NULL && fl_lock != NULL, "Init order issue?");
+  assert(cbl_mon != NULL && allocator != NULL, "Init order issue?");
   _cbl_mon = cbl_mon;
-  _fl_lock = fl_lock;
-  _fl_owner = (fl_owner != NULL) ? fl_owner : this;
+  _allocator = allocator;
 }
 
 void** PtrQueueSet::allocate_buffer() {
-  BufferNode* node = NULL;
-  {
-    MutexLockerEx x(_fl_owner->_fl_lock, Mutex::_no_safepoint_check_flag);
-    node = _fl_owner->_buf_free_list;
-    if (node != NULL) {
-      _fl_owner->_buf_free_list = node->next();
-      _fl_owner->_buf_free_list_sz--;
-    }
-  }
-  if (node == NULL) {
-    node = BufferNode::allocate(buffer_size());
-  } else {
-    // Reinitialize buffer obtained from free list.
-    node->set_index(0);
-    node->set_next(NULL);
-  }
+  BufferNode* node = _allocator->allocate();
   return BufferNode::make_buffer_from_node(node);
 }
 
 void PtrQueueSet::deallocate_buffer(BufferNode* node) {
-  MutexLockerEx x(_fl_owner->_fl_lock, Mutex::_no_safepoint_check_flag);
-  node->set_next(_fl_owner->_buf_free_list);
-  _fl_owner->_buf_free_list = node;
-  _fl_owner->_buf_free_list_sz++;
-}
-
-void PtrQueueSet::reduce_free_list() {
-  assert(_fl_owner == this, "Free list reduction is allowed only for the owner");
-  // For now we'll adopt the strategy of deleting half.
-  MutexLockerEx x(_fl_lock, Mutex::_no_safepoint_check_flag);
-  size_t n = _buf_free_list_sz / 2;
-  for (size_t i = 0; i < n; ++i) {
-    assert(_buf_free_list != NULL,
-           "_buf_free_list_sz is wrong: " SIZE_FORMAT, _buf_free_list_sz);
-    BufferNode* node = _buf_free_list;
-    _buf_free_list = node->next();
-    _buf_free_list_sz--;
-    BufferNode::deallocate(node);
-  }
+  _allocator->release(node);
 }
 
 void PtrQueue::handle_zero_index() {
@@ -270,11 +303,6 @@
             "Completed buffer length is wrong.");
 }
 
-void PtrQueueSet::set_buffer_size(size_t sz) {
-  assert(_buffer_size == 0 && sz > 0, "Should be called only once.");
-  _buffer_size = sz;
-}
-
 // Merge lists of buffers. Notify the processing threads.
 // The source queue is emptied as a result. The queues
 // must share the monitor.