1 /*

     2  * Copyright (c) 2001, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #include "precompiled.hpp"

    26 #include "gc/shared/ptrQueue.hpp"

    27 #include "memory/allocation.hpp"

    28 #include "memory/allocation.inline.hpp"

    29 #include "runtime/mutex.hpp"

    30 #include "runtime/mutexLocker.hpp"

    31 #include "runtime/thread.inline.hpp"

    32 

    33 #include <new>

    34 

    35 PtrQueue::PtrQueue(PtrQueueSet* qset, bool permanent, bool active) :

    36   _qset(qset),

    37   _active(active),

    38   _permanent(permanent),

    39   _index(0),

    40   _capacity_in_bytes(0),

    41   _buf(NULL),

    42   _lock(NULL)

    43 {}

    44 

    45 PtrQueue::~PtrQueue() {

    46   assert(_permanent || (_buf == NULL), "queue must be flushed before delete");

    47 }

    48 

    49 void PtrQueue::flush_impl() {

    50   if (_buf != NULL) {

    51     BufferNode* node = BufferNode::make_node_from_buffer(_buf, index());

    52     if (is_empty()) {

    53       // No work to do.

    54       qset()->deallocate_buffer(node);

    55     } else {

    56       qset()->enqueue_complete_buffer(node);

    57     }

    58     _buf = NULL;

    59     set_index(0);

    60   }

    61 }

    62 

    63 

    64 void PtrQueue::enqueue_known_active(void* ptr) {

    65   while (_index == 0) {

    66     handle_zero_index();

    67   }

    68 

    69   assert(_buf != NULL, "postcondition");

    70   assert(index() > 0, "postcondition");

    71   assert(index() <= capacity(), "invariant");

    72   _index -= _element_size;

    73   _buf[index()] = ptr;

    74 }

    75 

    76 void PtrQueue::locking_enqueue_completed_buffer(BufferNode* node) {

    77   assert(_lock->owned_by_self(), "Required.");

    78   qset()->enqueue_complete_buffer(node);

    79 }

    80 

    81 

    82 BufferNode* BufferNode::allocate(size_t size) {

    83   size_t byte_size = size * sizeof(void*);

    84   void* data = NEW_C_HEAP_ARRAY(char, buffer_offset() + byte_size, mtGC);

    85   return new (data) BufferNode;

    86 }

    87 

    88 void BufferNode::deallocate(BufferNode* node) {

    89   node->~BufferNode();

    90   FREE_C_HEAP_ARRAY(char, node);

    91 }

    92 

    93 PtrQueueSet::PtrQueueSet(bool notify_when_complete) :

    94   _buffer_size(0),

    95   _cbl_mon(NULL),

    96   _completed_buffers_head(NULL),

    97   _completed_buffers_tail(NULL),

    98   _n_completed_buffers(0),

    99   _process_completed_threshold(0),

   100   _process_completed(false),

   101   _fl_lock(NULL),

   102   _buf_free_list(NULL),

   103   _buf_free_list_sz(0),

   104   _fl_owner(NULL),

   105   _all_active(false),

   106   _notify_when_complete(notify_when_complete),

   107   _max_completed_queue(0),

   108   _completed_queue_padding(0)

   109 {

   110   _fl_owner = this;

   111 }

   112 

   113 PtrQueueSet::~PtrQueueSet() {

   114   // There are presently only a couple (derived) instances ever

   115   // created, and they are permanent, so no harm currently done by

   116   // doing nothing here.

   117 }

   118 

   119 void PtrQueueSet::initialize(Monitor* cbl_mon,

   120                              Mutex* fl_lock,

   121                              int process_completed_threshold,

   122                              int max_completed_queue,

   123                              PtrQueueSet *fl_owner) {

   124   _max_completed_queue = max_completed_queue;

   125   _process_completed_threshold = process_completed_threshold;

   126   _completed_queue_padding = 0;

   127   assert(cbl_mon != NULL && fl_lock != NULL, "Init order issue?");

   128   _cbl_mon = cbl_mon;

   129   _fl_lock = fl_lock;

   130   _fl_owner = (fl_owner != NULL) ? fl_owner : this;

   131 }

   132 

   133 void** PtrQueueSet::allocate_buffer() {

   134   BufferNode* node = NULL;

   135   {

   136     MutexLockerEx x(_fl_owner->_fl_lock, Mutex::_no_safepoint_check_flag);

   137     node = _fl_owner->_buf_free_list;

   138     if (node != NULL) {

   139       _fl_owner->_buf_free_list = node->next();

   140       _fl_owner->_buf_free_list_sz--;

   141     }

   142   }

   143   if (node == NULL) {

   144     node = BufferNode::allocate(buffer_size());

   145   } else {

   146     // Reinitialize buffer obtained from free list.

   147     node->set_index(0);

   148     node->set_next(NULL);

   149   }

   150   return BufferNode::make_buffer_from_node(node);

   151 }

   152 

   153 void PtrQueueSet::deallocate_buffer(BufferNode* node) {

   154   MutexLockerEx x(_fl_owner->_fl_lock, Mutex::_no_safepoint_check_flag);

   155   node->set_next(_fl_owner->_buf_free_list);

   156   _fl_owner->_buf_free_list = node;

   157   _fl_owner->_buf_free_list_sz++;

   158 }

   159 

   160 void PtrQueueSet::reduce_free_list() {

   161   assert(_fl_owner == this, "Free list reduction is allowed only for the owner");

   162   // For now we'll adopt the strategy of deleting half.

   163   MutexLockerEx x(_fl_lock, Mutex::_no_safepoint_check_flag);

   164   size_t n = _buf_free_list_sz / 2;

   165   for (size_t i = 0; i < n; ++i) {

   166     assert(_buf_free_list != NULL,

   167            "_buf_free_list_sz is wrong: " SIZE_FORMAT, _buf_free_list_sz);

   168     BufferNode* node = _buf_free_list;

   169     _buf_free_list = node->next();

   170     _buf_free_list_sz--;

   171     BufferNode::deallocate(node);

   172   }

   173 }

   174 

   175 void PtrQueue::handle_zero_index() {

   176   assert(index() == 0, "precondition");

   177 

   178   // This thread records the full buffer and allocates a new one (while

   179   // holding the lock if there is one).

   180   if (_buf != NULL) {

   181     if (!should_enqueue_buffer()) {

   182       assert(index() > 0, "the buffer can only be re-used if it's not full");

   183       return;

   184     }

   185 

   186     if (_lock) {

   187       assert(_lock->owned_by_self(), "Required.");

   188 

   189       BufferNode* node = BufferNode::make_node_from_buffer(_buf, index());

   190       _buf = NULL;         // clear shared _buf field

   191 

   192       locking_enqueue_completed_buffer(node); // enqueue completed buffer

   193       assert(_buf == NULL, "multiple enqueuers appear to be racing");

   194     } else {

   195       BufferNode* node = BufferNode::make_node_from_buffer(_buf, index());

   196       if (qset()->process_or_enqueue_complete_buffer(node)) {

   197         // Recycle the buffer. No allocation.

   198         assert(_buf == BufferNode::make_buffer_from_node(node), "invariant");

   199         assert(capacity() == qset()->buffer_size(), "invariant");

   200         reset();

   201         return;

   202       }

   203     }

   204   }

   205   // Set capacity in case this is the first allocation.

   206   set_capacity(qset()->buffer_size());

   207   // Allocate a new buffer.

   208   _buf = qset()->allocate_buffer();

   209   reset();

   210 }

   211 

   212 bool PtrQueueSet::process_or_enqueue_complete_buffer(BufferNode* node) {

   213   if (Thread::current()->is_Java_thread()) {

   214     // We don't lock. It is fine to be epsilon-precise here.

   215     if (_max_completed_queue == 0 ||

   216         (_max_completed_queue > 0 &&

   217           _n_completed_buffers >= _max_completed_queue + _completed_queue_padding)) {

   218       bool b = mut_process_buffer(node);

   219       if (b) {

   220         // True here means that the buffer hasn't been deallocated and the caller may reuse it.

   221         return true;

   222       }

   223     }

   224   }

   225   // The buffer will be enqueued. The caller will have to get a new one.

   226   enqueue_complete_buffer(node);

   227   return false;

   228 }

   229 

   230 void PtrQueueSet::enqueue_complete_buffer(BufferNode* cbn) {

   231   MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);

   232   cbn->set_next(NULL);

   233   if (_completed_buffers_tail == NULL) {

   234     assert(_completed_buffers_head == NULL, "Well-formedness");

   235     _completed_buffers_head = cbn;

   236     _completed_buffers_tail = cbn;

   237   } else {

   238     _completed_buffers_tail->set_next(cbn);

   239     _completed_buffers_tail = cbn;

   240   }

   241   _n_completed_buffers++;

   242 

   243   if (!_process_completed && _process_completed_threshold >= 0 &&

   244       _n_completed_buffers >= (size_t)_process_completed_threshold) {

   245     _process_completed = true;

   246     if (_notify_when_complete) {

   247       _cbl_mon->notify();

   248     }

   249   }

   250   DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());

   251 }

   252 

   253 size_t PtrQueueSet::completed_buffers_list_length() {

   254   size_t n = 0;

   255   BufferNode* cbn = _completed_buffers_head;

   256   while (cbn != NULL) {

   257     n++;

   258     cbn = cbn->next();

   259   }

   260   return n;

   261 }

   262 

   263 void PtrQueueSet::assert_completed_buffer_list_len_correct() {

   264   MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);

   265   assert_completed_buffer_list_len_correct_locked();

   266 }

   267 

   268 void PtrQueueSet::assert_completed_buffer_list_len_correct_locked() {

   269   guarantee(completed_buffers_list_length() ==  _n_completed_buffers,

   270             "Completed buffer length is wrong.");

   271 }

   272 

   273 void PtrQueueSet::set_buffer_size(size_t sz) {

   274   assert(_buffer_size == 0 && sz > 0, "Should be called only once.");

   275   _buffer_size = sz;

   276 }

   277 

   278 // Merge lists of buffers. Notify the processing threads.

   279 // The source queue is emptied as a result. The queues

   280 // must share the monitor.

   281 void PtrQueueSet::merge_bufferlists(PtrQueueSet *src) {

   282   assert(_cbl_mon == src->_cbl_mon, "Should share the same lock");

   283   MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);

   284   if (_completed_buffers_tail == NULL) {

   285     assert(_completed_buffers_head == NULL, "Well-formedness");

   286     _completed_buffers_head = src->_completed_buffers_head;

   287     _completed_buffers_tail = src->_completed_buffers_tail;

   288   } else {

   289     assert(_completed_buffers_head != NULL, "Well formedness");

   290     if (src->_completed_buffers_head != NULL) {

   291       _completed_buffers_tail->set_next(src->_completed_buffers_head);

   292       _completed_buffers_tail = src->_completed_buffers_tail;

   293     }

   294   }

   295   _n_completed_buffers += src->_n_completed_buffers;

   296 

   297   src->_n_completed_buffers = 0;

   298   src->_completed_buffers_head = NULL;

   299   src->_completed_buffers_tail = NULL;

   300 

   301   assert(_completed_buffers_head == NULL && _completed_buffers_tail == NULL ||

   302          _completed_buffers_head != NULL && _completed_buffers_tail != NULL,

   303          "Sanity");

   304 }

   305 

   306 void PtrQueueSet::notify_if_necessary() {

   307   MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);

   308   assert(_process_completed_threshold >= 0, "_process_completed is negative");

   309   if (_n_completed_buffers >= (size_t)_process_completed_threshold || _max_completed_queue == 0) {

   310     _process_completed = true;

   311     if (_notify_when_complete)

   312       _cbl_mon->notify();

   313   }

   314 }