1 /*
  2  * Copyright Amazon.com Inc. 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 #include "precompiled.hpp"
 25 
 26 #include "gc/shenandoah/shenandoahAgeCensus.hpp"
 27 #include "gc/shenandoah/shenandoahHeap.inline.hpp"
 28 #include "gc/shenandoah/shenandoahEvacTracker.hpp"
 29 #include "gc/shenandoah/shenandoahThreadLocalData.hpp"
 30 #include "gc/shenandoah/shenandoahRootProcessor.hpp"
 31 #include "runtime/threadSMR.inline.hpp"
 32 #include "runtime/thread.hpp"
 33 
 34 ShenandoahEvacuationStats::ShenandoahEvacuationStats(bool generational)
 35   : _evacuations_completed(0), _bytes_completed(0),
 36     _evacuations_attempted(0), _bytes_attempted(0),
 37     _use_age_table(generational && (ShenandoahGenerationalCensusAtEvac || !ShenandoahGenerationalAdaptiveTenuring)) {
 38   if (_use_age_table) {
 39     _age_table = new AgeTable(false);
 40   }
 41 }
 42 
 43 AgeTable* ShenandoahEvacuationStats::age_table() const {
 44   assert(_use_age_table, "Don't call");
 45   return _age_table;
 46 }
 47 
 48 void ShenandoahEvacuationStats::begin_evacuation(size_t bytes) {
 49   ++_evacuations_attempted;
 50   _bytes_attempted += bytes;
 51 }
 52 
 53 void ShenandoahEvacuationStats::end_evacuation(size_t bytes) {
 54   ++_evacuations_completed;
 55   _bytes_completed += bytes;
 56 }
 57 
 58 void ShenandoahEvacuationStats::record_age(size_t bytes, uint age) {
 59   assert(_use_age_table, "Don't call!");
 60   _age_table->add(age, bytes >> LogBytesPerWord);
 61 }
 62 
 63 void ShenandoahEvacuationStats::accumulate(const ShenandoahEvacuationStats* other) {
 64   _evacuations_completed += other->_evacuations_completed;
 65   _bytes_completed += other->_bytes_completed;
 66   _evacuations_attempted += other->_evacuations_attempted;
 67   _bytes_attempted += other->_bytes_attempted;
 68   if (_use_age_table) {
 69     _age_table->merge(other->age_table());
 70   }
 71 }
 72 
 73 void ShenandoahEvacuationStats::reset() {
 74   _evacuations_completed = _evacuations_attempted = 0;
 75   _bytes_completed = _bytes_attempted = 0;
 76   if (_use_age_table) {
 77     _age_table->clear();
 78   }
 79 }
 80 
 81 void ShenandoahEvacuationStats::print_on(outputStream* st) {
 82   size_t abandoned_size = _bytes_attempted - _bytes_completed;
 83   size_t abandoned_count = _evacuations_attempted - _evacuations_completed;
 84   st->print_cr("Evacuated " SIZE_FORMAT "%s across " SIZE_FORMAT " objects, "
 85             "abandoned " SIZE_FORMAT "%s across " SIZE_FORMAT " objects.",
 86             byte_size_in_proper_unit(_bytes_completed), proper_unit_for_byte_size(_bytes_completed),
 87             _evacuations_completed,
 88             byte_size_in_proper_unit(abandoned_size),   proper_unit_for_byte_size(abandoned_size),
 89             abandoned_count);
 90   if (_use_age_table) {
 91     _age_table->print_on(st, ShenandoahHeap::heap()->age_census()->tenuring_threshold());
 92   }
 93 }
 94 
 95 void ShenandoahEvacuationTracker::print_global_on(outputStream* st) {
 96   print_evacuations_on(st, &_workers_global, &_mutators_global);
 97 }
 98 
 99 void ShenandoahEvacuationTracker::print_evacuations_on(outputStream* st,
100                                                        ShenandoahEvacuationStats* workers,
101                                                        ShenandoahEvacuationStats* mutators) {
102   st->print("Workers: ");
103   workers->print_on(st);
104   st->cr();
105   st->print("Mutators: ");
106   mutators->print_on(st);
107   st->cr();
108 
109   ShenandoahHeap* heap = ShenandoahHeap::heap();
110   if (_generational) {
111     AgeTable young_region_ages(false);
112     for (uint i = 0; i < heap->num_regions(); ++i) {
113       ShenandoahHeapRegion* r = heap->get_region(i);
114       if (r->is_young()) {
115         young_region_ages.add(r->age(), r->get_live_data_words());
116       }
117     }
118     uint tenuring_threshold = heap->age_census()->tenuring_threshold();
119     st->print("Young regions: ");
120     young_region_ages.print_on(st, tenuring_threshold);
121     st->cr();
122   }
123 }
124 
125 class ShenandoahStatAggregator : public ThreadClosure {
126 public:
127   ShenandoahEvacuationStats* _target;
128   explicit ShenandoahStatAggregator(ShenandoahEvacuationStats* target) : _target(target) {}
129   virtual void do_thread(Thread* thread) override {
130     ShenandoahEvacuationStats* local = ShenandoahThreadLocalData::evacuation_stats(thread);
131     _target->accumulate(local);
132     local->reset();
133   }
134 };
135 
136 ShenandoahCycleStats ShenandoahEvacuationTracker::flush_cycle_to_global() {
137   ShenandoahEvacuationStats mutators(_generational), workers(_generational);
138 
139   ThreadsListHandle java_threads_iterator;
140   ShenandoahStatAggregator aggregate_mutators(&mutators);
141   java_threads_iterator.list()->threads_do(&aggregate_mutators);
142 
143   ShenandoahStatAggregator aggregate_workers(&workers);
144   ShenandoahHeap::heap()->gc_threads_do(&aggregate_workers);
145 
146   _mutators_global.accumulate(&mutators);
147   _workers_global.accumulate(&workers);
148 
149   if (_generational && (ShenandoahGenerationalCensusAtEvac || !ShenandoahGenerationalAdaptiveTenuring)) {
150     // Ingest population vectors into the heap's global census
151     // data, and use it to compute an appropriate tenuring threshold
152     // for use in the next cycle.
153     ShenandoahAgeCensus* census = ShenandoahHeap::heap()->age_census();
154     census->prepare_for_census_update();
155     // The first argument is used for any age 0 cohort population that we may otherwise have
156     // missed during the census. This is non-zero only when census happens at marking.
157     census->update_census(0, _mutators_global.age_table(), _workers_global.age_table());
158   }
159 
160   return {workers, mutators};
161 }
162 
163 void ShenandoahEvacuationTracker::begin_evacuation(Thread* thread, size_t bytes) {
164   ShenandoahThreadLocalData::begin_evacuation(thread, bytes);
165 }
166 
167 void ShenandoahEvacuationTracker::end_evacuation(Thread* thread, size_t bytes) {
168   ShenandoahThreadLocalData::end_evacuation(thread, bytes);
169 }
170 
171 void ShenandoahEvacuationTracker::record_age(Thread* thread, size_t bytes, uint age) {
172   ShenandoahThreadLocalData::record_age(thread, bytes, age);
173 }