graal-compiler: src/share/vm/gc_implementation/g1/satbQueue.cpp comparison

comparison src/share/vm/gc_implementation/g1/satbQueue.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	4ca6dc0799b6 78bbf4d43a14
children	7848fc12602b

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 #include "oops/oop.inline.hpp"
 #include "runtime/mutexLocker.hpp"
 #include "runtime/thread.hpp"
 #include "runtime/vmThread.hpp"
+PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 void ObjPtrQueue::flush() {
 // The buffer might contain refs into the CSet. We have to filter it
 // first before we flush it, otherwise we might end up with an
 // enqueued buffer with refs into the CSet which breaks our invariants.
 filter();
 DEBUG_ONLY(t->satb_mark_queue().verify_oops_in_buffer();)
 t->satb_mark_queue().handle_zero_index();
 }
 #ifdef ASSERT
-void SATBMarkQueueSet::dump_active_values(JavaThread* first,
+void SATBMarkQueueSet::dump_active_states(bool expected_active) {
-bool expected_active) {
+gclog_or_tty->print_cr("Expected SATB active state: %s",
-gclog_or_tty->print_cr("SATB queue active values for Java Threads");
+expected_active ? "ACTIVE" : "INACTIVE");
-gclog_or_tty->print_cr(" SATB queue set: active is %s",
+gclog_or_tty->print_cr("Actual SATB active states:");
-(is_active()) ? "TRUE" : "FALSE");
+gclog_or_tty->print_cr("  Queue set: %s", is_active() ? "ACTIVE" : "INACTIVE");
-gclog_or_tty->print_cr(" expected_active is %s",
+for (JavaThread* t = Threads::first(); t; t = t->next()) {
-(expected_active) ? "TRUE" : "FALSE");
+gclog_or_tty->print_cr("  Thread \"%s\" queue: %s", t->name(),
-for (JavaThread* t = first; t; t = t->next()) {
+t->satb_mark_queue().is_active() ? "ACTIVE" : "INACTIVE");
-bool active = t->satb_mark_queue().is_active();
+}
-gclog_or_tty->print_cr("  thread %s, active is %s",
+gclog_or_tty->print_cr("  Shared queue: %s",
-t->name(), (active) ? "TRUE" : "FALSE");
+shared_satb_queue()->is_active() ? "ACTIVE" : "INACTIVE");
+}
+void SATBMarkQueueSet::verify_active_states(bool expected_active) {
+// Verify queue set state
+if (is_active() != expected_active) {
+dump_active_states(expected_active);
+guarantee(false, "SATB queue set has an unexpected active state");
+}
+// Verify thread queue states
+for (JavaThread* t = Threads::first(); t; t = t->next()) {
+if (t->satb_mark_queue().is_active() != expected_active) {
+dump_active_states(expected_active);
+guarantee(false, "Thread SATB queue has an unexpected active state");
+}
+}
+// Verify shared queue state
+if (shared_satb_queue()->is_active() != expected_active) {
+dump_active_states(expected_active);
+guarantee(false, "Shared SATB queue has an unexpected active state");
 }
 }
 #endif // ASSERT
-void SATBMarkQueueSet::set_active_all_threads(bool b,
+void SATBMarkQueueSet::set_active_all_threads(bool active, bool expected_active) {
-bool expected_active) {
 assert(SafepointSynchronize::is_at_safepoint(), "Must be at safepoint.");
-JavaThread* first = Threads::first();
 #ifdef ASSERT
-if (_all_active != expected_active) {
+verify_active_states(expected_active);
-dump_active_values(first, expected_active);
-// I leave this here as a guarantee, instead of an assert, so
-// that it will still be compiled in if we choose to uncomment
-// the #ifdef ASSERT in a product build. The whole block is
-// within an #ifdef ASSERT so the guarantee will not be compiled
-// in a product build anyway.
-guarantee(false,
-"SATB queue set has an unexpected active value");
-}
 #endif // ASSERT
-_all_active = b;
+_all_active = active;
+for (JavaThread* t = Threads::first(); t; t = t->next()) {
-for (JavaThread* t = first; t; t = t->next()) {
+t->satb_mark_queue().set_active(active);
-#ifdef ASSERT
+}
-bool active = t->satb_mark_queue().is_active();
+shared_satb_queue()->set_active(active);
-if (active != expected_active) {
-dump_active_values(first, expected_active);
-// I leave this here as a guarantee, instead of an assert, so
-// that it will still be compiled in if we choose to uncomment
-// the #ifdef ASSERT in a product build. The whole block is
-// within an #ifdef ASSERT so the guarantee will not be compiled
-// in a product build anyway.
-guarantee(false,
-"thread has an unexpected active value in its SATB queue");
-}
-#endif // ASSERT
-t->satb_mark_queue().set_active(b);
-}
 }
 void SATBMarkQueueSet::filter_thread_buffers() {
 for(JavaThread* t = Threads::first(); t; t = t->next()) {
 t->satb_mark_queue().filter();
 t->satb_mark_queue().apply_closure_and_empty(_closure);
 }
 shared_satb_queue()->apply_closure_and_empty(_closure);
 }
-void SATBMarkQueueSet::par_iterate_closure_all_threads(int worker) {
+void SATBMarkQueueSet::par_iterate_closure_all_threads(uint worker) {
 SharedHeap* sh = SharedHeap::heap();
 int parity = sh->strong_roots_parity();
 for(JavaThread* t = Threads::first(); t; t = t->next()) {
 if (t->claim_oops_do(true, parity)) {
 shared_satb_queue()->apply_closure_and_empty(_par_closures[worker]);
 }
 }
 bool SATBMarkQueueSet::apply_closure_to_completed_buffer_work(bool par,
-int worker) {
+uint worker) {
 BufferNode* nd = NULL;
 {
 MutexLockerEx x(_cbl_mon, Mutex::_no_safepoint_check_flag);
 if (_completed_buffers_head != NULL) {
 nd = _completed_buffers_head;

Mercurial > hg > graal-compiler

comparison src/share/vm/gc_implementation/g1/satbQueue.cpp @ 18041:52b4284cb496