< prev index next >

src/hotspot/share/gc/g1/satbMarkQueue.cpp

Print this page
rev 47862 : imported patch 10.07.open.rebase_20171110.dcubed


  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 "jvm.h"
  27 #include "gc/g1/g1CollectedHeap.inline.hpp"
  28 #include "gc/g1/satbMarkQueue.hpp"
  29 #include "gc/shared/collectedHeap.hpp"
  30 #include "memory/allocation.inline.hpp"
  31 #include "oops/oop.inline.hpp"
  32 #include "runtime/mutexLocker.hpp"
  33 #include "runtime/safepoint.hpp"
  34 #include "runtime/thread.hpp"

  35 #include "runtime/vmThread.hpp"
  36 
  37 SATBMarkQueue::SATBMarkQueue(SATBMarkQueueSet* qset, bool permanent) :
  38   // SATB queues are only active during marking cycles. We create
  39   // them with their active field set to false. If a thread is
  40   // created during a cycle and its SATB queue needs to be activated
  41   // before the thread starts running, we'll need to set its active
  42   // field to true. This is done in JavaThread::initialize_queues().
  43   PtrQueue(qset, permanent, false /* active */)
  44 { }
  45 
  46 void SATBMarkQueue::flush() {
  47   // Filter now to possibly save work later.  If filtering empties the
  48   // buffer then flush_impl can deallocate the buffer.
  49   filter();
  50   flush_impl();
  51 }
  52 
  53 // Return true if a SATB buffer entry refers to an object that
  54 // requires marking.


 197 SATBMarkQueueSet::SATBMarkQueueSet() :
 198   PtrQueueSet(),
 199   _shared_satb_queue(this, true /* permanent */) { }
 200 
 201 void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock,
 202                                   int process_completed_threshold,
 203                                   Mutex* lock) {
 204   PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1);
 205   _shared_satb_queue.set_lock(lock);
 206 }
 207 
 208 void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) {
 209   t->satb_mark_queue().handle_zero_index();
 210 }
 211 
 212 #ifdef ASSERT
 213 void SATBMarkQueueSet::dump_active_states(bool expected_active) {
 214   log_error(gc, verify)("Expected SATB active state: %s", expected_active ? "ACTIVE" : "INACTIVE");
 215   log_error(gc, verify)("Actual SATB active states:");
 216   log_error(gc, verify)("  Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
 217   for (JavaThread* t = Threads::first(); t; t = t->next()) {
 218     log_error(gc, verify)("  Thread \"%s\" queue: %s", t->name(), t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE");
 219   }
 220   log_error(gc, verify)("  Shared queue: %s", shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE");
 221 }
 222 
 223 void SATBMarkQueueSet::verify_active_states(bool expected_active) {
 224   // Verify queue set state
 225   if (is_active() != expected_active) {
 226     dump_active_states(expected_active);
 227     guarantee(false, "SATB queue set has an unexpected active state");
 228   }
 229 
 230   // Verify thread queue states
 231   for (JavaThread* t = Threads::first(); t; t = t->next()) {
 232     if (t->satb_mark_queue().is_active() != expected_active) {
 233       dump_active_states(expected_active);
 234       guarantee(false, "Thread SATB queue has an unexpected active state");
 235     }
 236   }
 237 
 238   // Verify shared queue state
 239   if (shared_satb_queue()->is_active() != expected_active) {
 240     dump_active_states(expected_active);
 241     guarantee(false, "Shared SATB queue has an unexpected active state");
 242   }
 243 }
 244 #endif // ASSERT
 245 
 246 void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
 247   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
 248 #ifdef ASSERT
 249   verify_active_states(expected_active);
 250 #endif // ASSERT
 251   _all_active = active;
 252   for (JavaThread* t = Threads::first(); t; t = t->next()) {
 253     t->satb_mark_queue().set_active(active);
 254   }
 255   shared_satb_queue()->set_active(active);
 256 }
 257 
 258 void SATBMarkQueueSet::filter_thread_buffers() {
 259   for(JavaThread* t = Threads::first(); t; t = t->next()) {
 260     t->satb_mark_queue().filter();
 261   }
 262   shared_satb_queue()->filter();
 263 }
 264 
 265 bool SATBMarkQueueSet::apply_closure_to_completed_buffer(SATBBufferClosure* cl) {
 266   BufferNode* nd = NULL;
 267   {
 268     MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
 269     if (_completed_buffers_head != NULL) {
 270       nd = _completed_buffers_head;
 271       _completed_buffers_head = nd->next();
 272       if (_completed_buffers_head == NULL) _completed_buffers_tail = NULL;
 273       _n_completed_buffers--;
 274       if (_n_completed_buffers == 0) _process_completed = false;
 275     }
 276   }
 277   if (nd != NULL) {
 278     void **buf = BufferNode::make_buffer_from_node(nd);
 279     size_t index = nd->index();


 292 
 293 #define SATB_PRINTER_BUFFER_SIZE 256
 294 
 295 void SATBMarkQueueSet::print_all(const char* msg) {
 296   char buffer[SATB_PRINTER_BUFFER_SIZE];
 297   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
 298 
 299   tty->cr();
 300   tty->print_cr("SATB BUFFERS [%s]", msg);
 301 
 302   BufferNode* nd = _completed_buffers_head;
 303   int i = 0;
 304   while (nd != NULL) {
 305     void** buf = BufferNode::make_buffer_from_node(nd);
 306     jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Enqueued: %d", i);
 307     print_satb_buffer(buffer, buf, nd->index(), buffer_size());
 308     nd = nd->next();
 309     i += 1;
 310   }
 311 
 312   for (JavaThread* t = Threads::first(); t; t = t->next()) {
 313     jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Thread: %s", t->name());
 314     t->satb_mark_queue().print(buffer);
 315   }
 316 
 317   shared_satb_queue()->print("Shared");
 318 
 319   tty->cr();
 320 }
 321 #endif // PRODUCT
 322 
 323 void SATBMarkQueueSet::abandon_partial_marking() {
 324   BufferNode* buffers_to_delete = NULL;
 325   {
 326     MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
 327     while (_completed_buffers_head != NULL) {
 328       BufferNode* nd = _completed_buffers_head;
 329       _completed_buffers_head = nd->next();
 330       nd->set_next(buffers_to_delete);
 331       buffers_to_delete = nd;
 332     }
 333     _completed_buffers_tail = NULL;
 334     _n_completed_buffers = 0;
 335     DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
 336   }
 337   while (buffers_to_delete != NULL) {
 338     BufferNode* nd = buffers_to_delete;
 339     buffers_to_delete = nd->next();
 340     deallocate_buffer(nd);
 341   }
 342   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
 343   // So we can safely manipulate these queues.
 344   for (JavaThread* t = Threads::first(); t; t = t->next()) {
 345     t->satb_mark_queue().reset();
 346   }
 347  shared_satb_queue()->reset();
 348 }


  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 "jvm.h"
  27 #include "gc/g1/g1CollectedHeap.inline.hpp"
  28 #include "gc/g1/satbMarkQueue.hpp"
  29 #include "gc/shared/collectedHeap.hpp"
  30 #include "memory/allocation.inline.hpp"
  31 #include "oops/oop.inline.hpp"
  32 #include "runtime/mutexLocker.hpp"
  33 #include "runtime/safepoint.hpp"
  34 #include "runtime/thread.hpp"
  35 #include "runtime/threadSMR.hpp"
  36 #include "runtime/vmThread.hpp"
  37 
  38 SATBMarkQueue::SATBMarkQueue(SATBMarkQueueSet* qset, bool permanent) :
  39   // SATB queues are only active during marking cycles. We create
  40   // them with their active field set to false. If a thread is
  41   // created during a cycle and its SATB queue needs to be activated
  42   // before the thread starts running, we'll need to set its active
  43   // field to true. This is done in JavaThread::initialize_queues().
  44   PtrQueue(qset, permanent, false /* active */)
  45 { }
  46 
  47 void SATBMarkQueue::flush() {
  48   // Filter now to possibly save work later.  If filtering empties the
  49   // buffer then flush_impl can deallocate the buffer.
  50   filter();
  51   flush_impl();
  52 }
  53 
  54 // Return true if a SATB buffer entry refers to an object that
  55 // requires marking.


 198 SATBMarkQueueSet::SATBMarkQueueSet() :
 199   PtrQueueSet(),
 200   _shared_satb_queue(this, true /* permanent */) { }
 201 
 202 void SATBMarkQueueSet::initialize(Monitor* cbl_mon, Mutex* fl_lock,
 203                                   int process_completed_threshold,
 204                                   Mutex* lock) {
 205   PtrQueueSet::initialize(cbl_mon, fl_lock, process_completed_threshold, -1);
 206   _shared_satb_queue.set_lock(lock);
 207 }
 208 
 209 void SATBMarkQueueSet::handle_zero_index_for_thread(JavaThread* t) {
 210   t->satb_mark_queue().handle_zero_index();
 211 }
 212 
 213 #ifdef ASSERT
 214 void SATBMarkQueueSet::dump_active_states(bool expected_active) {
 215   log_error(gc, verify)("Expected SATB active state: %s", expected_active ? "ACTIVE" : "INACTIVE");
 216   log_error(gc, verify)("Actual SATB active states:");
 217   log_error(gc, verify)("  Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
 218   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 219     log_error(gc, verify)("  Thread \"%s\" queue: %s", t->name(), t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE");
 220   }
 221   log_error(gc, verify)("  Shared queue: %s", shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE");
 222 }
 223 
 224 void SATBMarkQueueSet::verify_active_states(bool expected_active) {
 225   // Verify queue set state
 226   if (is_active() != expected_active) {
 227     dump_active_states(expected_active);
 228     guarantee(false, "SATB queue set has an unexpected active state");
 229   }
 230 
 231   // Verify thread queue states
 232   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 233     if (t->satb_mark_queue().is_active() != expected_active) {
 234       dump_active_states(expected_active);
 235       guarantee(false, "Thread SATB queue has an unexpected active state");
 236     }
 237   }
 238 
 239   // Verify shared queue state
 240   if (shared_satb_queue()->is_active() != expected_active) {
 241     dump_active_states(expected_active);
 242     guarantee(false, "Shared SATB queue has an unexpected active state");
 243   }
 244 }
 245 #endif // ASSERT
 246 
 247 void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
 248   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
 249 #ifdef ASSERT
 250   verify_active_states(expected_active);
 251 #endif // ASSERT
 252   _all_active = active;
 253   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 254     t->satb_mark_queue().set_active(active);
 255   }
 256   shared_satb_queue()->set_active(active);
 257 }
 258 
 259 void SATBMarkQueueSet::filter_thread_buffers() {
 260   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 261     t->satb_mark_queue().filter();
 262   }
 263   shared_satb_queue()->filter();
 264 }
 265 
 266 bool SATBMarkQueueSet::apply_closure_to_completed_buffer(SATBBufferClosure* cl) {
 267   BufferNode* nd = NULL;
 268   {
 269     MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
 270     if (_completed_buffers_head != NULL) {
 271       nd = _completed_buffers_head;
 272       _completed_buffers_head = nd->next();
 273       if (_completed_buffers_head == NULL) _completed_buffers_tail = NULL;
 274       _n_completed_buffers--;
 275       if (_n_completed_buffers == 0) _process_completed = false;
 276     }
 277   }
 278   if (nd != NULL) {
 279     void **buf = BufferNode::make_buffer_from_node(nd);
 280     size_t index = nd->index();


 293 
 294 #define SATB_PRINTER_BUFFER_SIZE 256
 295 
 296 void SATBMarkQueueSet::print_all(const char* msg) {
 297   char buffer[SATB_PRINTER_BUFFER_SIZE];
 298   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
 299 
 300   tty->cr();
 301   tty->print_cr("SATB BUFFERS [%s]", msg);
 302 
 303   BufferNode* nd = _completed_buffers_head;
 304   int i = 0;
 305   while (nd != NULL) {
 306     void** buf = BufferNode::make_buffer_from_node(nd);
 307     jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Enqueued: %d", i);
 308     print_satb_buffer(buffer, buf, nd->index(), buffer_size());
 309     nd = nd->next();
 310     i += 1;
 311   }
 312 
 313   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 314     jio_snprintf(buffer, SATB_PRINTER_BUFFER_SIZE, "Thread: %s", t->name());
 315     t->satb_mark_queue().print(buffer);
 316   }
 317 
 318   shared_satb_queue()->print("Shared");
 319 
 320   tty->cr();
 321 }
 322 #endif // PRODUCT
 323 
 324 void SATBMarkQueueSet::abandon_partial_marking() {
 325   BufferNode* buffers_to_delete = NULL;
 326   {
 327     MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
 328     while (_completed_buffers_head != NULL) {
 329       BufferNode* nd = _completed_buffers_head;
 330       _completed_buffers_head = nd->next();
 331       nd->set_next(buffers_to_delete);
 332       buffers_to_delete = nd;
 333     }
 334     _completed_buffers_tail = NULL;
 335     _n_completed_buffers = 0;
 336     DEBUG_ONLY(assert_completed_buffer_list_len_correct_locked());
 337   }
 338   while (buffers_to_delete != NULL) {
 339     BufferNode* nd = buffers_to_delete;
 340     buffers_to_delete = nd->next();
 341     deallocate_buffer(nd);
 342   }
 343   assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
 344   // So we can safely manipulate these queues.
 345   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 346     t->satb_mark_queue().reset();
 347   }
 348   shared_satb_queue()->reset();
 349 }
< prev index next >