Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.cpp@b2ef234911c9

src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.cpp

Thu, 20 Sep 2012 09:52:56 -0700

author
johnc
date
Thu, 20 Sep 2012 09:52:56 -0700
changeset 4067
b2ef234911c9
parent 2314
f95d63e2154a
child 6876
710a3c8b516e
permissions
-rw-r--r--

7190666: G1: assert(_unused == 0) failed: Inconsistency in PLAB stats
Summary: Reset the fields in ParGCAllocBuffer, that are used for accumulating values for the ResizePLAB sensors in PLABStats, to zero after flushing the values to the PLABStats fields. Flush PLABStats values only when retiring the final allocation buffers prior to disposing of a G1ParScanThreadState object, rather than when retiring every allocation buffer.
Reviewed-by: jwilhelm, jmasa, ysr

     1 /*

     2  * Copyright (c) 2004, 2010, Oracle and/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 

    25 #include "precompiled.hpp"

    26 #include "gc_implementation/shared/gcAdaptivePolicyCounters.hpp"

    27 #include "memory/resourceArea.hpp"

    28 

    29 // This class keeps statistical information and computes the

    30 // size of the heap.

    31 

    32 GCAdaptivePolicyCounters::GCAdaptivePolicyCounters(const char* name,

    33                                         int collectors,

    34                                         int generations,

    35                                         AdaptiveSizePolicy* size_policy_arg)

    36         : GCPolicyCounters(name, collectors, generations),

    37           _size_policy(size_policy_arg) {

    38   if (UsePerfData) {

    39     EXCEPTION_MARK;

    40     ResourceMark rm;

    41 

    42     const char* cname = PerfDataManager::counter_name(name_space(), "edenSize");

    43     _eden_size_counter = PerfDataManager::create_variable(SUN_GC, cname,

    44       PerfData::U_Bytes, _size_policy->calculated_eden_size_in_bytes(), CHECK);

    45 

    46     cname = PerfDataManager::counter_name(name_space(), "promoSize");

    47     _promo_size_counter = PerfDataManager::create_variable(SUN_GC, cname,

    48       PerfData::U_Bytes, size_policy()->calculated_promo_size_in_bytes(),

    49       CHECK);

    50 

    51     cname = PerfDataManager::counter_name(name_space(), "youngCapacity");

    52     size_t young_capacity_in_bytes =

    53       _size_policy->calculated_eden_size_in_bytes() +

    54       _size_policy->calculated_survivor_size_in_bytes();

    55     _young_capacity_counter = PerfDataManager::create_variable(SUN_GC, cname,

    56       PerfData::U_Bytes, young_capacity_in_bytes, CHECK);

    57 

    58     cname = PerfDataManager::counter_name(name_space(), "avgSurvivedAvg");

    59     _avg_survived_avg_counter = PerfDataManager::create_variable(SUN_GC, cname,

    60       PerfData::U_Bytes, size_policy()->calculated_survivor_size_in_bytes(),

    61         CHECK);

    62 

    63     cname = PerfDataManager::counter_name(name_space(), "avgSurvivedDev");

    64     _avg_survived_dev_counter = PerfDataManager::create_variable(SUN_GC, cname,

    65       PerfData::U_Bytes, (jlong) 0 , CHECK);

    66 

    67     cname = PerfDataManager::counter_name(name_space(), "avgSurvivedPaddedAvg");

    68     _avg_survived_padded_avg_counter =

    69       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Bytes,

    70         size_policy()->calculated_survivor_size_in_bytes(), CHECK);

    71 

    72     cname = PerfDataManager::counter_name(name_space(), "avgMinorPauseTime");

    73     _avg_minor_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,

    74       PerfData::U_Ticks, (jlong) _size_policy->_avg_minor_pause->average(),

    75       CHECK);

    76 

    77     cname = PerfDataManager::counter_name(name_space(), "avgMinorIntervalTime");

    78     _avg_minor_interval_counter = PerfDataManager::create_variable(SUN_GC,

    79       cname,

    80       PerfData::U_Ticks,

    81       (jlong) _size_policy->_avg_minor_interval->average(),

    82       CHECK);

    83 

    84 #ifdef NOT_PRODUCT

    85       // This is a counter for the most recent minor pause time

    86       // (the last sample, not the average).  It is useful for

    87       // verifying the average pause time but not worth putting

    88       // into the product.

    89       cname = PerfDataManager::counter_name(name_space(), "minorPauseTime");

    90       _minor_pause_counter = PerfDataManager::create_variable(SUN_GC, cname,

    91       PerfData::U_Ticks, (jlong) _size_policy->_avg_minor_pause->last_sample(),

    92       CHECK);

    93 #endif

    94 

    95     cname = PerfDataManager::counter_name(name_space(), "minorGcCost");

    96     _minor_gc_cost_counter = PerfDataManager::create_variable(SUN_GC,

    97       cname,

    98       PerfData::U_Ticks,

    99       (jlong) _size_policy->minor_gc_cost(),

   100       CHECK);

   101 

   102     cname = PerfDataManager::counter_name(name_space(), "mutatorCost");

   103     _mutator_cost_counter = PerfDataManager::create_variable(SUN_GC, cname,

   104       PerfData::U_Ticks, (jlong) _size_policy->mutator_cost(), CHECK);

   105 

   106     cname = PerfDataManager::counter_name(name_space(), "survived");

   107     _survived_counter = PerfDataManager::create_variable(SUN_GC, cname,

   108       PerfData::U_Bytes, (jlong) 0, CHECK);

   109 

   110     cname = PerfDataManager::counter_name(name_space(), "promoted");

   111     _promoted_counter = PerfDataManager::create_variable(SUN_GC, cname,

   112       PerfData::U_Bytes, (jlong) 0, CHECK);

   113 

   114     cname = PerfDataManager::counter_name(name_space(), "avgYoungLive");

   115     _avg_young_live_counter = PerfDataManager::create_variable(SUN_GC, cname,

   116       PerfData::U_Bytes, (jlong) size_policy()->avg_young_live()->average(),

   117       CHECK);

   118 

   119     cname = PerfDataManager::counter_name(name_space(), "avgOldLive");

   120     _avg_old_live_counter = PerfDataManager::create_variable(SUN_GC, cname,

   121       PerfData::U_Bytes, (jlong) size_policy()->avg_old_live()->average(),

   122       CHECK);

   123 

   124     cname = PerfDataManager::counter_name(name_space(), "survivorOverflowed");

   125     _survivor_overflowed_counter = PerfDataManager::create_variable(SUN_GC, cname,

   126       PerfData::U_Events, (jlong)0, CHECK);

   127 

   128     cname = PerfDataManager::counter_name(name_space(),

   129       "decrementTenuringThresholdForGcCost");

   130     _decrement_tenuring_threshold_for_gc_cost_counter =

   131       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,

   132         (jlong)0, CHECK);

   133 

   134     cname = PerfDataManager::counter_name(name_space(),

   135       "incrementTenuringThresholdForGcCost");

   136     _increment_tenuring_threshold_for_gc_cost_counter =

   137       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,

   138         (jlong)0, CHECK);

   139 

   140     cname = PerfDataManager::counter_name(name_space(),

   141       "decrementTenuringThresholdForSurvivorLimit");

   142     _decrement_tenuring_threshold_for_survivor_limit_counter =

   143       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,

   144         (jlong)0, CHECK);

   145     cname = PerfDataManager::counter_name(name_space(),

   146       "changeYoungGenForMinPauses");

   147     _change_young_gen_for_min_pauses_counter =

   148       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,

   149         (jlong)0, CHECK);

   150 

   151     cname = PerfDataManager::counter_name(name_space(),

   152       "changeOldGenForMajPauses");

   153     _change_old_gen_for_maj_pauses_counter =

   154       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,

   155         (jlong)0, CHECK);

   156 

   157     cname = PerfDataManager::counter_name(name_space(),

   158       "increaseOldGenForThroughput");

   159     _change_old_gen_for_throughput_counter =

   160       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,

   161         (jlong)0, CHECK);

   162 

   163     cname = PerfDataManager::counter_name(name_space(),

   164       "increaseYoungGenForThroughput");

   165     _change_young_gen_for_throughput_counter =

   166       PerfDataManager::create_variable(SUN_GC, cname, PerfData::U_Events,

   167         (jlong)0, CHECK);

   168 

   169     cname = PerfDataManager::counter_name(name_space(),

   170       "decreaseForFootprint");

   171     _decrease_for_footprint_counter =

   172       PerfDataManager::create_variable(SUN_GC, cname,

   173       PerfData::U_Events, (jlong)0, CHECK);

   174 

   175     cname = PerfDataManager::counter_name(name_space(), "decideAtFullGc");

   176     _decide_at_full_gc_counter = PerfDataManager::create_variable(SUN_GC, cname,

   177       PerfData::U_None, (jlong)0, CHECK);

   178 

   179     cname = PerfDataManager::counter_name(name_space(), "minorPauseYoungSlope");

   180     _minor_pause_young_slope_counter =

   181       PerfDataManager::create_variable(SUN_GC, cname,

   182       PerfData::U_None, (jlong) 0, CHECK);

   183 

   184     cname = PerfDataManager::counter_name(name_space(), "majorCollectionSlope");

   185     _major_collection_slope_counter =

   186       PerfDataManager::create_variable(SUN_GC, cname,

   187       PerfData::U_None, (jlong) 0, CHECK);

   188 

   189     cname = PerfDataManager::counter_name(name_space(), "minorCollectionSlope");

   190     _minor_collection_slope_counter =

   191       PerfDataManager::create_variable(SUN_GC, cname,

   192       PerfData::U_None, (jlong) 0, CHECK);

   193   }

   194 }

   195 

   196 void GCAdaptivePolicyCounters::update_counters_from_policy() {

   197   if (UsePerfData && (size_policy() != NULL)) {

   198     update_avg_minor_pause_counter();

   199     update_avg_minor_interval_counter();

   200 #ifdef NOT_PRODUCT

   201     update_minor_pause_counter();

   202 #endif

   203     update_minor_gc_cost_counter();

   204     update_avg_young_live_counter();

   205 

   206     update_survivor_size_counters();

   207     update_avg_survived_avg_counters();

   208     update_avg_survived_dev_counters();

   209     update_avg_survived_padded_avg_counters();

   210 

   211     update_change_old_gen_for_throughput();

   212     update_change_young_gen_for_throughput();

   213     update_decrease_for_footprint();

   214     update_change_young_gen_for_min_pauses();

   215     update_change_old_gen_for_maj_pauses();

   216 

   217     update_minor_pause_young_slope_counter();

   218     update_minor_collection_slope_counter();

   219     update_major_collection_slope_counter();

   220   }

   221 }

   222 

   223 void GCAdaptivePolicyCounters::update_counters() {

   224   if (UsePerfData) {

   225     update_counters_from_policy();

   226   }

   227 }

Mercurial Repository: jdk8-mips64-public/hotspot

mercurial