- PerfData (Abstract)
    - PerfLong (Abstract)
        - PerfLongConstant        (alias: PerfConstant)
        - PerfLongVariant (Abstract)
            - PerfLongVariable    (alias: PerfVariable)
            - PerfLongCounter     (alias: PerfCounter)

    - PerfByteArray (Abstract)
        - PerfString (Abstract)
            - PerfStringVariable
            - PerfStringConstant

...(以下のコメント内を参照)

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * Classes to support access to production performance data
     *
     * The PerfData class structure is provided for creation, access, and update
     * of performance data (a.k.a. instrumentation) in a specific memory region
     * which is possibly accessible as shared memory. Although not explicitly
     * prevented from doing so, developers should not use the values returned
     * by accessor methods to make algorithmic decisions as they are potentially
     * extracted from a shared memory region. Although any shared memory region
     * created is with appropriate access restrictions, allowing read-write access
     * only to the principal that created the JVM, it is believed that a the
     * shared memory region facilitates an easier attack path than attacks
     * launched through mechanisms such as /proc. For this reason, it is
     * recommended that data returned by PerfData accessor methods be used
     * cautiously.
     *
     * There are three variability classifications of performance data
     *   Constants  -  value is written to the PerfData memory once, on creation
     *   Variables  -  value is modifiable, with no particular restrictions
     *   Counters   -  value is monotonically changing (increasing or decreasing)
     *
     * The performance data items can also have various types. The class
     * hierarchy and the structure of the memory region are designed to
     * accommodate new types as they are needed. Types are specified in
     * terms of Java basic types, which accommodates client applications
     * written in the Java programming language. The class hierarchy is:
     *
     * - PerfData (Abstract)
     *     - PerfLong (Abstract)
     *         - PerfLongConstant        (alias: PerfConstant)
     *         - PerfLongVariant (Abstract)
     *             - PerfLongVariable    (alias: PerfVariable)
     *             - PerfLongCounter     (alias: PerfCounter)
     *
     *     - PerfByteArray (Abstract)
     *         - PerfString (Abstract)
     *             - PerfStringVariable
     *             - PerfStringConstant
     *
     *
     * As seen in the class hierarchy, the initially supported types are:
     *
     *    Long      - performance data holds a Java long type
     *    ByteArray - performance data holds an array of Java bytes
     *                used for holding C++ char arrays.
     *
     * The String type is derived from the ByteArray type.
     *
     * A PerfData subtype is not required to provide an implementation for
     * each variability classification. For example, the String type provides
     * Variable and Constant variablility classifications in the PerfStringVariable
     * and PerfStringConstant classes, but does not provide a counter type.
     *
     * Performance data are also described by a unit of measure. Units allow
     * client applications to make reasonable decisions on how to treat
     * performance data generically, preventing the need to hard-code the
     * specifics of a particular data item in client applications. The current
     * set of units are:
     *
     *   None        - the data has no units of measure
     *   Bytes       - data is measured in bytes
     *   Ticks       - data is measured in clock ticks
     *   Events      - data is measured in events. For example,
     *                 the number of garbage collection events or the
     *                 number of methods compiled.
     *   String      - data is not numerical. For example,
     *                 the java command line options
     *   Hertz       - data is a frequency
     *
     * The performance counters also provide a support attribute, indicating
     * the stability of the counter as a programmatic interface. The support
     * level is also implied by the name space in which the counter is created.
     * The counter name space support conventions follow the Java package, class,
     * and property support conventions:
     *
     *    java.*          - stable, supported interface
     *    com.sun.*       - unstable, supported interface
     *    sun.*           - unstable, unsupported interface
     *
     * In the above context, unstable is a measure of the interface support
     * level, not the implementation stability level.
     *
     * Currently, instances of PerfData subtypes are considered to have
     * a life time equal to that of the VM and are managed by the
     * PerfDataManager class. All constructors for the PerfData class and
     * its subtypes have protected constructors. Creation of PerfData
     * instances is performed by invoking various create methods on the
     * PerfDataManager class. Users should not attempt to delete these
     * instances as the PerfDataManager class expects to perform deletion
     * operations on exit of the VM.
     *
     * Examples:
     *
     * Creating performance counter that holds a monotonically increasing
     * long data value with units specified in U_Bytes in the "java.gc.*"
     * name space.
     *
     *   PerfLongCounter* foo_counter;
     *
     *   foo_counter = PerfDataManager::create_long_counter(JAVA_GC, "foo",
     *                                                       PerfData::U_Bytes,
     *                                                       optionalInitialValue,
     *                                                       CHECK);
     *   foo_counter->inc();
     *
     * Creating a performance counter that holds a variably change long
     * data value with untis specified in U_Bytes in the "com.sun.ci
     * name space.
     *
     *   PerfLongVariable* bar_varible;
     *   bar_variable = PerfDataManager::create_long_variable(COM_CI, "bar",
    .*                                                        PerfData::U_Bytes,
     *                                                        optionalInitialValue,
     *                                                        CHECK);
     *
     *   bar_variable->inc();
     *   bar_variable->set_value(0);
     *
     * Creating a performance counter that holds a constant string value in
     * the "sun.cls.*" name space.
     *
     *   PerfDataManager::create_string_constant(SUN_CLS, "foo", string, CHECK);
     *
     *   Although the create_string_constant() factory method returns a pointer
     *   to the PerfStringConstant object, it can safely be ignored. Developers
     *   are not encouraged to access the string constant's value via this
     *   pointer at this time due to security concerns.
     *
     * Creating a performance counter in an arbitrary name space that holds a
     * value that is sampled by the StatSampler periodic task.
     *
     *    PerfDataManager::create_counter("foo.sampled", PerfData::U_Events,
     *                                    &my_jlong, CHECK);
     *
     *    In this example, the PerfData pointer can be ignored as the caller
     *    is relying on the StatSampler PeriodicTask to sample the given
     *    address at a regular interval. The interval is defined by the
     *    PerfDataSamplingInterval global variable, and is applyied on
     *    a system wide basis, not on an per-counter basis.
     *
     * Creating a performance counter in an arbitrary name space that utilizes
     * a helper object to return a value to the StatSampler via the take_sample()
     * method.
     *
     *     class MyTimeSampler : public PerfLongSampleHelper {
     *       public:
     *         jlong take_sample() { return os::elapsed_counter(); }
     *     };
     *
     *     PerfDataManager::create_counter(SUN_RT, "helped",
     *                                     PerfData::U_Ticks,
     *                                     new MyTimeSampler(), CHECK);
     *
     *     In this example, a subtype of PerfLongSampleHelper is instantiated
     *     and its take_sample() method is overridden to perform whatever
     *     operation is necessary to generate the data sample. This method
     *     will be called by the StatSampler at a regular interval, defined
     *     by the PerfDataSamplingInterval global variable.
     *
     *     As before, PerfSampleHelper is an alias for PerfLongSampleHelper.
     *
     * For additional uses of PerfData subtypes, see the utility classes
     * PerfTraceTime and PerfTraceTimedEvent below.
     *
     * Always-on non-sampled counters can be created independent of
     * the UsePerfData flag. Counters will be created on the c-heap
     * if UsePerfData is false.
     *
     * Until further noice, all PerfData objects should be created and
     * manipulated within a guarded block. The guard variable is
     * UsePerfData, a product flag set to true by default. This flag may
     * be removed from the product in the future.
     *
     */

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /* jvmstat global and subsystem counter name space - enumeration value
     * serve as an index into the PerfDataManager::_name_space[] array
     * containing the corresponding name space string. Only the top level
     * subsystem name spaces are represented here.
     */
    enum CounterNS {
      // top level name spaces
      JAVA_NS,
      COM_NS,
      SUN_NS,
      // subsystem name spaces
      JAVA_GC,              // Garbage Collection name spaces
      COM_GC,
      SUN_GC,
      JAVA_CI,              // Compiler name spaces
      COM_CI,
      SUN_CI,
      JAVA_CLS,             // Class Loader name spaces
      COM_CLS,
      SUN_CLS,
      JAVA_RT,              // Runtime name spaces
      COM_RT,
      SUN_RT,
      JAVA_OS,              // Operating System name spaces
      COM_OS,
      SUN_OS,
      JAVA_THREADS,         // Threads System name spaces
      COM_THREADS,
      SUN_THREADS,
      JAVA_PROPERTY,        // Java Property name spaces
      COM_PROPERTY,
      SUN_PROPERTY,
      NULL_NS,
      COUNTERNS_LAST = NULL_NS
    };

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    class PerfData : public CHeapObj {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * PerfLong is the base class for the various Long PerfData subtypes.
     * it contains implementation details that are common among its derived
     * types.
     */
    class PerfLong : public PerfData {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfLongConstant class, and its alias PerfConstant, implement
     * a PerfData subtype that holds a jlong data value that is set upon
     * creation of an instance of this class. This class provides no
     * methods for changing the data value stored in PerfData memory region.
     */
    class PerfLongConstant : public PerfLong {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    typedef PerfLongConstant PerfConstant;

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfLongVariant class, and its alias PerfVariant, implement
     * a PerfData subtype that holds a jlong data value that can be modified
     * in an unrestricted manner. This class provides the implementation details
     * for common functionality among its derived types.
     */
    class PerfLongVariant : public PerfLong {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * PerfLongSampleHelper, and its alias PerfSamplerHelper, is a base class
     * for helper classes that rely upon the StatSampler periodic task to
     * invoke the take_sample() method and write the value returned to its
     * appropriate location in the PerfData memory region.
     */
    class PerfLongSampleHelper : public CHeapObj {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    typedef PerfLongSampleHelper PerfSampleHelper;

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
        virtual jlong take_sample() = 0;

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfLongCounter class, and its alias PerfCounter, implement
     * a PerfData subtype that holds a jlong data value that can (should)
     * be modified in a monotonic manner. The inc(jlong) and add(jlong)
     * methods can be passed negative values to implement a monotonically
     * decreasing value. However, we rely upon the programmer to honor
     * the notion that this counter always moves in the same direction -
     * either increasing or decreasing.
     */
    class PerfLongCounter : public PerfLongVariant {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    typedef PerfLongCounter PerfCounter;

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfLongVariable class, and its alias PerfVariable, implement
     * a PerfData subtype that holds a jlong data value that can
     * be modified in an unrestricted manner.
     */
    class PerfLongVariable : public PerfLongVariant {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    typedef PerfLongVariable PerfVariable;

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfByteArray provides a PerfData subtype that allows the creation
     * of a contiguous region of the PerfData memory region for storing a vector
     * of bytes. This class is currently intended to be a base class for
     * the PerfString class, and cannot be instantiated directly.
     */
    class PerfByteArray : public PerfData {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    class PerfString : public PerfByteArray {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfStringConstant class provides a PerfData sub class that
     * allows a null terminated string of single byte characters to be
     * stored in the PerfData memory region.
     */
    class PerfStringConstant : public PerfString {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfStringVariable class provides a PerfData sub class that
     * allows a null terminated string of single byte character data
     * to be stored in PerfData memory region. The string value can be reset
     * after initialization. If the string value is >= max_length, then
     * it will be truncated to max_length characters. The copied string
     * is always null terminated.
     */
    class PerfStringVariable : public PerfString {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfDataList class is a container class for managing lists
     * of PerfData items. The intention of this class is to allow for
     * alternative implementations for management of list of PerfData
     * items without impacting the code that uses the lists.
     *
     * The initial implementation is based upon GrowableArray. Searches
     * on GrowableArray types is linear in nature and this may become
     * a performance issue for creation of PerfData items, particularly
     * from Java code where a test for existence is implemented as a
     * search over all existing PerfData items.
     *
     * The abstraction is not complete. A more general container class
     * would provide an Iterator abstraction that could be used to
     * traverse the lists. This implementation still relys upon integer
     * iterators and the at(int index) method. However, the GrowableArray
     * is not directly visible outside this class and can be replaced by
     * some other implementation, as long as that implementation provides
     * a mechanism to iterate over the container by index.
     */
    class PerfDataList : public CHeapObj {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * The PerfDataManager class is responsible for creating PerfData
     * subtypes via a set a factory methods and for managing lists
     * of the various PerfData types.
     */
    class PerfDataManager : AllStatic {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /*
     * this class will administer a PerfCounter used as a time accumulator
     * for a basic block much like the TraceTime class.
     *
     * Example:
     *
     *    static PerfCounter* my_time_counter = PerfDataManager::create_counter("my.time.counter", PerfData::U_Ticks, 0LL, CHECK);
     *
     *    {
     *      PerfTraceTime ptt(my_time_counter);
     *      // perform the operation you want to measure
     *    }
     *
     * Note: use of this class does not need to occur within a guarded
     * block. The UsePerfData guard is used with the implementation
     * of this class.
     */
    class PerfTraceTime : public StackObj {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
        elapsedTimer _t;
        PerfLongCounter* _timerp;

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
    /* The PerfTraceTimedEvent class is responsible for counting the
     * occurrence of some event and measuring the the elapsed time of
     * the event in two separate PerfCounter instances.
     *
     * Example:
     *
     *    static PerfCounter* my_time_counter = PerfDataManager::create_counter("my.time.counter", PerfData::U_Ticks, CHECK);
     *    static PerfCounter* my_event_counter = PerfDataManager::create_counter("my.event.counter", PerfData::U_Events, CHECK);
     *
     *    {
     *      PerfTraceTimedEvent ptte(my_time_counter, my_event_counter);
     *      // perform the operation you want to count and measure
     *    }
     *
     * Note: use of this class does not need to occur within a guarded
     * block. The UsePerfData guard is used with the implementation
     * of this class.
     *
     */
    class PerfTraceTimedEvent : public PerfTraceTime {

    ((cite: hotspot/src/share/vm/runtime/perfData.hpp))
      public:
        inline PerfTraceTimedEvent(PerfLongCounter* timerp, PerfLongCounter* eventp): PerfTraceTime(timerp), _eventp(eventp) {
          if (!UsePerfData) return;
          _eventp->inc();
        }

        inline PerfTraceTimedEvent(PerfLongCounter* timerp, PerfLongCounter* eventp, int* recursion_counter): PerfTraceTime(timerp, recursion_counter), _eventp(eventp) {
          if (!UsePerfData) return;
          _eventp->inc();
        }