jdk8-mips64-public/hotspot: comparison src/share/vm/services/nmtDCmd.cpp

-:4d3a43351904
+:833b0f92429a
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */
 #include "precompiled.hpp"
+#include "runtime/mutexLocker.hpp"
 #include "services/nmtDCmd.hpp"
 #include "services/memReporter.hpp"
 #include "services/memTracker.hpp"
 #include "utilities/globalDefinitions.hpp"
 "allocation activities at different callsites.",
 "BOOLEAN", false, "false"),
 _shutdown("shutdown", "request runtime to shutdown itself and free the " \
 "memory used by runtime.",
 "BOOLEAN", false, "false"),
-_auto_shutdown("autoShutdown", "automatically shutdown itself under "    \
+_statistics("statistics", "print tracker statistics for tuning purpose.", \
-"stress situation",
+"BOOLEAN", false, "false"),
-"BOOLEAN", true, "true"),
-#ifndef PRODUCT
-_debug("debug", "print tracker statistics. Debug only, not thread safe", \
-"BOOLEAN", false, "false"),
-#endif
 _scale("scale", "Memory usage in which scale, KB, MB or GB",
 "STRING", false, "KB") {
 _dcmdparser.add_dcmd_option(&_summary);
 _dcmdparser.add_dcmd_option(&_detail);
 _dcmdparser.add_dcmd_option(&_baseline);
 _dcmdparser.add_dcmd_option(&_summary_diff);
 _dcmdparser.add_dcmd_option(&_detail_diff);
 _dcmdparser.add_dcmd_option(&_shutdown);
-_dcmdparser.add_dcmd_option(&_auto_shutdown);
+_dcmdparser.add_dcmd_option(&_statistics);
-#ifndef PRODUCT
-_dcmdparser.add_dcmd_option(&_debug);
-#endif
 _dcmdparser.add_dcmd_option(&_scale);
 }
