/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
#include "gc_implementation/shared/gcAdaptivePolicyCounters.hpp"
#include "gc_implementation/shared/gcStats.hpp"
#include "runtime/perfData.hpp"
// CMSGCAdaptivePolicyCounters is a holder class for performance counters
// that track the data and decisions for the ergonomics policy for the
// concurrent mark sweep collector
friend class VMStructs;
private:
// Capacity of tenured generation recorded at the end of
// any collection.
// Average stop-the-world pause time for both initial and
// remark pauses sampled at the end of the checkpointRootsFinalWork.
// Average stop-the-world (STW) GC cost for the STW pause time
// _avg_cms_STW_time_counter.
#ifdef NOT_PRODUCT
// These are useful to see how the most recent values of these
// counters compare to their respective averages but
// do not control behavior.
#endif
// Average of the initial marking pause for a concurrent collection.
// Average of the remark pause for a concurrent collection.
// Average for the sum of all the concurrent times per collection.
// Average for the time between the most recent end of a
// concurrent collection and the beginning of the next
// concurrent collection.
// Average of the concurrent GC costs based on _avg_concurrent_time_counter
// and _avg_concurrent_interval_counter.
// Average of the free space in the tenured generation at the
// end of the sweep of the tenured generation.
// Average of the free space in the tenured generation at the
// start of the sweep of the tenured generation.
// Average of the free space in the tenured generation at the
// after any resizing of the tenured generation at the end
// of a collection of the tenured generation.
// Average of the mark-sweep-compact (MSC) pause time for a collection
// of the tenured generation.
// Average for the time between the most recent end of a
// MSC collection and the beginning of the next
// MSC collection.
// Average for the GC cost of a MSC collection based on
// _avg_msc_pause_counter and _avg_msc_interval_counter.
// Average of the mark-sweep (MS) pause time for a collection
// of the tenured generation.
// Average for the time between the most recent end of a
// MS collection and the beginning of the next
// MS collection.
// Average for the GC cost of a MS collection based on
// _avg_ms_pause_counter and _avg_ms_interval_counter.
// Average of the bytes promoted per minor collection.
// Average of the deviation of the promoted average
// Padded average of the bytes promoted per minor colleciton
// See description of the _change_young_gen_for_maj_pauses
// variable recently in cmsAdaptiveSizePolicy.hpp.
// See descriptions of _remark_pause_old_slope, _initial_pause_old_slope,
// etc. variables recently in cmsAdaptiveSizePolicy.hpp.
"Wrong size policy");
return (CMSAdaptiveSizePolicy*)_size_policy;
}
inline void update_avg_cms_STW_time_counter() {
(double) MILLIUNITS));
}
inline void update_avg_cms_STW_gc_cost_counter() {
}
inline void update_avg_initial_pause_counter() {
(double) MILLIUNITS));
}
#ifdef NOT_PRODUCT
inline void update_avg_remark_pause_counter() {
(double) MILLIUNITS));
}
inline void update_initial_pause_counter() {
(double) MILLIUNITS));
}
#endif
inline void update_remark_pause_counter() {
(double) MILLIUNITS));
}
inline void update_avg_concurrent_time_counter() {
(double) MILLIUNITS));
}
inline void update_avg_concurrent_interval_counter() {
(double) MILLIUNITS));
}
inline void update_avg_concurrent_gc_cost_counter() {
}
inline void update_avg_cms_free_counter() {
}
inline void update_avg_cms_free_at_sweep_counter() {
}
inline void update_avg_cms_promo_counter() {
}
inline void update_avg_old_live_counter() {
);
}
inline void update_avg_msc_pause_counter() {
(double) MILLIUNITS));
}
inline void update_avg_msc_interval_counter() {
(double) MILLIUNITS));
}
inline void update_msc_gc_cost_counter() {
}
inline void update_avg_ms_pause_counter() {
(double) MILLIUNITS));
}
inline void update_avg_ms_interval_counter() {
(double) MILLIUNITS));
}
inline void update_ms_gc_cost_counter() {
}
inline void update_major_gc_cost_counter() {
);
}
inline void update_mutator_cost_counter() {
);
}
);
}
);
}
);
}
inline void update_remark_pause_old_slope_counter() {
);
}
inline void update_initial_pause_old_slope_counter() {
);
}
inline void update_remark_pause_young_slope_counter() {
);
}
inline void update_initial_pause_young_slope_counter() {
);
}
inline void update_change_young_gen_for_maj_pauses() {
}
public:
// update counters
void update_counters();
void update_counters_from_policy();
}
}
};
#endif // SHARE_VM_GC_IMPLEMENTATION_CONCURRENTMARKSWEEP_CMSGCADAPTIVEPOLICYCOUNTERS_HPP