1 /*
2 * Copyright (c) 2001, 2015, 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/systemDictionary.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "memory/allocation.inline.hpp"
29 #include "memory/resourceArea.hpp"
30 #include "oops/oop.inline.hpp"
31 #include "runtime/arguments.hpp"
32 #include "runtime/java.hpp"
33 #include "runtime/javaCalls.hpp"
34 #include "runtime/os.hpp"
35 #include "runtime/statSampler.hpp"
36 #include "runtime/vm_version.hpp"
37
38 // --------------------------------------------------------
39 // StatSamplerTask
40
41 class StatSamplerTask : public PeriodicTask {
42 public:
43 StatSamplerTask(int interval_time) : PeriodicTask(interval_time) {}
44 void task() { StatSampler::collect_sample(); }
45 };
46
47
48 //----------------------------------------------------------
49 // Implementation of StatSampler
50
51 StatSamplerTask* StatSampler::_task = NULL;
52 PerfDataList* StatSampler::_sampled = NULL;
53
54 /*
55 * the initialize method is called from the engage() method
56 * and is responsible for initializing various global variables.
57 */
58 void StatSampler::initialize() {
59
60 if (!UsePerfData) return;
61
62 // create performance data that could not be created prior
63 // to vm_init_globals() or otherwise have no logical home.
64
65 create_misc_perfdata();
66
67 // get copy of the sampled list
68 _sampled = PerfDataManager::sampled();
69
70 }
71
72 /*
73 * The engage() method is called at initialization time via
74 * Thread::create_vm() to initialize the StatSampler and
75 * register it with the WatcherThread as a periodic task.
76 */
77 void StatSampler::engage() {
78
79 if (!UsePerfData) return;
80
81 if (!is_active()) {
82
83 initialize();
84
85 // start up the periodic task
86 _task = new StatSamplerTask(PerfDataSamplingInterval);
87 _task->enroll();
88 }
89 }
90
91
92 /*
93 * the disengage() method is responsible for deactivating the periodic
94 * task and, if logging was enabled, for logging the final sample. This
95 * method is called from before_exit() in java.cpp and is only called
96 * after the WatcherThread has been stopped.
97 */
98 void StatSampler::disengage() {
99
100 if (!UsePerfData) return;
101
102 if (!is_active())
103 return;
104
105 // remove StatSamplerTask
106 _task->disenroll();
107 delete _task;
108 _task = NULL;
109
110 // force a final sample
111 sample_data(_sampled);
112 }
113
114 /*
115 * the destroy method is responsible for releasing any resources used by
116 * the StatSampler prior to shutdown of the VM. this method is called from
117 * before_exit() in java.cpp and is only called after the WatcherThread
118 * has stopped.
119 */
120 void StatSampler::destroy() {
121
122 if (!UsePerfData) return;
123
124 if (_sampled != NULL) {
125 delete(_sampled);
126 _sampled = NULL;
127 }
128 }
129
130 /*
131 * The sample_data() method is responsible for sampling the
132 * the data value for each PerfData instance in the given list.
133 */
134 void StatSampler::sample_data(PerfDataList* list) {
135
136 assert(list != NULL, "null list unexpected");
137
138 for (int index = 0; index < list->length(); index++) {
139 PerfData* item = list->at(index);
140 item->sample();
141 }
142 }
143
144 /*
145 * the collect_sample() method is the method invoked by the
146 * WatcherThread via the PeriodicTask::task() method. This method
147 * is responsible for collecting data samples from sampled
148 * PerfData instances every PerfDataSamplingInterval milliseconds.
149 * It is also responsible for logging the requested set of
150 * PerfData instances every _sample_count milliseconds. While
151 * logging data, it will output a column header after every _print_header
152 * rows of data have been logged.
153 */
154 void StatSampler::collect_sample() {
155
156 // future - check for new PerfData objects. PerfData objects might
157 // get added to the PerfDataManager lists after we have already
158 // built our local copies.
159 //
160 // if (PerfDataManager::count() > previous) {
161 // // get a new copy of the sampled list
162 // if (_sampled != NULL) {
163 // delete(_sampled);
164 // _sampled = NULL;
165 // }
166 // _sampled = PerfDataManager::sampled();
167 // }
168
169 assert(_sampled != NULL, "list not initialized");
170
171 sample_data(_sampled);
172 }
173
174 /*
175 * method to upcall into Java to return the value of the specified
176 * property as a utf8 string, or NULL if does not exist. The caller
177 * is responsible for setting a ResourceMark for proper cleanup of
178 * the utf8 strings.
179 */
180 const char* StatSampler::get_system_property(const char* name, TRAPS) {
181
182 // setup the arguments to getProperty
183 Handle key_str = java_lang_String::create_from_str(name, CHECK_NULL);
184
185 // return value
186 JavaValue result(T_OBJECT);
187
188 // public static String getProperty(String key, String def);
189 JavaCalls::call_static(&result,
190 KlassHandle(THREAD, SystemDictionary::System_klass()),
191 vmSymbols::getProperty_name(),
192 vmSymbols::string_string_signature(),
193 key_str,
194 CHECK_NULL);
195
196 oop value_oop = (oop)result.get_jobject();
197 if (value_oop == NULL) {
198 return NULL;
199 }
200
201 // convert Java String to utf8 string
202 char* value = java_lang_String::as_utf8_string(value_oop);
203
204 return value;
205 }
206
207 /*
208 * The list of System Properties that have corresponding PerfData
209 * string instrumentation created by retrieving the named property's
210 * value from System.getProperty() and unconditionally creating a
211 * PerfStringConstant object initialized to the retrieved value. This
212 * is not an exhaustive list of Java properties with corresponding string
213 * instrumentation as the create_system_property_instrumentation() method
214 * creates other property based instrumentation conditionally.
215 */
216
217 // stable interface, supported counters
218 static const char* property_counters_ss[] = {
219 "java.vm.specification.version",
220 "java.vm.specification.name",
221 "java.vm.specification.vendor",
222 "java.vm.version",
223 "java.vm.name",
224 "java.vm.vendor",
225 "java.vm.info",
226 "jdk.debug",
227 "java.library.path",
228 "java.class.path",
229 "java.version",
230 "java.home",
231 NULL
232 };
233
234 // unstable interface, supported counters
235 static const char* property_counters_us[] = {
236 NULL
237 };
238
239 // unstable interface, unsupported counters
240 static const char* property_counters_uu[] = {
241 "sun.boot.library.path",
242 NULL
243 };
244
245 typedef struct {
246 const char** property_list;
247 CounterNS name_space;
248 } PropertyCounters;
249
250 static PropertyCounters property_counters[] = {
251 { property_counters_ss, JAVA_PROPERTY },
252 { property_counters_us, COM_PROPERTY },
253 { property_counters_uu, SUN_PROPERTY },
254 { NULL, SUN_PROPERTY }
255 };
256
257
258 /*
259 * Method to create PerfData string instruments that contain the values
260 * of various system properties. String instruments are created for each
261 * property specified in the property lists provided in property_counters[].
262 * Property counters have a counter name space prefix prepended to the
263 * property name as indicated in property_counters[].
264 */
265 void StatSampler::create_system_property_instrumentation(TRAPS) {
266
267 ResourceMark rm;
268
269 for (int i = 0; property_counters[i].property_list != NULL; i++) {
270
271 for (int j = 0; property_counters[i].property_list[j] != NULL; j++) {
272
273 const char* property_name = property_counters[i].property_list[j];
274 assert(property_name != NULL, "property name should not be NULL");
275
276 const char* value = get_system_property(property_name, CHECK);
277
278 // the property must exist
279 assert(value != NULL, "property name should be valid");
280
281 if (value != NULL) {
282 // create the property counter
283 PerfDataManager::create_string_constant(property_counters[i].name_space,
284 property_name, value, CHECK);
285 }
286 }
287 }
288 }
289
290 /*
291 * The create_misc_perfdata() method provides a place to create
292 * PerfData instances that would otherwise have no better place
293 * to exist.
294 */
295 void StatSampler::create_misc_perfdata() {
296
297 ResourceMark rm;
298 EXCEPTION_MARK;
299
300 // numeric constants
301
302 // frequency of the native high resolution timer
303 PerfDataManager::create_constant(SUN_OS, "hrt.frequency",
304 PerfData::U_Hertz, os::elapsed_frequency(),
305 CHECK);
306
307 // string constants
308
309 // create string instrumentation for various Java properties.
310 create_system_property_instrumentation(CHECK);
311
312 // HotSpot flags (from .hotspotrc) and args (from command line)
313 //
314 PerfDataManager::create_string_constant(JAVA_RT, "vmFlags",
315 Arguments::jvm_flags(), CHECK);
316 PerfDataManager::create_string_constant(JAVA_RT, "vmArgs",
317 Arguments::jvm_args(), CHECK);
318
319 // java class name/jar file and arguments to main class
320 // note: name is cooridnated with launcher and Arguments.cpp
321 PerfDataManager::create_string_constant(SUN_RT, "javaCommand",
322 Arguments::java_command(), CHECK);
323
324 // the Java VM Internal version string
325 PerfDataManager::create_string_constant(SUN_RT, "internalVersion",
326 VM_Version::internal_vm_info_string(),
327 CHECK);
328
329 // create sampled instrumentation objects
330 create_sampled_perfdata();
331 }
332
333 /*
334 * helper class to provide for sampling of the elapsed_counter value
335 * maintained in the OS class.
336 */
337 class HighResTimeSampler : public PerfSampleHelper {
338 public:
339 jlong take_sample() { return os::elapsed_counter(); }
340 };
341
342 /*
343 * the create_sampled_perdata() method provides a place to instantiate
344 * sampled PerfData instances that would otherwise have no better place
345 * to exist.
346 */
347 void StatSampler::create_sampled_perfdata() {
348
349 EXCEPTION_MARK;
350
351 // setup sampling of the elapsed time counter maintained in the
352 // the os class. This counter can be used as either a time stamp
353 // for each logged entry or as a liveness indicator for the VM.
354 PerfSampleHelper* psh = new HighResTimeSampler();
355 PerfDataManager::create_counter(SUN_OS, "hrt.ticks",
356 PerfData::U_Ticks, psh, CHECK);
357 }
358
359 /*
360 * the statSampler_exit() function is called from os_init.cpp on
361 * exit of the vm.
362 */
363 void statSampler_exit() {
364
365 if (!UsePerfData) return;
366
367 StatSampler::destroy();
368 }
--- EOF ---