1 /*

     2  * Copyright (c) 2017, 2018, Red Hat, Inc. All rights reserved.

     3  *

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

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

     6  * published by the Free Software Foundation.

     7  *

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

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

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

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

    12  * accompanied this code).

    13  *

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

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

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

    17  *

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

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

    20  * questions.

    21  *

    22  */

    23 

    24 #include "precompiled.hpp"

    25 

    26 #include "gc/shared/stringdedup/stringDedup.hpp"

    27 #include "gc/shared/stringdedup/stringDedupThread.hpp"

    28 #include "gc/shenandoah/shenandoahHeap.inline.hpp"

    29 #include "gc/shenandoah/shenandoahStrDedupQueue.hpp"

    30 #include "gc/shenandoah/shenandoahStrDedupQueue.inline.hpp"

    31 #include "gc/shenandoah/shenandoahStringDedup.hpp"

    32 #include "logging/log.hpp"

    33 #include "runtime/mutex.hpp"

    34 #include "runtime/mutexLocker.hpp"

    35 

    36 ShenandoahStrDedupQueue::ShenandoahStrDedupQueue() :

    37   _consumer_queue(NULL),

    38   _num_producer_queue(ShenandoahHeap::heap()->max_workers()),

    39   _published_queues(NULL),

    40   _free_list(NULL),

    41   _num_free_buffer(0),

    42   _max_free_buffer(ShenandoahHeap::heap()->max_workers() * 2),

    43   _cancel(false),

    44   _total_buffers(0) {

    45   _producer_queues = NEW_C_HEAP_ARRAY(ShenandoahQueueBuffer*, _num_producer_queue, mtGC);

    46   for (size_t index = 0; index < _num_producer_queue; index ++) {

    47     _producer_queues[index] = NULL;

    48   }

    49 }

    50 

    51 ShenandoahStrDedupQueue::~ShenandoahStrDedupQueue() {

    52   MonitorLockerEx ml(StringDedupQueue_lock, Mutex::_no_safepoint_check_flag);

    53   for (size_t index = 0; index < num_queues(); index ++) {

    54     release_buffers(queue_at(index));

    55   }

    56 

    57   release_buffers(_free_list);

    58   FREE_C_HEAP_ARRAY(ShenandoahQueueBuffer*, _producer_queues);

    59 }

    60 

    61 void ShenandoahStrDedupQueue::wait_impl() {

    62   MonitorLockerEx ml(StringDedupQueue_lock, Mutex::_no_safepoint_check_flag);

    63   while (_consumer_queue == NULL && !_cancel) {

    64     ml.wait(Mutex::_no_safepoint_check_flag);

    65     assert(_consumer_queue == NULL, "Why wait?");

    66     _consumer_queue = _published_queues;

    67     _published_queues = NULL;

    68   }

    69 }

    70 

    71 void ShenandoahStrDedupQueue::cancel_wait_impl() {

    72   MonitorLockerEx ml(StringDedupQueue_lock, Mutex::_no_safepoint_check_flag);

    73   _cancel = true;

    74   ml.notify();

    75 }

    76 

    77 void ShenandoahStrDedupQueue::unlink_or_oops_do_impl(StringDedupUnlinkOrOopsDoClosure* cl, size_t queue) {

    78   ShenandoahQueueBuffer* q = queue_at(queue);

    79   while (q != NULL) {

    80     q->unlink_or_oops_do(cl);

    81     q = q->next();

    82   }

    83 }

    84 

    85 ShenandoahQueueBuffer* ShenandoahStrDedupQueue::queue_at(size_t queue_id) const {

    86   assert(queue_id <= num_queues(), "Invalid queue id");

    87   if (queue_id < _num_producer_queue) {

    88     return _producer_queues[queue_id];

    89   } else if (queue_id == _num_producer_queue) {

    90     return _consumer_queue;

    91   } else {

    92     assert(queue_id == _num_producer_queue + 1, "Must be");

    93     return _published_queues;

    94   }

    95 }

    96 

    97 void ShenandoahStrDedupQueue::set_producer_buffer(ShenandoahQueueBuffer* buf, size_t queue_id) {

    98   assert(queue_id < _num_producer_queue, "Not a producer queue id");

    99   _producer_queues[queue_id] = buf;

   100 }

   101 

   102 void ShenandoahStrDedupQueue::push_impl(uint worker_id, oop string_oop) {

   103   assert(worker_id < _num_producer_queue, "Invalid queue id. Can only push to producer queue");

   104   assert(ShenandoahStringDedup::is_candidate(string_oop), "Not a candidate");

   105 

   106   ShenandoahQueueBuffer* buf = queue_at((size_t)worker_id);

   107 

   108   if (buf == NULL) {

   109     MonitorLockerEx ml(StringDedupQueue_lock, Mutex::_no_safepoint_check_flag);

   110     buf = new_buffer();

   111     set_producer_buffer(buf, worker_id);

   112   } else if (buf->is_full()) {

   113     MonitorLockerEx ml(StringDedupQueue_lock, Mutex::_no_safepoint_check_flag);

   114     buf->set_next(_published_queues);

   115     _published_queues = buf;

   116     buf = new_buffer();

   117     set_producer_buffer(buf, worker_id);

   118     ml.notify();

   119   }

   120 

   121   assert(!buf->is_full(), "Sanity");

   122   buf->push(string_oop);

   123 }

   124 

   125 oop ShenandoahStrDedupQueue::pop_impl() {

   126   assert(Thread::current() == StringDedupThread::thread(), "Must be dedup thread");

   127   while (true) {

   128     if (_consumer_queue == NULL) {

   129       MonitorLockerEx ml(StringDedupQueue_lock, Mutex::_no_safepoint_check_flag);

   130       _consumer_queue = _published_queues;

   131       _published_queues = NULL;

   132     }

   133 

   134     // there is nothing

   135     if (_consumer_queue == NULL) {

   136       return NULL;

   137     }

   138 

   139     oop obj = NULL;

   140     if (pop_candidate(obj)) {

   141       assert(ShenandoahStringDedup::is_candidate(obj), "Must be a candidate");

   142       return obj;

   143     }

   144     assert(obj == NULL, "No more candidate");

   145   }

   146 }

   147 

   148 bool ShenandoahStrDedupQueue::pop_candidate(oop& obj) {

   149   ShenandoahQueueBuffer* to_release = NULL;

   150   bool suc = true;

   151   do {

   152     if (_consumer_queue->is_empty()) {

   153       ShenandoahQueueBuffer* buf = _consumer_queue;

   154       _consumer_queue = _consumer_queue->next();

   155       buf->set_next(to_release);

   156       to_release = buf;

   157 

   158       if (_consumer_queue == NULL) {

   159         suc = false;

   160         break;

   161       }

   162     }

   163     obj = _consumer_queue->pop();

   164   } while (obj == NULL);

   165 

   166   if (to_release != NULL) {

   167     MonitorLockerEx ml(StringDedupQueue_lock, Mutex::_no_safepoint_check_flag);

   168     release_buffers(to_release);

   169   }

   170 

   171   return suc;

   172 }

   173 

   174 ShenandoahQueueBuffer* ShenandoahStrDedupQueue::new_buffer() {

   175   assert_lock_strong(StringDedupQueue_lock);

   176   if (_free_list != NULL) {

   177     assert(_num_free_buffer > 0, "Sanity");

   178     ShenandoahQueueBuffer* buf = _free_list;

   179     _free_list = _free_list->next();

   180     _num_free_buffer --;

   181     buf->reset();

   182     return buf;

   183   } else {

   184     assert(_num_free_buffer == 0, "Sanity");

   185     _total_buffers ++;

   186     return new ShenandoahQueueBuffer;

   187   }

   188 }

   189 

   190 void ShenandoahStrDedupQueue::release_buffers(ShenandoahQueueBuffer* list) {

   191   assert_lock_strong(StringDedupQueue_lock);

   192   while (list != NULL) {

   193     ShenandoahQueueBuffer* tmp = list;

   194     list = list->next();

   195     if (_num_free_buffer < _max_free_buffer) {

   196       tmp->set_next(_free_list);

   197       _free_list = tmp;

   198       _num_free_buffer ++;

   199     } else {

   200       _total_buffers --;

   201       delete tmp;

   202     }

   203   }

   204 }

   205 

   206 void ShenandoahStrDedupQueue::print_statistics_impl() {

   207   Log(gc, stringdedup) log;

   208   log.debug("  Queue:");

   209   log.debug("    Total buffers: " SIZE_FORMAT " (" SIZE_FORMAT " K). " SIZE_FORMAT " buffers are on free list",

   210     _total_buffers, (_total_buffers * sizeof(ShenandoahQueueBuffer) / K), _num_free_buffer);

   211 }

   212 

   213 class VerifyQueueClosure : public OopClosure {

   214 private:

   215   ShenandoahHeap* _heap;

   216 public:

   217   VerifyQueueClosure();

   218 

   219   void do_oop(oop* o);

   220   void do_oop(narrowOop* o) {

   221     ShouldNotCallThis();

   222   }

   223 };

   224 

   225 VerifyQueueClosure::VerifyQueueClosure() :

   226   _heap(ShenandoahHeap::heap()) {

   227 }

   228 

   229 void VerifyQueueClosure::do_oop(oop* o) {

   230   if (*o != NULL) {

   231     oop obj = *o;

   232     shenandoah_assert_correct(o, obj);

   233     assert(java_lang_String::is_instance(obj), "Object must be a String");

   234   }

   235 }

   236 

   237 void ShenandoahStrDedupQueue::verify_impl() {

   238   VerifyQueueClosure vcl;

   239   for (size_t index = 0; index < num_queues(); index ++) {

   240     ShenandoahQueueBuffer* buf = queue_at(index);

   241     while (buf != NULL) {

   242       buf->oops_do(&vcl);

   243       buf = buf->next();

   244     }

   245   }

   246 }