1 /*
   2  * Copyright (c) 2001, 2014, 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   "java.library.path",
 227   "java.class.path",


 228   "java.version",
 229   "java.home",
 230   NULL
 231 };
 232 
 233 // unstable interface, supported counters
 234 static const char* property_counters_us[] = {
 235   NULL
 236 };
 237 
 238 // unstable interface, unsupported counters
 239 static const char* property_counters_uu[] = {
 240   "sun.boot.class.path",
 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 ---