8214850: Rename vm_operations.?pp files to vmOperations.?pp files
Reviewed-by: dholmes, coleenp
/*
* Copyright (c) 2018, 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.
*
* 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 "precompiled.hpp"
#include "gc/shared/weakProcessorPhases.hpp"
#include "gc/shared/weakProcessorPhaseTimes.hpp"
#include "gc/shared/workerDataArray.inline.hpp"
#include "logging/log.hpp"
#include "logging/logStream.hpp"
#include "utilities/debug.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/ticks.hpp"
static uint phase_index(WeakProcessorPhase phase) {
return WeakProcessorPhases::index(phase);
}
static bool is_serial_phase(WeakProcessorPhase phase) {
return WeakProcessorPhases::is_serial(phase);
}
static void assert_oop_storage_phase(WeakProcessorPhase phase) {
assert(WeakProcessorPhases::is_oop_storage(phase),
"Not an oop_storage phase %u", phase_index(phase));
}
const double uninitialized_time = -1.0;
#ifdef ASSERT
static bool is_initialized_time(double t) { return t >= 0.0; }
#endif // ASSERT
static void reset_times(double* times, size_t ntimes) {
for (size_t i = 0; i < ntimes; ++i) {
times[i] = uninitialized_time;
}
}
WeakProcessorPhaseTimes::WeakProcessorPhaseTimes(uint max_threads) :
_max_threads(max_threads),
_active_workers(0),
_total_time_sec(uninitialized_time),
_worker_phase_times_sec()
{
assert(_max_threads > 0, "max_threads must not be zero");
reset_times(_phase_times_sec, ARRAY_SIZE(_phase_times_sec));
if (_max_threads > 1) {
WorkerDataArray<double>** wpt = _worker_phase_times_sec;
FOR_EACH_WEAK_PROCESSOR_OOP_STORAGE_PHASE(phase) {
const char* description = WeakProcessorPhases::description(phase);
*wpt++ = new WorkerDataArray<double>(_max_threads, description);
}
}
}
WeakProcessorPhaseTimes::~WeakProcessorPhaseTimes() {
for (size_t i = 0; i < ARRAY_SIZE(_worker_phase_times_sec); ++i) {
delete _worker_phase_times_sec[i];
}
}
uint WeakProcessorPhaseTimes::max_threads() const { return _max_threads; }
uint WeakProcessorPhaseTimes::active_workers() const {
assert(_active_workers != 0, "active workers not set");
return _active_workers;
}
void WeakProcessorPhaseTimes::set_active_workers(uint n) {
assert(_active_workers == 0, "active workers already set");
assert(n > 0, "active workers must be non-zero");
assert(n <= _max_threads, "active workers must not exceed max threads");
_active_workers = n;
}
void WeakProcessorPhaseTimes::reset() {
_active_workers = 0;
_total_time_sec = uninitialized_time;
reset_times(_phase_times_sec, ARRAY_SIZE(_phase_times_sec));
if (_max_threads > 1) {
for (size_t i = 0; i < ARRAY_SIZE(_worker_phase_times_sec); ++i) {
_worker_phase_times_sec[i]->reset();
}
}
}
double WeakProcessorPhaseTimes::total_time_sec() const {
assert(is_initialized_time(_total_time_sec), "Total time not set");
return _total_time_sec;
}
void WeakProcessorPhaseTimes::record_total_time_sec(double time_sec) {
assert(!is_initialized_time(_total_time_sec), "Already set total time");
_total_time_sec = time_sec;
}
double WeakProcessorPhaseTimes::phase_time_sec(WeakProcessorPhase phase) const {
assert(is_initialized_time(_phase_times_sec[phase_index(phase)]),
"phase time not set %u", phase_index(phase));
return _phase_times_sec[phase_index(phase)];
}
void WeakProcessorPhaseTimes::record_phase_time_sec(WeakProcessorPhase phase, double time_sec) {
assert(!is_initialized_time(_phase_times_sec[phase_index(phase)]),
"Already set time for phase %u", phase_index(phase));
_phase_times_sec[phase_index(phase)] = time_sec;
}
WorkerDataArray<double>* WeakProcessorPhaseTimes::worker_data(WeakProcessorPhase phase) const {
assert_oop_storage_phase(phase);
assert(active_workers() > 1, "No worker data when single-threaded");
return _worker_phase_times_sec[WeakProcessorPhases::oop_storage_index(phase)];
}
double WeakProcessorPhaseTimes::worker_time_sec(uint worker_id, WeakProcessorPhase phase) const {
assert(worker_id < active_workers(),
"invalid worker id %u for %u", worker_id, active_workers());
if (active_workers() == 1) {
return phase_time_sec(phase);
} else {
return worker_data(phase)->get(worker_id);
}
}
void WeakProcessorPhaseTimes::record_worker_time_sec(uint worker_id,
WeakProcessorPhase phase,
double time_sec) {
if (active_workers() == 1) {
record_phase_time_sec(phase, time_sec);
} else {
worker_data(phase)->set(worker_id, time_sec);
}
}
static double elapsed_time_sec(Ticks start_time, Ticks end_time) {
return (end_time - start_time).seconds();
}
WeakProcessorTimeTracker::WeakProcessorTimeTracker(WeakProcessorPhaseTimes* times) :
_times(times),
_start_time(Ticks::now())
{}
WeakProcessorTimeTracker::~WeakProcessorTimeTracker() {
if (_times != NULL) {
Ticks end_time = Ticks::now();
_times->record_total_time_sec(elapsed_time_sec(_start_time, end_time));
}
}
WeakProcessorPhaseTimeTracker::WeakProcessorPhaseTimeTracker(WeakProcessorPhaseTimes* times,
WeakProcessorPhase phase,
uint worker_id) :
_times(times),
_phase(phase),
_worker_id(worker_id),
_start_time(Ticks::now())
{
assert_oop_storage_phase(_phase);
assert(_times == NULL || worker_id < _times->active_workers(),
"Invalid worker_id %u", worker_id);
}
WeakProcessorPhaseTimeTracker::WeakProcessorPhaseTimeTracker(WeakProcessorPhaseTimes* times,
WeakProcessorPhase phase) :
_times(times),
_phase(phase),
_worker_id(0),
_start_time(Ticks::now())
{
assert(is_serial_phase(phase), "Not a serial phase %u", phase_index(phase));
}
WeakProcessorPhaseTimeTracker::~WeakProcessorPhaseTimeTracker() {
if (_times != NULL) {
double time_sec = elapsed_time_sec(_start_time, Ticks::now());
if (is_serial_phase(_phase)) {
_times->record_phase_time_sec(_phase, time_sec);
} else {
_times->record_worker_time_sec(_worker_id, _phase, time_sec);
}
}
}
//////////////////////////////////////////////////////////////////////////////
// Printing times
const char* const indents[] = {"", " ", " ", " ", " "};
const size_t max_indents_index = ARRAY_SIZE(indents) - 1;
static const char* indent_str(size_t i) {
return indents[MIN2(i, max_indents_index)];
}
#define TIME_FORMAT "%.1lfms"
void WeakProcessorPhaseTimes::log_st_phase(WeakProcessorPhase phase,
uint indent) const {
log_debug(gc, phases)("%s%s: " TIME_FORMAT,
indent_str(indent),
WeakProcessorPhases::description(phase),
phase_time_sec(phase) * MILLIUNITS);
}
void WeakProcessorPhaseTimes::log_mt_phase_summary(WeakProcessorPhase phase,
uint indent) const {
LogTarget(Debug, gc, phases) lt;
LogStream ls(lt);
ls.print("%s", indents[indent]);
worker_data(phase)->print_summary_on(&ls, true);
}
void WeakProcessorPhaseTimes::log_mt_phase_details(WeakProcessorPhase phase,
uint indent) const {
LogTarget(Trace, gc, phases) lt;
LogStream ls(lt);
ls.print("%s", indents[indent]);
worker_data(phase)->print_details_on(&ls);
}
void WeakProcessorPhaseTimes::log_print_phases(uint indent) const {
if (log_is_enabled(Debug, gc, phases)) {
bool details_enabled = log_is_enabled(Trace, gc, phases);
FOR_EACH_WEAK_PROCESSOR_PHASE(phase) {
if (is_serial_phase(phase) || (active_workers() == 1)) {
log_st_phase(phase, indent);
} else {
log_mt_phase_summary(phase, indent);
if (details_enabled) {
log_mt_phase_details(phase, indent + 1);
}
}
}
}
}
void WeakProcessorPhaseTimes::log_print(uint indent) const {
if (log_is_enabled(Debug, gc, phases)) {
log_debug(gc, phases)("%s%s: " TIME_FORMAT,
indent_str(indent),
"Weak Processing",
total_time_sec() * MILLIUNITS);
log_print_phases(indent + 1);
}
}