+size_t NMTDCmd::get_scale(const char* scale) const {
+if (scale == NULL) return 0;
+return NMTUtil::scale_from_name(scale);
+}
 void NMTDCmd::execute(DCmdSource source, TRAPS) {
+// Check NMT state
+//  native memory tracking has to be on
+if (MemTracker::tracking_level() == NMT_off) {
+output()->print_cr("Native memory tracking is not enabled");
+return;
+} else if (MemTracker::tracking_level() == NMT_minimal) {
+output()->print_cr("Native memory tracking has been shutdown");
+return;
+}
 const char* scale_value = _scale.value();
-size_t scale_unit;
+size_t scale_unit = get_scale(scale_value);
-if (strcmp(scale_value, "KB") == 0 || strcmp(scale_value, "kb") == 0) {
+if (scale_unit == 0) {
-scale_unit = K;
-} else if (strcmp(scale_value, "MB") == 0 ||
-strcmp(scale_value, "mb") == 0) {
-scale_unit = M;
-} else if (strcmp(scale_value, "GB") == 0 ||
-strcmp(scale_value, "gb") == 0) {
-scale_unit = G;
-} else {
 output()->print_cr("Incorrect scale value: %s", scale_value);
 return;
 }
 int nopt = 0;
 if (_detail.is_set() && _detail.value()) { ++nopt; }
 if (_baseline.is_set() && _baseline.value()) { ++nopt; }
 if (_summary_diff.is_set() && _summary_diff.value()) { ++nopt; }
 if (_detail_diff.is_set() && _detail_diff.value()) { ++nopt; }
 if (_shutdown.is_set() && _shutdown.value()) { ++nopt; }
-if (_auto_shutdown.is_set()) { ++nopt; }
+if (_statistics.is_set() && _statistics.value()) { ++nopt; }
-#ifndef PRODUCT
-if (_debug.is_set() && _debug.value()) { ++nopt; }
-#endif
 if (nopt > 1) {
 output()->print_cr("At most one of the following option can be specified: " \
-"summary, detail, baseline, summary.diff, detail.diff, shutdown"
+"summary, detail, baseline, summary.diff, detail.diff, shutdown");
-#ifndef PRODUCT
-", debug"
-#endif
-);
 return;
 } else if (nopt == 0) {
 if (_summary.is_set()) {
 output()->print_cr("No command to execute");
 return;
 } else {
 _summary.set_value(true);
 }
 }
-#ifndef PRODUCT
+// Serialize NMT query
-if (_debug.value()) {
+MutexLocker locker(MemTracker::query_lock());
-output()->print_cr("debug command is NOT thread-safe, may cause crash");
-MemTracker::print_tracker_stats(output());
-return;
-}
-#endif
-// native memory tracking has to be on
-if (!MemTracker::is_on() || MemTracker::shutdown_in_progress()) {
-// if it is not on, what's the reason?
-output()->print_cr("%s", MemTracker::reason());
-return;
-}
 if (_summary.value()) {
-BaselineTTYOutputer outputer(output());
+report(true, scale_unit);
-MemTracker::print_memory_usage(outputer, scale_unit, true);
 } else if (_detail.value()) {
-BaselineTTYOutputer outputer(output());
+if (!check_detail_tracking_level(output())) {
-MemTracker::print_memory_usage(outputer, scale_unit, false);
+return;
+}
+report(false, scale_unit);
 } else if (_baseline.value()) {
-if (MemTracker::baseline()) {
+MemBaseline& baseline = MemTracker::get_baseline();
-output()->print_cr("Successfully baselined.");
+if (!baseline.baseline(MemTracker::tracking_level() != NMT_detail)) {
-} else {
+output()->print_cr("Baseline failed");
-output()->print_cr("Baseline failed.");
+} else {
+output()->print_cr("Baseline succeeded");
 }
 } else if (_summary_diff.value()) {
-if (MemTracker::has_baseline()) {
+MemBaseline& baseline = MemTracker::get_baseline();
-BaselineTTYOutputer outputer(output());
+if (baseline.baseline_type() >= MemBaseline::Summary_baselined) {
-MemTracker::compare_memory_usage(outputer, scale_unit, true);
+report_diff(true, scale_unit);
 } else {
-output()->print_cr("No baseline to compare, run 'baseline' command first");
+output()->print_cr("No baseline for comparison");
 }
 } else if (_detail_diff.value()) {
-if (MemTracker::has_baseline()) {
+if (!check_detail_tracking_level(output())) {
-BaselineTTYOutputer outputer(output());
+return;
-MemTracker::compare_memory_usage(outputer, scale_unit, false);
+}
-} else {
+MemBaseline& baseline = MemTracker::get_baseline();
-output()->print_cr("No baseline to compare to, run 'baseline' command first");
+if (baseline.baseline_type() == MemBaseline::Detail_baselined) {
+report_diff(false, scale_unit);
+} else {
+output()->print_cr("No detail baseline for comparison");
 }
 } else if (_shutdown.value()) {
-MemTracker::shutdown(MemTracker::NMT_shutdown_user);
+MemTracker::shutdown();
-output()->print_cr("Shutdown is in progress, it will take a few moments to " \
+output()->print_cr("Native memory tracking has been turned off");
-"completely shutdown");
+} else if (_statistics.value()) {
-} else if (_auto_shutdown.is_set()) {
+if (check_detail_tracking_level(output())) {
-MemTracker::set_autoShutdown(_auto_shutdown.value());
+MemTracker::tuning_statistics(output());
+}
 } else {
 ShouldNotReachHere();
 output()->print_cr("Unknown command");
 }
 }
 } else {
 return 0;
 }
 }
+void NMTDCmd::report(bool summaryOnly, size_t scale_unit) {
+MemBaseline baseline;
+if (baseline.baseline(summaryOnly)) {
+if (summaryOnly) {
+MemSummaryReporter rpt(baseline, output(), scale_unit);
+rpt.report();
+} else {
+MemDetailReporter rpt(baseline, output(), scale_unit);
+rpt.report();
+}
+}
+}
+void NMTDCmd::report_diff(bool summaryOnly, size_t scale_unit) {
+MemBaseline& early_baseline = MemTracker::get_baseline();
+assert(early_baseline.baseline_type() != MemBaseline::Not_baselined,
+"Not yet baselined");
+assert(summaryOnly || early_baseline.baseline_type() == MemBaseline::Detail_baselined,
+"Not a detail baseline");
+MemBaseline baseline;
+if (baseline.baseline(summaryOnly)) {
+if (summaryOnly) {
+MemSummaryDiffReporter rpt(early_baseline, baseline, output(), scale_unit);
+rpt.report_diff();
+} else {
+MemDetailDiffReporter rpt(early_baseline, baseline, output(), scale_unit);
+rpt.report_diff();
+}
+}
+}
+bool NMTDCmd::check_detail_tracking_level(outputStream* out) {
+if (MemTracker::tracking_level() == NMT_detail) {
+return true;
+} else if (MemTracker::cmdline_tracking_level() == NMT_detail) {
+out->print_cr("Tracking level has been downgraded due to lack of resources");
+return false;
+} else {
+out->print_cr("Detail tracking is not enabled");
+return false;
+}
+}

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

comparison: src/share/vm/services/nmtDCmd.cpp

src/share/vm/services/nmtDCmd.cpp