jdk8-mips64-public/hotspot: src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp@215f81b4d9b3 (annotated)

src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp@215f81b4d9b3 (annotated)

src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp

Mon, 18 May 2009 11:52:46 -0700

author: iveresov
date: Mon, 18 May 2009 11:52:46 -0700
changeset 1230: 215f81b4d9b3
parent 1229: 315a5d70b295
child 1234: f89cf529c3c7
permissions: -rw-r--r--

6841831: G1: assert(contains_reference(from),"We just added it!") fires
Summary: During parallel rset updating we have to make sure that the worker ids of the refinement threads do not intersect with the worker ids that can be claimed by the mutator threads.
Reviewed-by: tonyp

 /*
  * Copyright 2001-2007 Sun Microsystems, Inc.  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.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  * CA 95054 USA or visit www.sun.com if you need additional information or
  * have any questions.
  *
  */
 #include "incls/_precompiled.incl"
 #include "incls/_concurrentG1Refine.cpp.incl"
 ConcurrentG1Refine::ConcurrentG1Refine() :
   _card_counts(NULL), _cur_card_count_histo(NULL), _cum_card_count_histo(NULL),
   _hot_cache(NULL),
   _def_use_cache(false), _use_cache(false),
   _n_periods(0), _total_cards(0), _total_travs(0),
   _threads(NULL), _n_threads(0)
 {
   if (G1ConcRefine) {
     _n_threads = (int)thread_num();
     if (_n_threads > 0) {
       _threads = NEW_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _n_threads);
       int worker_id_offset = (int)DirtyCardQueueSet::num_par_ids();
       ConcurrentG1RefineThread *next = NULL;
       for (int i = _n_threads - 1; i >= 0; i--) {
         ConcurrentG1RefineThread* t = new ConcurrentG1RefineThread(this, next, worker_id_offset, i);
         assert(t != NULL, "Conc refine should have been created");
         assert(t->cg1r() == this, "Conc refine thread should refer to this");
         _threads[i] = t;
         next = t;
       }
     }
   }
 }
 size_t ConcurrentG1Refine::thread_num() {
   if (G1ConcRefine) {
     return (G1ParallelRSetThreads > 0) ? G1ParallelRSetThreads : ParallelGCThreads;
   }
   return 0;
 }
 void ConcurrentG1Refine::init() {
   if (G1ConcRSLogCacheSize > 0 || G1ConcRSCountTraversals) {
     G1CollectedHeap* g1h = G1CollectedHeap::heap();
     _n_card_counts =
       (unsigned) (g1h->g1_reserved_obj_bytes() >> CardTableModRefBS::card_shift);
     _card_counts = NEW_C_HEAP_ARRAY(unsigned char, _n_card_counts);
     for (size_t i = 0; i < _n_card_counts; i++) _card_counts[i] = 0;
     ModRefBarrierSet* bs = g1h->mr_bs();
     guarantee(bs->is_a(BarrierSet::CardTableModRef), "Precondition");
     CardTableModRefBS* ctbs = (CardTableModRefBS*)bs;
     _ct_bot = ctbs->byte_for_const(g1h->reserved_region().start());
     if (G1ConcRSCountTraversals) {
       _cur_card_count_histo = NEW_C_HEAP_ARRAY(unsigned, 256);
       _cum_card_count_histo = NEW_C_HEAP_ARRAY(unsigned, 256);
       for (int i = 0; i < 256; i++) {
         _cur_card_count_histo[i] = 0;
         _cum_card_count_histo[i] = 0;
       }
     }
   }
   if (G1ConcRSLogCacheSize > 0) {
     _def_use_cache = true;
     _use_cache = true;
     _hot_cache_size = (1 << G1ConcRSLogCacheSize);
     _hot_cache = NEW_C_HEAP_ARRAY(jbyte*, _hot_cache_size);
     _n_hot = 0;
     _hot_cache_idx = 0;
   }
 }
 void ConcurrentG1Refine::stop() {
   if (_threads != NULL) {
     for (int i = 0; i < _n_threads; i++) {
       _threads[i]->stop();
     }
   }
 }
 ConcurrentG1Refine::~ConcurrentG1Refine() {
   if (G1ConcRSLogCacheSize > 0 || G1ConcRSCountTraversals) {
     assert(_card_counts != NULL, "Logic");
     FREE_C_HEAP_ARRAY(unsigned char, _card_counts);
     assert(_cur_card_count_histo != NULL, "Logic");
     FREE_C_HEAP_ARRAY(unsigned, _cur_card_count_histo);
     assert(_cum_card_count_histo != NULL, "Logic");
     FREE_C_HEAP_ARRAY(unsigned, _cum_card_count_histo);
   }
   if (G1ConcRSLogCacheSize > 0) {
     assert(_hot_cache != NULL, "Logic");
     FREE_C_HEAP_ARRAY(jbyte*, _hot_cache);
   }
   if (_threads != NULL) {
     for (int i = 0; i < _n_threads; i++) {
       delete _threads[i];
     }
     FREE_C_HEAP_ARRAY(ConcurrentG1RefineThread*, _n_threads);
   }
 }
 void ConcurrentG1Refine::threads_do(ThreadClosure *tc) {
   if (_threads != NULL) {
     for (int i = 0; i < _n_threads; i++) {
       tc->do_thread(_threads[i]);
     }
   }
 }
 int ConcurrentG1Refine::add_card_count(jbyte* card_ptr) {
   size_t card_num = (card_ptr - _ct_bot);
   guarantee(0 <= card_num && card_num < _n_card_counts, "Bounds");
   unsigned char cnt = _card_counts[card_num];
   if (cnt < 255) _card_counts[card_num]++;
   return cnt;
   _total_travs++;
 }
 jbyte* ConcurrentG1Refine::cache_insert(jbyte* card_ptr) {
   int count = add_card_count(card_ptr);
   // Count previously unvisited cards.
   if (count == 0) _total_cards++;
   // We'll assume a traversal unless we store it in the cache.
   if (count < G1ConcRSHotCardLimit) {
     _total_travs++;
     return card_ptr;
   }
   // Otherwise, it's hot.
   jbyte* res = NULL;
   MutexLockerEx x(HotCardCache_lock, Mutex::_no_safepoint_check_flag);
   if (_n_hot == _hot_cache_size) {
     _total_travs++;
     res = _hot_cache[_hot_cache_idx];
     _n_hot--;
   }
   // Now _n_hot < _hot_cache_size, and we can insert at _hot_cache_idx.
   _hot_cache[_hot_cache_idx] = card_ptr;
   _hot_cache_idx++;
   if (_hot_cache_idx == _hot_cache_size) _hot_cache_idx = 0;
   _n_hot++;
   return res;
 }
 void ConcurrentG1Refine::clean_up_cache(int worker_i, G1RemSet* g1rs) {
   assert(!use_cache(), "cache should be disabled");
   int start_ind = _hot_cache_idx-1;
   for (int i = 0; i < _n_hot; i++) {
     int ind = start_ind - i;
     if (ind < 0) ind = ind + _hot_cache_size;
     jbyte* entry = _hot_cache[ind];
     if (entry != NULL) {
       g1rs->concurrentRefineOneCard(entry, worker_i);
     }
   }
   _n_hot = 0;
   _hot_cache_idx = 0;
 }
 void ConcurrentG1Refine::clear_and_record_card_counts() {
   if (G1ConcRSLogCacheSize == 0 && !G1ConcRSCountTraversals) return;
   _n_periods++;
   if (G1ConcRSCountTraversals) {
     for (size_t i = 0; i < _n_card_counts; i++) {
       unsigned char bucket = _card_counts[i];
       _cur_card_count_histo[bucket]++;
       _card_counts[i] = 0;
     }
     gclog_or_tty->print_cr("Card counts:");
     for (int i = 0; i < 256; i++) {
       if (_cur_card_count_histo[i] > 0) {
         gclog_or_tty->print_cr("  %3d: %9d", i, _cur_card_count_histo[i]);
         _cum_card_count_histo[i] += _cur_card_count_histo[i];
         _cur_card_count_histo[i] = 0;
       }
     }
   } else {
     assert(G1ConcRSLogCacheSize > 0, "Logic");
     Copy::fill_to_words((HeapWord*)(&_card_counts[0]),
                         _n_card_counts / HeapWordSize);
   }
 }
 void
 ConcurrentG1Refine::
 print_card_count_histo_range(unsigned* histo, int from, int to,
                              float& cum_card_pct,
                              float& cum_travs_pct) {
   unsigned cards = 0;
   unsigned travs = 0;
   guarantee(to <= 256, "Precondition");
   for (int i = from; i < to-1; i++) {
     cards += histo[i];
     travs += histo[i] * i;
   }
   if (to == 256) {
     unsigned histo_card_sum = 0;
     unsigned histo_trav_sum = 0;
     for (int i = 1; i < 255; i++) {
       histo_trav_sum += histo[i] * i;
     }
     cards += histo[255];
     // correct traversals for the last one.
     unsigned travs_255 = (unsigned) (_total_travs - histo_trav_sum);
     travs += travs_255;
   } else {
     cards += histo[to-1];
     travs += histo[to-1] * (to-1);
   }
   float fperiods = (float)_n_periods;
   float f_tot_cards = (float)_total_cards/fperiods;
   float f_tot_travs = (float)_total_travs/fperiods;
   if (cards > 0) {
     float fcards = (float)cards/fperiods;
     float ftravs = (float)travs/fperiods;
     if (to == 256) {
       gclog_or_tty->print(" %4d-       %10.2f%10.2f", from, fcards, ftravs);
     } else {
       gclog_or_tty->print(" %4d-%4d   %10.2f%10.2f", from, to-1, fcards, ftravs);
     }
     float pct_cards = fcards*100.0/f_tot_cards;
     cum_card_pct += pct_cards;
     float pct_travs = ftravs*100.0/f_tot_travs;
     cum_travs_pct += pct_travs;
     gclog_or_tty->print_cr("%10.2f%10.2f%10.2f%10.2f",
                   pct_cards, cum_card_pct,
                   pct_travs, cum_travs_pct);
   }
 }
 void ConcurrentG1Refine::print_final_card_counts() {
   if (!G1ConcRSCountTraversals) return;
   gclog_or_tty->print_cr("Did %d total traversals of %d distinct cards.",
                 _total_travs, _total_cards);
   float fperiods = (float)_n_periods;
   gclog_or_tty->print_cr("  This is an average of %8.2f traversals, %8.2f cards, "
                 "per collection.", (float)_total_travs/fperiods,
                 (float)_total_cards/fperiods);
   gclog_or_tty->print_cr("  This is an average of %8.2f traversals/distinct "
                 "dirty card.\n",
                 _total_cards > 0 ?
                 (float)_total_travs/(float)_total_cards : 0.0);
   gclog_or_tty->print_cr("Histogram:\n\n%10s   %10s%10s%10s%10s%10s%10s",
                 "range", "# cards", "# travs", "% cards", "(cum)",
                 "% travs", "(cum)");
   gclog_or_tty->print_cr("------------------------------------------------------------"
                 "-------------");
   float cum_cards_pct = 0.0;
   float cum_travs_pct = 0.0;
   for (int i = 1; i < 10; i++) {
     print_card_count_histo_range(_cum_card_count_histo, i, i+1,
                                  cum_cards_pct, cum_travs_pct);
   }
   for (int i = 10; i < 100; i += 10) {
     print_card_count_histo_range(_cum_card_count_histo, i, i+10,
                                  cum_cards_pct, cum_travs_pct);
   }
   print_card_count_histo_range(_cum_card_count_histo, 100, 150,
                                cum_cards_pct, cum_travs_pct);
   print_card_count_histo_range(_cum_card_count_histo, 150, 200,
                                cum_cards_pct, cum_travs_pct);
   print_card_count_histo_range(_cum_card_count_histo, 150, 255,
                                cum_cards_pct, cum_travs_pct);
   print_card_count_histo_range(_cum_card_count_histo, 255, 256,
                                cum_cards_pct, cum_travs_pct);
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp@215f81b4d9b3 (annotated)

src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp