runtimeService.cpp revision 3730:fb19af007ffc 
1/*
2 * Copyright (c) 2003, 2012, 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 "classfile/classLoader.hpp"
27#include "services/attachListener.hpp"
28#include "services/management.hpp"
29#include "services/runtimeService.hpp"
30#include "utilities/dtrace.hpp"
31#include "utilities/exceptions.hpp"
32
33#ifndef USDT2
34HS_DTRACE_PROBE_DECL(hs_private, safepoint__begin);
35HS_DTRACE_PROBE_DECL(hs_private, safepoint__end);
36#endif /* !USDT2 */
37
38#if INCLUDE_MANAGEMENT
39TimeStamp RuntimeService::_app_timer;
40TimeStamp RuntimeService::_safepoint_timer;
41PerfCounter*  RuntimeService::_sync_time_ticks = NULL;
42PerfCounter*  RuntimeService::_total_safepoints = NULL;
43PerfCounter*  RuntimeService::_safepoint_time_ticks = NULL;
44PerfCounter*  RuntimeService::_application_time_ticks = NULL;
45PerfCounter*  RuntimeService::_thread_interrupt_signaled_count = NULL;
46PerfCounter*  RuntimeService::_interrupted_before_count = NULL;
47PerfCounter*  RuntimeService::_interrupted_during_count = NULL;
48
49void RuntimeService::init() {
50  // Make sure the VM version is initialized
51  Abstract_VM_Version::initialize();
52
53  if (UsePerfData) {
54    EXCEPTION_MARK;
55
56    _sync_time_ticks =
57              PerfDataManager::create_counter(SUN_RT, "safepointSyncTime",
58                                              PerfData::U_Ticks, CHECK);
59
60    _total_safepoints =
61              PerfDataManager::create_counter(SUN_RT, "safepoints",
62                                              PerfData::U_Events, CHECK);
63
64    _safepoint_time_ticks =
65              PerfDataManager::create_counter(SUN_RT, "safepointTime",
66                                              PerfData::U_Ticks, CHECK);
67
68    _application_time_ticks =
69              PerfDataManager::create_counter(SUN_RT, "applicationTime",
70                                              PerfData::U_Ticks, CHECK);
71
72
73    // create performance counters for jvm_version and its capabilities
74    PerfDataManager::create_constant(SUN_RT, "jvmVersion", PerfData::U_None,
75                                     (jlong) Abstract_VM_Version::jvm_version(), CHECK);
76
77    // I/O interruption related counters
78
79    // thread signaling via os::interrupt()
80
81    _thread_interrupt_signaled_count =
82                PerfDataManager::create_counter(SUN_RT,
83                 "threadInterruptSignaled", PerfData::U_Events, CHECK);
84
85    // OS_INTRPT via "check before" in _INTERRUPTIBLE
86
87    _interrupted_before_count =
88                PerfDataManager::create_counter(SUN_RT, "interruptedBeforeIO",
89                                                PerfData::U_Events, CHECK);
90
91    // OS_INTRPT via "check during" in _INTERRUPTIBLE
92
93    _interrupted_during_count =
94                PerfDataManager::create_counter(SUN_RT, "interruptedDuringIO",
95                                                PerfData::U_Events, CHECK);
96
97    // The capabilities counter is a binary representation of the VM capabilities in string.
98    // This string respresentation simplifies the implementation of the client side
99    // to parse the value.
100    char capabilities[65];
101    size_t len = sizeof(capabilities);
102    memset((void*) capabilities, '0', len);
103    capabilities[len-1] = '\0';
104    capabilities[0] = AttachListener::is_attach_supported() ? '1' : '0';
105#if INCLUDE_SERVICES
106    capabilities[1] = '1';
107#endif // INCLUDE_SERVICES
108    PerfDataManager::create_string_constant(SUN_RT, "jvmCapabilities",
109                                            capabilities, CHECK);
110  }
111}
112
113void RuntimeService::record_safepoint_begin() {
114#ifndef USDT2
115  HS_DTRACE_PROBE(hs_private, safepoint__begin);
116#else /* USDT2 */
117  HS_PRIVATE_SAFEPOINT_BEGIN();
118#endif /* USDT2 */
119
120  // Print the time interval in which the app was executing
121  if (PrintGCApplicationConcurrentTime) {
122    gclog_or_tty->print_cr("Application time: %3.7f seconds",
123                                last_application_time_sec());
124  }
125
126  // update the time stamp to begin recording safepoint time
127  _safepoint_timer.update();
128  if (UsePerfData) {
129    _total_safepoints->inc();
130    if (_app_timer.is_updated()) {
131      _application_time_ticks->inc(_app_timer.ticks_since_update());
132    }
133  }
134}
135
136void RuntimeService::record_safepoint_synchronized() {
137  if (UsePerfData) {
138    _sync_time_ticks->inc(_safepoint_timer.ticks_since_update());
139  }
140}
141
142void RuntimeService::record_safepoint_end() {
143#ifndef USDT2
144  HS_DTRACE_PROBE(hs_private, safepoint__end);
145#else /* USDT2 */
146  HS_PRIVATE_SAFEPOINT_END();
147#endif /* USDT2 */
148
149  // Print the time interval for which the app was stopped
150  // during the current safepoint operation.
151  if (PrintGCApplicationStoppedTime) {
152    gclog_or_tty->print_cr("Total time for which application threads "
153                           "were stopped: %3.7f seconds",
154                           last_safepoint_time_sec());
155  }
156
157  // update the time stamp to begin recording app time
158  _app_timer.update();
159  if (UsePerfData) {
160    _safepoint_time_ticks->inc(_safepoint_timer.ticks_since_update());
161  }
162}
163
164void RuntimeService::record_application_start() {
165  // update the time stamp to begin recording app time
166  _app_timer.update();
167}
168
169// Don't need to record application end because we currently
170// exit at a safepoint and record_safepoint_begin() handles updating
171// the application time counter at VM exit.
172
173jlong RuntimeService::safepoint_sync_time_ms() {
174  return UsePerfData ?
175    Management::ticks_to_ms(_sync_time_ticks->get_value()) : -1;
176}
177
178jlong RuntimeService::safepoint_count() {
179  return UsePerfData ?
180    _total_safepoints->get_value() : -1;
181}
182jlong RuntimeService::safepoint_time_ms() {
183  return UsePerfData ?
184    Management::ticks_to_ms(_safepoint_time_ticks->get_value()) : -1;
185}
186
187jlong RuntimeService::application_time_ms() {
188  return UsePerfData ?
189    Management::ticks_to_ms(_application_time_ticks->get_value()) : -1;
190}
191
192void RuntimeService::record_interrupted_before_count() {
193  if (UsePerfData) {
194    _interrupted_before_count->inc();
195  }
196}
197
198void RuntimeService::record_interrupted_during_count() {
199  if (UsePerfData) {
200    _interrupted_during_count->inc();
201  }
202}
203
204void RuntimeService::record_thread_interrupt_signaled_count() {
205  if (UsePerfData) {
206    _thread_interrupt_signaled_count->inc();
207  }
208}
209
210#endif // INCLUDE_MANAGEMENT
211