hotspot/src/share/vm/runtime/perfData.cpp
author jlaskey
Tue, 23 Jul 2013 12:00:29 -0300
changeset 19089 51cfdcf21d35
parent 18025 b7bcf7497f93
child 22551 9bf46d16dcc6
permissions -rw-r--r--
8021130: Comments need to be tokens Reviewed-by: lagergren, attila Contributed-by: james.laskey@oracle.com
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
15228
e92acc84ade3 7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents: 13975
diff changeset
     2
 * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 1
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "classfile/vmSymbols.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "runtime/handles.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "runtime/java.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "runtime/mutex.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    31
#include "runtime/mutexLocker.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    32
#include "runtime/os.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    33
#include "runtime/perfData.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    34
#include "utilities/exceptions.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    35
#include "utilities/globalDefinitions.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
PerfDataList*   PerfDataManager::_all = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
PerfDataList*   PerfDataManager::_sampled = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
PerfDataList*   PerfDataManager::_constants = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
 * The jvmstat global and subsysem jvmstat counter name spaces. The top
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
 * level name spaces imply the interface stability level of the counter,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
 * which generally follows the Java package, class, and property naming
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
 * conventions. The CounterNS enumeration values should be used to index
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
 * into this array.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
const char* PerfDataManager::_name_spaces[] = {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  // top level name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  "java",                   // stable and supported name space
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  "com.sun",                // unstable but supported name space
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  "sun",                    // unstable and unsupported name space
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  // subsystem name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  "java.gc",                // Garbage Collection name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  "com.sun.gc",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  "sun.gc",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  "java.ci",                // Compiler name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  "com.sun.ci",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  "sun.ci",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  "java.cls",               // Class Loader name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  "com.sun.cls",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  "sun.cls",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  "java.rt",                // Runtime name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  "com.sun.rt",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  "sun.rt",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  "java.os",                // Operating System name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  "com.sun.os",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  "sun.os",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  "java.threads",           // Threads System name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  "com.sun.threads",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  "sun.threads",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  "java.property",          // Java Property name spaces
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  "com.sun.property",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  "sun.property",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  "",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
PerfData::PerfData(CounterNS ns, const char* name, Units u, Variability v)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
                  : _name(NULL), _u(u), _v(v), _valuep(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
                    _on_c_heap(false) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  const char* prefix = PerfDataManager::ns_to_string(ns);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7397
diff changeset
    84
  _name = NEW_C_HEAP_ARRAY(char, strlen(name) + strlen(prefix) + 2, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  assert(_name != NULL && strlen(name) != 0, "invalid name");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  if (ns == NULL_NS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
     // No prefix is added to counters with the NULL_NS namespace.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
     strcpy(_name, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
     // set the F_Supported flag based on the counter name prefix.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
     if (PerfDataManager::is_stable_supported(_name) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
         PerfDataManager::is_unstable_supported(_name)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
       _flags = F_Supported;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
     else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
       _flags = F_None;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    sprintf(_name, "%s.%s", prefix, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
    // set the F_Supported flag based on the given namespace.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    if (PerfDataManager::is_stable_supported(ns) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
        PerfDataManager::is_unstable_supported(ns)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
      _flags = F_Supported;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
      _flags = F_None;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
PerfData::~PerfData() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  if (_name != NULL) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7397
diff changeset
   114
    FREE_C_HEAP_ARRAY(char, _name, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
  if (is_on_c_heap()) {
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7397
diff changeset
   117
    FREE_C_HEAP_ARRAY(PerfDataEntry, _pdep, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
void PerfData::create_entry(BasicType dtype, size_t dsize, size_t vlen) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  size_t dlen = vlen==0 ? 1 : vlen;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  size_t namelen = strlen(name()) + 1;  // include null terminator
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  size_t size = sizeof(PerfDataEntry) + namelen;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  size_t pad_length = ((size % dsize) == 0) ? 0 : dsize - (size % dsize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  size += pad_length;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
  size_t data_start = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  size += (dsize * dlen);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // align size to assure allocation in units of 8 bytes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  int align = sizeof(jlong) - 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  size = ((size + align) & ~align);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
  char* psmp = PerfMemory::alloc(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  if (psmp == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
    // out of PerfMemory memory resources. allocate on the C heap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
    // to avoid vm termination.
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7397
diff changeset
   140
    psmp = NEW_C_HEAP_ARRAY(char, size, mtInternal);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    _on_c_heap = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // compute the addresses for the name and data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  char* cname = psmp + sizeof(PerfDataEntry);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // data is in the last dsize*dlen bytes of the entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  void* valuep = (void*) (psmp + data_start);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  assert(is_on_c_heap() || PerfMemory::contains(cname), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  assert(is_on_c_heap() || PerfMemory::contains((char*)valuep), "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // copy the name, including null terminator, into PerfData memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  strcpy(cname, name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  // set the header values in PerfData memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  PerfDataEntry* pdep = (PerfDataEntry*)psmp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  pdep->entry_length = (jint)size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  pdep->name_offset = (jint) ((uintptr_t) cname - (uintptr_t) psmp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  pdep->vector_length = (jint)vlen;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  pdep->data_type = (jbyte) type2char(dtype);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  pdep->data_units = units();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  pdep->data_variability = variability();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  pdep->flags = (jbyte)flags();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
  pdep->data_offset = (jint) data_start;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  if (PerfTraceDataCreation) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    tty->print("name = %s, dtype = %d, variability = %d,"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
               " units = %d, dsize = %d, vlen = %d,"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
               " pad_length = %d, size = %d, on_c_heap = %s,"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
               " address = " INTPTR_FORMAT ","
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
               " data address = " INTPTR_FORMAT "\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
               cname, dtype, variability(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
               units(), dsize, vlen,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
               pad_length, size, is_on_c_heap() ? "TRUE":"FALSE",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
               psmp, valuep);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // record the start of the entry and the location of the data field.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  _pdep = pdep;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  _valuep = valuep;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
  // mark the PerfData memory region as having been updated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  PerfMemory::mark_updated();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
PerfLong::PerfLong(CounterNS ns, const char* namep, Units u, Variability v)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
                 : PerfData(ns, namep, u, v) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
  create_entry(T_LONG, sizeof(jlong));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
int PerfLong::format(char* buffer, int length) {
15228
e92acc84ade3 7102489: RFE: cleanup jlong typedef on __APPLE__and _LLP64 systems.
hseigel
parents: 13975
diff changeset
   195
  return jio_snprintf(buffer, length, JLONG_FORMAT, *(jlong*)_valuep);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
PerfLongVariant::PerfLongVariant(CounterNS ns, const char* namep, Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
                                 Variability v, jlong* sampled)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
                                : PerfLong(ns, namep, u, v),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
                                  _sampled(sampled), _sample_helper(NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  sample();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
PerfLongVariant::PerfLongVariant(CounterNS ns, const char* namep, Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
                                 Variability v, PerfLongSampleHelper* helper)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
                                : PerfLong(ns, namep, u, v),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
                                  _sampled(NULL), _sample_helper(helper) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  sample();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
void PerfLongVariant::sample() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   216
  // JJJ - This should not happen.  Maybe the first sample is taken
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   217
  // while the _sample_helper is being null'ed out.
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   218
  // assert(_sample_helper != NULL || _sampled != NULL, "unexpected state");
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13195
diff changeset
   219
  if (_sample_helper == NULL) return;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  if (_sample_helper != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    *(jlong*)_valuep = _sample_helper->take_sample();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  else if (_sampled != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    *(jlong*)_valuep = *_sampled;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
PerfByteArray::PerfByteArray(CounterNS ns, const char* namep, Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
                             Variability v, jint length)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
                            : PerfData(ns, namep, u, v), _length(length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  create_entry(T_BYTE, sizeof(jbyte), (size_t)_length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
void PerfString::set_string(const char* s2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  // copy n bytes of the string, assuring the null string is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // copied if s2 == NULL.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  strncpy((char *)_valuep, s2 == NULL ? "" : s2, _length);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  // assure the string is null terminated when strlen(s2) >= _length
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  ((char*)_valuep)[_length-1] = '\0';
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
int PerfString::format(char* buffer, int length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
  return jio_snprintf(buffer, length, "%s", (char*)_valuep);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
PerfStringConstant::PerfStringConstant(CounterNS ns, const char* namep,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
                                       const char* initial_value)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
                     : PerfString(ns, namep, V_Constant,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
                                  initial_value == NULL ? 1 :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
                                  MIN2((jint)(strlen((char*)initial_value)+1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
                                       (jint)(PerfMaxStringConstLength+1)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
                                  initial_value) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
    if (is_valid() && initial_value != NULL &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
        ((jint)strlen(initial_value) > (jint)PerfMaxStringConstLength)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
      warning("Truncating PerfStringConstant: name = %s,"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
              " length = " INT32_FORMAT ","
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
              " PerfMaxStringConstLength = " INT32_FORMAT "\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
              namep,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
              (jint)strlen(initial_value),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
              (jint)PerfMaxStringConstLength);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
void PerfDataManager::destroy() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  if (_all == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    // destroy already called, or initialization never happened
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  for (int index = 0; index < _all->length(); index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    PerfData* p = _all->at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  delete(_all);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  delete(_sampled);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  delete(_constants);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
  _all = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
  _sampled = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
  _constants = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
void PerfDataManager::add_item(PerfData* p, bool sampled) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  MutexLocker ml(PerfDataManager_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  if (_all == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    _all = new PerfDataList(100);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  assert(!_all->contains(p->name()), "duplicate name added");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  // add to the list of all perf data items
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  _all->append(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  if (p->variability() == PerfData::V_Constant) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
    if (_constants == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
      _constants = new PerfDataList(25);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    _constants->append(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  if (sampled) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    if (_sampled == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
      _sampled = new PerfDataList(25);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
    _sampled->append(p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 15228
diff changeset
   326
PerfData* PerfDataManager::find_by_name(const char* name) {
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 15228
diff changeset
   327
  return _all->find_by_name(name);
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 15228
diff changeset
   328
}
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 15228
diff changeset
   329
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
PerfDataList* PerfDataManager::all() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  MutexLocker ml(PerfDataManager_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  if (_all == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  PerfDataList* clone = _all->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  return clone;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
PerfDataList* PerfDataManager::sampled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  MutexLocker ml(PerfDataManager_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  if (_sampled == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  PerfDataList* clone = _sampled->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  return clone;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
PerfDataList* PerfDataManager::constants() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  MutexLocker ml(PerfDataManager_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
  if (_constants == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
  PerfDataList* clone = _constants->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  return clone;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
char* PerfDataManager::counter_name(const char* ns, const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
   assert(ns != NULL, "ns string required");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
   assert(name != NULL, "name string required");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
   size_t len = strlen(ns) + strlen(name) + 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
   char* result = NEW_RESOURCE_ARRAY(char, len);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
   sprintf(result, "%s.%s", ns, name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
   return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
char* PerfDataManager::name_space(const char* ns, const char* sub,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
                                  int instance) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
   char intbuf[40];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
   jio_snprintf(intbuf, 40, UINT32_FORMAT, instance);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
   return name_space(ns, name_space(sub, intbuf));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
char *PerfDataManager::name_space(const char* ns, int instance) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
   char intbuf[40];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
   jio_snprintf(intbuf, 40, UINT32_FORMAT, instance);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
   return name_space(ns, intbuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
PerfStringConstant* PerfDataManager::create_string_constant(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
                                                            const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
                                                            const char* s,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
                                                            TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  PerfStringConstant* p = new PerfStringConstant(ns, name, s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
  add_item(p, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
PerfLongConstant* PerfDataManager::create_long_constant(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
                                                        const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
                                                        PerfData::Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
                                                        jlong val, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  PerfLongConstant* p = new PerfLongConstant(ns, name, u, val);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  add_item(p, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
PerfStringVariable* PerfDataManager::create_string_variable(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
                                                            const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
                                                            jint max_length,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
                                                            const char* s,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
                                                            TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  if (max_length == 0 && s != NULL) max_length = (jint)strlen(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  assert(max_length != 0, "PerfStringVariable with length 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
  PerfStringVariable* p = new PerfStringVariable(ns, name, max_length, s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
  add_item(p, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
PerfLongVariable* PerfDataManager::create_long_variable(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
                                                        const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
                                                        PerfData::Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
                                                        jlong ival, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  PerfLongVariable* p = new PerfLongVariable(ns, name, u, ival);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  add_item(p, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
PerfLongVariable* PerfDataManager::create_long_variable(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
                                                        const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
                                                        PerfData::Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
                                                        jlong* sp, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  // Sampled counters not supported if UsePerfData is false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  if (!UsePerfData) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  PerfLongVariable* p = new PerfLongVariable(ns, name, u, sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  add_item(p, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
PerfLongVariable* PerfDataManager::create_long_variable(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
                                                        const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
                                                        PerfData::Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
                                                        PerfSampleHelper* sh,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
                                                        TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // Sampled counters not supported if UsePerfData is false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  if (!UsePerfData) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  PerfLongVariable* p = new PerfLongVariable(ns, name, u, sh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  add_item(p, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
PerfLongCounter* PerfDataManager::create_long_counter(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
                                                      const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
                                                      PerfData::Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
                                                      jlong ival, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  PerfLongCounter* p = new PerfLongCounter(ns, name, u, ival);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  add_item(p, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
PerfLongCounter* PerfDataManager::create_long_counter(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
                                                      const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
                                                      PerfData::Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
                                                      jlong* sp, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // Sampled counters not supported if UsePerfData is false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  if (!UsePerfData) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  PerfLongCounter* p = new PerfLongCounter(ns, name, u, sp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  add_item(p, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
PerfLongCounter* PerfDataManager::create_long_counter(CounterNS ns,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
                                                      const char* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
                                                      PerfData::Units u,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
                                                      PerfSampleHelper* sh,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
                                                      TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  // Sampled counters not supported if UsePerfData is false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  if (!UsePerfData) return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  PerfLongCounter* p = new PerfLongCounter(ns, name, u, sh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  if (!p->is_valid()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    // allocation of native resources failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
    delete p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
    THROW_0(vmSymbols::java_lang_OutOfMemoryError());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  add_item(p, true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  return p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
PerfDataList::PerfDataList(int length) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7397
diff changeset
   569
  _set = new(ResourceObj::C_HEAP, mtInternal) PerfDataArray(length, true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
PerfDataList::PerfDataList(PerfDataList* p) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
13195
be27e1b6a4b9 6995781: Native Memory Tracking (Phase 1)
zgu
parents: 7397
diff changeset
   574
  _set = new(ResourceObj::C_HEAP, mtInternal) PerfDataArray(p->length(), true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  _set->appendAll(p->get_impl());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
PerfDataList::~PerfDataList() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
  delete _set;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
bool PerfDataList::by_name(void* name, PerfData* pd) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  if (pd == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  return strcmp((const char*)name, pd->name()) == 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
PerfData* PerfDataList::find_by_name(const char* name) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
13975
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
   595
  // if add_item hasn't been called the list won't be initialized
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
   596
  if (this == NULL)
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
   597
    return NULL;
2f7431485cfa 7189254: Change makefiles for more flexibility to override defaults
jprovino
parents: 13728
diff changeset
   598
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
  int i = _set->find((void*)name, PerfDataList::by_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  if (i >= 0 && i <= _set->length())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    return _set->at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
PerfDataList* PerfDataList::clone() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  PerfDataList* copy = new PerfDataList(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  assert(copy != NULL, "just checking");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
  return copy;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
}