1 /*
2 * Copyright (c) 2001, 2010, 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 #ifndef SHARE_VM_RUNTIME_PERFDATA_HPP
26 #define SHARE_VM_RUNTIME_PERFDATA_HPP
27
28 #include "memory/allocation.inline.hpp"
29 #include "runtime/perfMemory.hpp"
30 #include "runtime/timer.hpp"
31 #include "utilities/growableArray.hpp"
32
33 /* jvmstat global and subsystem counter name space - enumeration value
34 * serve as an index into the PerfDataManager::_name_space[] array
35 * containing the corresponding name space string. Only the top level
36 * subsystem name spaces are represented here.
37 */
38 enum CounterNS {
39 // top level name spaces
40 JAVA_NS,
41 COM_NS,
42 SUN_NS,
43 // subsystem name spaces
44 JAVA_GC, // Garbage Collection name spaces
45 COM_GC,
46 SUN_GC,
47 JAVA_CI, // Compiler name spaces
48 COM_CI,
49 SUN_CI,
50 JAVA_CLS, // Class Loader name spaces
51 COM_CLS,
52 SUN_CLS,
53 JAVA_RT, // Runtime name spaces
54 COM_RT,
55 SUN_RT,
56 JAVA_OS, // Operating System name spaces
57 COM_OS,
58 SUN_OS,
59 JAVA_THREADS, // Threads System name spaces
60 COM_THREADS,
61 SUN_THREADS,
62 JAVA_PROPERTY, // Java Property name spaces
63 COM_PROPERTY,
64 SUN_PROPERTY,
65 NULL_NS,
66 COUNTERNS_LAST = NULL_NS
67 };
68
69 /*
70 * Classes to support access to production performance data
71 *
72 * The PerfData class structure is provided for creation, access, and update
73 * of performance data (a.k.a. instrumentation) in a specific memory region
74 * which is possibly accessible as shared memory. Although not explicitly
75 * prevented from doing so, developers should not use the values returned
76 * by accessor methods to make algorithmic decisions as they are potentially
77 * extracted from a shared memory region. Although any shared memory region
78 * created is with appropriate access restrictions, allowing read-write access
79 * only to the principal that created the JVM, it is believed that a the
80 * shared memory region facilitates an easier attack path than attacks
81 * launched through mechanisms such as /proc. For this reason, it is
82 * recommended that data returned by PerfData accessor methods be used
83 * cautiously.
84 *
85 * There are three variability classifications of performance data
86 * Constants - value is written to the PerfData memory once, on creation
87 * Variables - value is modifiable, with no particular restrictions
88 * Counters - value is monotonically changing (increasing or decreasing)
89 *
90 * The performance data items can also have various types. The class
91 * hierarchy and the structure of the memory region are designed to
92 * accommodate new types as they are needed. Types are specified in
93 * terms of Java basic types, which accommodates client applications
94 * written in the Java programming language. The class hierarchy is:
95 *
96 * - PerfData (Abstract)
97 * - PerfLong (Abstract)
98 * - PerfLongConstant (alias: PerfConstant)
99 * - PerfLongVariant (Abstract)
100 * - PerfLongVariable (alias: PerfVariable)
101 * - PerfLongCounter (alias: PerfCounter)
102 *
103 * - PerfByteArray (Abstract)
104 * - PerfString (Abstract)
105 * - PerfStringVariable
106 * - PerfStringConstant
107 *
108 *
109 * As seen in the class hierarchy, the initially supported types are:
110 *
111 * Long - performance data holds a Java long type
112 * ByteArray - performance data holds an array of Java bytes
113 * used for holding C++ char arrays.
114 *
115 * The String type is derived from the ByteArray type.
116 *
117 * A PerfData subtype is not required to provide an implementation for
118 * each variability classification. For example, the String type provides
119 * Variable and Constant variablility classifications in the PerfStringVariable
120 * and PerfStringConstant classes, but does not provide a counter type.
121 *
122 * Performance data are also described by a unit of measure. Units allow
123 * client applications to make reasonable decisions on how to treat
124 * performance data generically, preventing the need to hard-code the
125 * specifics of a particular data item in client applications. The current
126 * set of units are:
127 *
128 * None - the data has no units of measure
129 * Bytes - data is measured in bytes
130 * Ticks - data is measured in clock ticks
131 * Events - data is measured in events. For example,
132 * the number of garbage collection events or the
133 * number of methods compiled.
134 * String - data is not numerical. For example,
135 * the java command line options
136 * Hertz - data is a frequency
137 *
138 * The performance counters also provide a support attribute, indicating
139 * the stability of the counter as a programmatic interface. The support
140 * level is also implied by the name space in which the counter is created.
141 * The counter name space support conventions follow the Java package, class,
142 * and property support conventions:
143 *
144 * java.* - stable, supported interface
145 * com.sun.* - unstable, supported interface
146 * sun.* - unstable, unsupported interface
147 *
148 * In the above context, unstable is a measure of the interface support
149 * level, not the implementation stability level.
150 *
151 * Currently, instances of PerfData subtypes are considered to have
152 * a life time equal to that of the VM and are managed by the
153 * PerfDataManager class. All constructors for the PerfData class and
154 * its subtypes have protected constructors. Creation of PerfData
155 * instances is performed by invoking various create methods on the
156 * PerfDataManager class. Users should not attempt to delete these
157 * instances as the PerfDataManager class expects to perform deletion
158 * operations on exit of the VM.
159 *
160 * Examples:
161 *
162 * Creating performance counter that holds a monotonically increasing
163 * long data value with units specified in U_Bytes in the "java.gc.*"
164 * name space.
165 *
166 * PerfLongCounter* foo_counter;
167 *
168 * foo_counter = PerfDataManager::create_long_counter(JAVA_GC, "foo",
169 * PerfData::U_Bytes,
170 * optionalInitialValue,
171 * CHECK);
172 * foo_counter->inc();
173 *
174 * Creating a performance counter that holds a variably change long
175 * data value with untis specified in U_Bytes in the "com.sun.ci
176 * name space.
177 *
178 * PerfLongVariable* bar_varible;
179 * bar_variable = PerfDataManager::create_long_variable(COM_CI, "bar",
180 .* PerfData::U_Bytes,
181 * optionalInitialValue,
182 * CHECK);
183 *
184 * bar_variable->inc();
185 * bar_variable->set_value(0);
186 *
187 * Creating a performance counter that holds a constant string value in
188 * the "sun.cls.*" name space.
189 *
190 * PerfDataManager::create_string_constant(SUN_CLS, "foo", string, CHECK);
191 *
192 * Although the create_string_constant() factory method returns a pointer
193 * to the PerfStringConstant object, it can safely be ignored. Developers
194 * are not encouraged to access the string constant's value via this
195 * pointer at this time due to security concerns.
196 *
197 * Creating a performance counter in an arbitrary name space that holds a
198 * value that is sampled by the StatSampler periodic task.
199 *
200 * PerfDataManager::create_counter("foo.sampled", PerfData::U_Events,
201 * &my_jlong, CHECK);
202 *
203 * In this example, the PerfData pointer can be ignored as the caller
204 * is relying on the StatSampler PeriodicTask to sample the given
205 * address at a regular interval. The interval is defined by the
206 * PerfDataSamplingInterval global variable, and is applyied on
207 * a system wide basis, not on an per-counter basis.
208 *
209 * Creating a performance counter in an arbitrary name space that utilizes
210 * a helper object to return a value to the StatSampler via the take_sample()
211 * method.
212 *
213 * class MyTimeSampler : public PerfLongSampleHelper {
214 * public:
215 * jlong take_sample() { return os::elapsed_counter(); }
216 * };
217 *
218 * PerfDataManager::create_counter(SUN_RT, "helped",
219 * PerfData::U_Ticks,
220 * new MyTimeSampler(), CHECK);
221 *
222 * In this example, a subtype of PerfLongSampleHelper is instantiated
223 * and its take_sample() method is overridden to perform whatever
224 * operation is necessary to generate the data sample. This method
225 * will be called by the StatSampler at a regular interval, defined
226 * by the PerfDataSamplingInterval global variable.
227 *
228 * As before, PerfSampleHelper is an alias for PerfLongSampleHelper.
229 *
230 * For additional uses of PerfData subtypes, see the utility classes
231 * PerfTraceTime and PerfTraceTimedEvent below.
232 *
233 * Always-on non-sampled counters can be created independent of
234 * the UsePerfData flag. Counters will be created on the c-heap
235 * if UsePerfData is false.
236 *
237 * Until further noice, all PerfData objects should be created and
238 * manipulated within a guarded block. The guard variable is
239 * UsePerfData, a product flag set to true by default. This flag may
240 * be removed from the product in the future.
241 *
242 */
243 class PerfData : public CHeapObj<mtInternal> {
244
245 friend class StatSampler; // for access to protected void sample()
246 friend class PerfDataManager; // for access to protected destructor
247
248 public:
249
250 // the Variability enum must be kept in synchronization with the
251 // the com.sun.hotspot.perfdata.Variability class
252 enum Variability {
253 V_Constant = 1,
254 V_Monotonic = 2,
255 V_Variable = 3,
256 V_last = V_Variable
257 };
258
259 // the Units enum must be kept in synchronization with the
260 // the com.sun.hotspot.perfdata.Units class
261 enum Units {
262 U_None = 1,
263 U_Bytes = 2,
264 U_Ticks = 3,
265 U_Events = 4,
266 U_String = 5,
267 U_Hertz = 6,
268 U_Last = U_Hertz
269 };
270
271 // Miscellaneous flags
272 enum Flags {
273 F_None = 0x0,
274 F_Supported = 0x1 // interface is supported - java.* and com.sun.*
275 };
276
277 private:
278 char* _name;
279 Variability _v;
280 Units _u;
281 bool _on_c_heap;
282 Flags _flags;
283
284 PerfDataEntry* _pdep;
285
286 protected:
287
288 void *_valuep;
289
290 PerfData(CounterNS ns, const char* name, Units u, Variability v);
291 ~PerfData();
292
293 // create the entry for the PerfData item in the PerfData memory region.
294 // this region is maintained separately from the PerfData objects to
295 // facilitate its use by external processes.
296 void create_entry(BasicType dtype, size_t dsize, size_t dlen = 0);
297
298 // sample the data item given at creation time and write its value
299 // into the its corresponding PerfMemory location.
300 virtual void sample() = 0;
301
302 public:
303
304 // returns a boolean indicating the validity of this object.
305 // the object is valid if and only if memory in PerfMemory
306 // region was successfully allocated.
307 inline bool is_valid() { return _valuep != NULL; }
308
309 // returns a boolean indicating whether the underlying object
310 // was allocated in the PerfMemory region or on the C heap.
311 inline bool is_on_c_heap() { return _on_c_heap; }
312
313 // returns a pointer to a char* containing the name of the item.
314 // The pointer returned is the pointer to a copy of the name
315 // passed to the constructor, not the pointer to the name in the
316 // PerfData memory region. This redundancy is maintained for
317 // security reasons as the PerfMemory region may be in shared
318 // memory.
319 const char* name() { return _name; }
320
321 // returns the variability classification associated with this item
322 Variability variability() { return _v; }
323
324 // returns the units associated with this item.
325 Units units() { return _u; }
326
327 // returns the flags associated with this item.
328 Flags flags() { return _flags; }
329
330 // returns the address of the data portion of the item in the
331 // PerfData memory region.
332 inline void* get_address() { return _valuep; }
333
334 // returns the value of the data portion of the item in the
335 // PerfData memory region formatted as a string.
336 virtual int format(char* cp, int length) = 0;
337 };
338
339 /*
340 * PerfLongSampleHelper, and its alias PerfSamplerHelper, is a base class
341 * for helper classes that rely upon the StatSampler periodic task to
342 * invoke the take_sample() method and write the value returned to its
343 * appropriate location in the PerfData memory region.
344 */
345 class PerfLongSampleHelper : public CHeapObj<mtInternal> {
346 public:
347 virtual jlong take_sample() = 0;
348 };
349
350 typedef PerfLongSampleHelper PerfSampleHelper;
351
352
353 /*
354 * PerfLong is the base class for the various Long PerfData subtypes.
355 * it contains implementation details that are common among its derived
356 * types.
357 */
358 class PerfLong : public PerfData {
359
360 protected:
361
362 PerfLong(CounterNS ns, const char* namep, Units u, Variability v);
363
364 public:
365 int format(char* buffer, int length);
366
367 // returns the value of the data portion of the item in the
368 // PerfData memory region.
369 inline jlong get_value() { return *(jlong*)_valuep; }
370 };
371
372 /*
373 * The PerfLongConstant class, and its alias PerfConstant, implement
374 * a PerfData subtype that holds a jlong data value that is set upon
375 * creation of an instance of this class. This class provides no
376 * methods for changing the data value stored in PerfData memory region.
377 */
378 class PerfLongConstant : public PerfLong {
379
380 friend class PerfDataManager; // for access to protected constructor
381
382 private:
383 // hide sample() - no need to sample constants
384 void sample() { }
385
386 protected:
387
388 PerfLongConstant(CounterNS ns, const char* namep, Units u,
389 jlong initial_value=0)
390 : PerfLong(ns, namep, u, V_Constant) {
391
392 if (is_valid()) *(jlong*)_valuep = initial_value;
393 }
394 };
395
396 typedef PerfLongConstant PerfConstant;
397
398 /*
399 * The PerfLongVariant class, and its alias PerfVariant, implement
400 * a PerfData subtype that holds a jlong data value that can be modified
401 * in an unrestricted manner. This class provides the implementation details
402 * for common functionality among its derived types.
403 */
404 class PerfLongVariant : public PerfLong {
405
406 protected:
407 jlong* _sampled;
408 PerfLongSampleHelper* _sample_helper;
409
410 PerfLongVariant(CounterNS ns, const char* namep, Units u, Variability v,
411 jlong initial_value=0)
412 : PerfLong(ns, namep, u, v) {
413 if (is_valid()) *(jlong*)_valuep = initial_value;
414 }
415
416 PerfLongVariant(CounterNS ns, const char* namep, Units u, Variability v,
417 jlong* sampled);
418
419 PerfLongVariant(CounterNS ns, const char* namep, Units u, Variability v,
420 PerfLongSampleHelper* sample_helper);
421
422 void sample();
423
424 public:
425 inline void inc() { (*(jlong*)_valuep)++; }
426 inline void inc(jlong val) { (*(jlong*)_valuep) += val; }
427 inline void add(jlong val) { (*(jlong*)_valuep) += val; }
428 };
429
430 /*
431 * The PerfLongCounter class, and its alias PerfCounter, implement
432 * a PerfData subtype that holds a jlong data value that can (should)
433 * be modified in a monotonic manner. The inc(jlong) and add(jlong)
434 * methods can be passed negative values to implement a monotonically
435 * decreasing value. However, we rely upon the programmer to honor
436 * the notion that this counter always moves in the same direction -
437 * either increasing or decreasing.
438 */
439 class PerfLongCounter : public PerfLongVariant {
440
441 friend class PerfDataManager; // for access to protected constructor
442
443 protected:
444
445 PerfLongCounter(CounterNS ns, const char* namep, Units u,
446 jlong initial_value=0)
447 : PerfLongVariant(ns, namep, u, V_Monotonic,
448 initial_value) { }
449
450 PerfLongCounter(CounterNS ns, const char* namep, Units u, jlong* sampled)
451 : PerfLongVariant(ns, namep, u, V_Monotonic, sampled) { }
452
453 PerfLongCounter(CounterNS ns, const char* namep, Units u,
454 PerfLongSampleHelper* sample_helper)
455 : PerfLongVariant(ns, namep, u, V_Monotonic,
456 sample_helper) { }
457 };
458
459 typedef PerfLongCounter PerfCounter;
460
461 /*
462 * The PerfLongVariable class, and its alias PerfVariable, implement
463 * a PerfData subtype that holds a jlong data value that can
464 * be modified in an unrestricted manner.
465 */
466 class PerfLongVariable : public PerfLongVariant {
467
468 friend class PerfDataManager; // for access to protected constructor
469
470 protected:
471
472 PerfLongVariable(CounterNS ns, const char* namep, Units u,
473 jlong initial_value=0)
474 : PerfLongVariant(ns, namep, u, V_Variable,
475 initial_value) { }
476
477 PerfLongVariable(CounterNS ns, const char* namep, Units u, jlong* sampled)
478 : PerfLongVariant(ns, namep, u, V_Variable, sampled) { }
479
480 PerfLongVariable(CounterNS ns, const char* namep, Units u,
481 PerfLongSampleHelper* sample_helper)
482 : PerfLongVariant(ns, namep, u, V_Variable,
483 sample_helper) { }
484
485 public:
486 inline void set_value(jlong val) { (*(jlong*)_valuep) = val; }
487 };
488
489 typedef PerfLongVariable PerfVariable;
490
491 /*
492 * The PerfByteArray provides a PerfData subtype that allows the creation
493 * of a contiguous region of the PerfData memory region for storing a vector
494 * of bytes. This class is currently intended to be a base class for
495 * the PerfString class, and cannot be instantiated directly.
496 */
497 class PerfByteArray : public PerfData {
498
499 protected:
500 jint _length;
501
502 PerfByteArray(CounterNS ns, const char* namep, Units u, Variability v,
503 jint length);
504 };
505
506 class PerfString : public PerfByteArray {
507
508 protected:
509
510 void set_string(const char* s2);
511
512 PerfString(CounterNS ns, const char* namep, Variability v, jint length,
513 const char* initial_value)
514 : PerfByteArray(ns, namep, U_String, v, length) {
515 if (is_valid()) set_string(initial_value);
516 }
517
518 public:
519
520 int format(char* buffer, int length);
521 };
522
523 /*
524 * The PerfStringConstant class provides a PerfData sub class that
525 * allows a null terminated string of single byte characters to be
526 * stored in the PerfData memory region.
527 */
528 class PerfStringConstant : public PerfString {
529
530 friend class PerfDataManager; // for access to protected constructor
531
532 private:
533
534 // hide sample() - no need to sample constants
535 void sample() { }
536
537 protected:
538
539 // Restrict string constant lengths to be <= PerfMaxStringConstLength.
540 // This prevents long string constants, as can occur with very
541 // long classpaths or java command lines, from consuming too much
542 // PerfData memory.
543 PerfStringConstant(CounterNS ns, const char* namep,
544 const char* initial_value);
545 };
546
547 /*
548 * The PerfStringVariable class provides a PerfData sub class that
549 * allows a null terminated string of single byte character data
550 * to be stored in PerfData memory region. The string value can be reset
551 * after initialization. If the string value is >= max_length, then
552 * it will be truncated to max_length characters. The copied string
553 * is always null terminated.
554 */
555 class PerfStringVariable : public PerfString {
556
557 friend class PerfDataManager; // for access to protected constructor
558
559 protected:
560
561 // sampling of string variables are not yet supported
562 void sample() { }
563
564 PerfStringVariable(CounterNS ns, const char* namep, jint max_length,
565 const char* initial_value)
566 : PerfString(ns, namep, V_Variable, max_length+1,
567 initial_value) { }
568
569 public:
570 inline void set_value(const char* val) { set_string(val); }
571 };
572
573
574 /*
575 * The PerfDataList class is a container class for managing lists
576 * of PerfData items. The intention of this class is to allow for
577 * alternative implementations for management of list of PerfData
578 * items without impacting the code that uses the lists.
579 *
580 * The initial implementation is based upon GrowableArray. Searches
581 * on GrowableArray types is linear in nature and this may become
582 * a performance issue for creation of PerfData items, particularly
583 * from Java code where a test for existence is implemented as a
584 * search over all existing PerfData items.
585 *
586 * The abstraction is not complete. A more general container class
587 * would provide an Iterator abstraction that could be used to
588 * traverse the lists. This implementation still relys upon integer
589 * iterators and the at(int index) method. However, the GrowableArray
590 * is not directly visible outside this class and can be replaced by
591 * some other implementation, as long as that implementation provides
592 * a mechanism to iterate over the container by index.
593 */
594 class PerfDataList : public CHeapObj<mtInternal> {
595
596 private:
597
598 // GrowableArray implementation
599 typedef GrowableArray<PerfData*> PerfDataArray;
600
601 PerfDataArray* _set;
602
603 // method to search for a instrumentation object by name
604 static bool by_name(void* name, PerfData* pd);
605
606 protected:
607 // we expose the implementation here to facilitate the clone
608 // method.
609 PerfDataArray* get_impl() { return _set; }
610
611 public:
612
613 // create a PerfDataList with the given initial length
614 PerfDataList(int length);
615
616 // create a PerfDataList as a shallow copy of the given PerfDataList
617 PerfDataList(PerfDataList* p);
618
619 ~PerfDataList();
620
621 // return the PerfData item indicated by name,
622 // or NULL if it doesn't exist.
623 PerfData* find_by_name(const char* name);
624
625 // return true if a PerfData item with the name specified in the
626 // argument exists, otherwise return false.
627 bool contains(const char* name) { return find_by_name(name) != NULL; }
628
629 // return the number of PerfData items in this list
630 int length() { return _set->length(); }
631
632 // add a PerfData item to this list
633 void append(PerfData *p) { _set->append(p); }
634
635 // remove the given PerfData item from this list. When called
636 // while iterating over the list, this method will result in a
637 // change in the length of the container. The at(int index)
638 // method is also impacted by this method as elements with an
639 // index greater than the index of the element removed by this
640 // method will be shifted down by one.
641 void remove(PerfData *p) { _set->remove(p); }
642
643 // create a new PerfDataList from this list. The new list is
644 // a shallow copy of the original list and care should be taken
645 // with respect to delete operations on the elements of the list
646 // as the are likely in use by another copy of the list.
647 PerfDataList* clone();
648
649 // for backward compatibility with GrowableArray - need to implement
650 // some form of iterator to provide a cleaner abstraction for
651 // iteration over the container.
652 PerfData* at(int index) { return _set->at(index); }
653 };
654
655
656 /*
657 * The PerfDataManager class is responsible for creating PerfData
658 * subtypes via a set a factory methods and for managing lists
659 * of the various PerfData types.
660 */
661 class PerfDataManager : AllStatic {
662
663 friend class StatSampler; // for access to protected PerfDataList methods
664
665 private:
666 static PerfDataList* _all;
667 static PerfDataList* _sampled;
668 static PerfDataList* _constants;
669 static const char* _name_spaces[];
670
671 // add a PerfData item to the list(s) of know PerfData objects
672 static void add_item(PerfData* p, bool sampled);
673
674 protected:
675 // return the list of all known PerfData items
676 static PerfDataList* all();
677 static int count() { return _all->length(); }
678
679 // return the list of all known PerfData items that are to be
680 // sampled by the StatSampler.
681 static PerfDataList* sampled();
682 static int sampled_count() { return _sampled->length(); }
683
684 // return the list of all known PerfData items that have a
685 // variability classification of type Constant
686 static PerfDataList* constants();
687 static int constants_count() { return _constants->length(); }
688
689 public:
690
691 // method to check for the existence of a PerfData item with
692 // the given name.
693 static bool exists(const char* name) { return _all->contains(name); }
694
695 // method to search for a instrumentation object by name
696 static PerfData* find_by_name(const char* name);
697
698 // method to map a CounterNS enumeration to a namespace string
699 static const char* ns_to_string(CounterNS ns) {
700 return _name_spaces[ns];
701 }
702
703 // methods to test the interface stability of a given counter namespace
704 //
705 static bool is_stable_supported(CounterNS ns) {
706 return (ns != NULL_NS) && ((ns % 3) == JAVA_NS);
707 }
708 static bool is_unstable_supported(CounterNS ns) {
709 return (ns != NULL_NS) && ((ns % 3) == COM_NS);
710 }
711 static bool is_unstable_unsupported(CounterNS ns) {
712 return (ns == NULL_NS) || ((ns % 3) == SUN_NS);
713 }
714
715 // methods to test the interface stability of a given counter name
716 //
717 static bool is_stable_supported(const char* name) {
718 const char* javadot = "java.";
719 return strncmp(name, javadot, strlen(javadot)) == 0;
720 }
721 static bool is_unstable_supported(const char* name) {
722 const char* comdot = "com.sun.";
723 return strncmp(name, comdot, strlen(comdot)) == 0;
724 }
725 static bool is_unstable_unsupported(const char* name) {
726 return !(is_stable_supported(name) && is_unstable_supported(name));
727 }
728
729 // method to construct counter name strings in a given name space.
730 // The string object is allocated from the Resource Area and calls
731 // to this method must be made within a ResourceMark.
732 //
733 static char* counter_name(const char* name_space, const char* name);
734
735 // method to construct name space strings in a given name space.
736 // The string object is allocated from the Resource Area and calls
737 // to this method must be made within a ResourceMark.
738 //
739 static char* name_space(const char* name_space, const char* sub_space) {
740 return counter_name(name_space, sub_space);
741 }
742
743 // same as above, but appends the instance number to the name space
744 //
745 static char* name_space(const char* name_space, const char* sub_space,
746 int instance);
747 static char* name_space(const char* name_space, int instance);
748
749
750 // these methods provide the general interface for creating
751 // performance data resources. The types of performance data
752 // resources can be extended by adding additional create<type>
753 // methods.
754
755 // Constant Types
756 static PerfStringConstant* create_string_constant(CounterNS ns,
757 const char* name,
758 const char *s, TRAPS);
759
760 static PerfLongConstant* create_long_constant(CounterNS ns,
761 const char* name,
762 PerfData::Units u,
763 jlong val, TRAPS);
764
765
766 // Variable Types
767 static PerfStringVariable* create_string_variable(CounterNS ns,
768 const char* name,
769 int max_length,
770 const char *s, TRAPS);
771
772 static PerfStringVariable* create_string_variable(CounterNS ns,
773 const char* name,
774 const char *s, TRAPS) {
775 return create_string_variable(ns, name, 0, s, CHECK_NULL);
776 };
777
778 static PerfLongVariable* create_long_variable(CounterNS ns,
779 const char* name,
780 PerfData::Units u,
781 jlong ival, TRAPS);
782
783 static PerfLongVariable* create_long_variable(CounterNS ns,
784 const char* name,
785 PerfData::Units u, TRAPS) {
786 return create_long_variable(ns, name, u, (jlong)0, CHECK_NULL);
787 };
788
789 static PerfLongVariable* create_long_variable(CounterNS, const char* name,
790 PerfData::Units u,
791 jlong* sp, TRAPS);
792
793 static PerfLongVariable* create_long_variable(CounterNS ns,
794 const char* name,
795 PerfData::Units u,
796 PerfLongSampleHelper* sh,
797 TRAPS);
798
799
800 // Counter Types
801 static PerfLongCounter* create_long_counter(CounterNS ns, const char* name,
802 PerfData::Units u,
803 jlong ival, TRAPS);
804
805 static PerfLongCounter* create_long_counter(CounterNS ns, const char* name,
806 PerfData::Units u, TRAPS) {
807 return create_long_counter(ns, name, u, (jlong)0, CHECK_NULL);
808 };
809
810 static PerfLongCounter* create_long_counter(CounterNS ns, const char* name,
811 PerfData::Units u, jlong* sp,
812 TRAPS);
813
814 static PerfLongCounter* create_long_counter(CounterNS ns, const char* name,
815 PerfData::Units u,
816 PerfLongSampleHelper* sh,
817 TRAPS);
818
819
820 // these creation methods are provided for ease of use. These allow
821 // Long performance data types to be created with a shorthand syntax.
822
823 static PerfConstant* create_constant(CounterNS ns, const char* name,
824 PerfData::Units u, jlong val, TRAPS) {
825 return create_long_constant(ns, name, u, val, CHECK_NULL);
826 }
827
828 static PerfVariable* create_variable(CounterNS ns, const char* name,
829 PerfData::Units u, jlong ival, TRAPS) {
830 return create_long_variable(ns, name, u, ival, CHECK_NULL);
831 }
832
833 static PerfVariable* create_variable(CounterNS ns, const char* name,
834 PerfData::Units u, TRAPS) {
835 return create_long_variable(ns, name, u, (jlong)0, CHECK_NULL);
836 }
837
838 static PerfVariable* create_variable(CounterNS ns, const char* name,
839 PerfData::Units u, jlong* sp, TRAPS) {
840 return create_long_variable(ns, name, u, sp, CHECK_NULL);
841 }
842
843 static PerfVariable* create_variable(CounterNS ns, const char* name,
844 PerfData::Units u,
845 PerfSampleHelper* sh, TRAPS) {
846 return create_long_variable(ns, name, u, sh, CHECK_NULL);
847 }
848
849 static PerfCounter* create_counter(CounterNS ns, const char* name,
850 PerfData::Units u, jlong ival, TRAPS) {
851 return create_long_counter(ns, name, u, ival, CHECK_NULL);
852 }
853
854 static PerfCounter* create_counter(CounterNS ns, const char* name,
855 PerfData::Units u, TRAPS) {
856 return create_long_counter(ns, name, u, (jlong)0, CHECK_NULL);
857 }
858
859 static PerfCounter* create_counter(CounterNS ns, const char* name,
860 PerfData::Units u, jlong* sp, TRAPS) {
861 return create_long_counter(ns, name, u, sp, CHECK_NULL);
862 }
863
864 static PerfCounter* create_counter(CounterNS ns, const char* name,
865 PerfData::Units u,
866 PerfSampleHelper* sh, TRAPS) {
867 return create_long_counter(ns, name, u, sh, CHECK_NULL);
868 }
869
870 static void destroy();
871 };
872
873 // Useful macros to create the performance counters
874 #define NEWPERFTICKCOUNTER(counter, counter_ns, counter_name) \
875 {counter = PerfDataManager::create_counter(counter_ns, counter_name, \
876 PerfData::U_Ticks,CHECK);}
877
878 #define NEWPERFEVENTCOUNTER(counter, counter_ns, counter_name) \
879 {counter = PerfDataManager::create_counter(counter_ns, counter_name, \
880 PerfData::U_Events,CHECK);}
881
882 #define NEWPERFBYTECOUNTER(counter, counter_ns, counter_name) \
883 {counter = PerfDataManager::create_counter(counter_ns, counter_name, \
884 PerfData::U_Bytes,CHECK);}
885
886 // Utility Classes
887
888 /*
889 * this class will administer a PerfCounter used as a time accumulator
890 * for a basic block much like the TraceTime class.
891 *
892 * Example:
893 *
894 * static PerfCounter* my_time_counter = PerfDataManager::create_counter("my.time.counter", PerfData::U_Ticks, 0LL, CHECK);
895 *
896 * {
897 * PerfTraceTime ptt(my_time_counter);
898 * // perform the operation you want to measure
899 * }
900 *
901 * Note: use of this class does not need to occur within a guarded
902 * block. The UsePerfData guard is used with the implementation
903 * of this class.
904 */
905 class PerfTraceTime : public StackObj {
906
907 protected:
908 elapsedTimer _t;
909 PerfLongCounter* _timerp;
910 // pointer to thread-local or global recursion counter variable
911 int* _recursion_counter;
912
913 public:
914 inline PerfTraceTime(PerfLongCounter* timerp) : _timerp(timerp), _recursion_counter(NULL) {
915 if (!UsePerfData) return;
916 _t.start();
917 }
918
919 inline PerfTraceTime(PerfLongCounter* timerp, int* recursion_counter) : _timerp(timerp), _recursion_counter(recursion_counter) {
920 if (!UsePerfData || (_recursion_counter != NULL &&
921 (*_recursion_counter)++ > 0)) return;
922 _t.start();
923 }
924
925 inline void suspend() { if (!UsePerfData) return; _t.stop(); }
926 inline void resume() { if (!UsePerfData) return; _t.start(); }
927
928 inline ~PerfTraceTime() {
929 if (!UsePerfData || (_recursion_counter != NULL &&
930 --(*_recursion_counter) > 0)) return;
931 _t.stop();
932 _timerp->inc(_t.ticks());
933 }
934 };
935
936 /* The PerfTraceTimedEvent class is responsible for counting the
937 * occurrence of some event and measuring the the elapsed time of
938 * the event in two separate PerfCounter instances.
939 *
940 * Example:
941 *
942 * static PerfCounter* my_time_counter = PerfDataManager::create_counter("my.time.counter", PerfData::U_Ticks, CHECK);
943 * static PerfCounter* my_event_counter = PerfDataManager::create_counter("my.event.counter", PerfData::U_Events, CHECK);
944 *
945 * {
946 * PerfTraceTimedEvent ptte(my_time_counter, my_event_counter);
947 * // perform the operation you want to count and measure
948 * }
949 *
950 * Note: use of this class does not need to occur within a guarded
951 * block. The UsePerfData guard is used with the implementation
952 * of this class.
953 *
954 */
955 class PerfTraceTimedEvent : public PerfTraceTime {
956
957 protected:
958 PerfLongCounter* _eventp;
959
960 public:
961 inline PerfTraceTimedEvent(PerfLongCounter* timerp, PerfLongCounter* eventp): PerfTraceTime(timerp), _eventp(eventp) {
962 if (!UsePerfData) return;
963 _eventp->inc();
964 }
965
966 inline PerfTraceTimedEvent(PerfLongCounter* timerp, PerfLongCounter* eventp, int* recursion_counter): PerfTraceTime(timerp, recursion_counter), _eventp(eventp) {
967 if (!UsePerfData) return;
968 _eventp->inc();
969 }
970 };
971
972 #endif // SHARE_VM_RUNTIME_PERFDATA_HPP