src/hotspot/os/windows/os_perf_windows.cpp
author rwestberg
Thu, 28 Jun 2018 15:06:55 +0200
changeset 50879 d90c3cbf13df
parent 50321 b186322970f4
child 53882 ca682d9d8db5
permissions -rw-r--r--
8003209: JFR events for network utilization Reviewed-by: mgronlun, egahlin
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     1
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     2
 * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     4
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     7
 * published by the Free Software Foundation.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     8
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    13
 * accompanied this code).
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    14
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    18
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    21
 * questions.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    22
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    23
 */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    24
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    25
#include "precompiled.hpp"
50879
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
    26
#include "iphlp_interface.hpp"
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    27
#include "logging/log.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    28
#include "memory/allocation.inline.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    29
#include "memory/resourceArea.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    30
#include "pdh_interface.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    31
#include "runtime/os_perf.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    32
#include "runtime/os.hpp"
50879
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
    33
#include "utilities/macros.hpp"
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    34
#include "vm_version_ext_x86.hpp"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    35
#include <math.h>
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    36
#include <psapi.h>
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    37
#include <TlHelp32.h>
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    38
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    39
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    40
 * Windows provides a vast plethora of performance objects and counters,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    41
 * consumption of which is assisted using the Performance Data Helper (PDH) interface.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    42
 * We import a selected few api entry points from PDH, see pdh_interface.hpp.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    43
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    44
 * The code located in this file is to a large extent an abstraction over much of the
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    45
 * plumbing needed to start consuming an object and/or counter of choice.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    46
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    47
 */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    48
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    49
 /*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    50
 * How to use:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    51
 * 1. Create query
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    52
 * 2. Add counters to the query
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    53
 * 3. Collect the performance data using the query
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    54
 * 4. Display the performance data using the counters associated with the query
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    55
 * 5. Destroy query (counter destruction implied)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    56
 */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    57
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    58
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    59
 * Every PDH artifact, like processor, process, thread, memory, and so forth are
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    60
 * identified with an index that is always the same irrespective
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    61
 * of the localized version of the operating system or service pack installed.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    62
 * INFO: Using PDH APIs Correctly in a Localized Language (Q287159)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    63
 *   http://support.microsoft.com/default.aspx?scid=kb;EN-US;q287159
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    64
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    65
 * To find the correct index for an object or counter, inspect the registry key / value:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    66
 * [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009\Counter]
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    67
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    68
 * some common PDH indexes
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    69
 */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    70
static const DWORD PDH_PROCESSOR_IDX = 238;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    71
static const DWORD PDH_PROCESSOR_TIME_IDX = 6;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    72
static const DWORD PDH_PRIV_PROCESSOR_TIME_IDX = 144;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    73
static const DWORD PDH_PROCESS_IDX = 230;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    74
static const DWORD PDH_ID_PROCESS_IDX = 784;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    75
static const DWORD PDH_CONTEXT_SWITCH_RATE_IDX = 146;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    76
static const DWORD PDH_SYSTEM_IDX = 2;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    77
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    78
/* useful pdh fmt's */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    79
static const char* const OBJECT_COUNTER_FMT = "\\%s\\%s";
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    80
static const size_t OBJECT_COUNTER_FMT_LEN = 2;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    81
static const char* const OBJECT_WITH_INSTANCES_COUNTER_FMT = "\\%s(%s)\\%s";
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    82
static const size_t OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN = 4;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    83
static const char* const PROCESS_OBJECT_INSTANCE_COUNTER_FMT = "\\%s(%s#%s)\\%s";
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    84
static const size_t PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN = 5;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    85
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    86
static const char* process_image_name = NULL; // for example, "java" but could have another image name
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    87
static char* pdh_IDProcess_counter_fmt = NULL;   // "\Process(java#%d)\ID Process" */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    88
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    89
// Need to limit how often we update a query to minimize the heisenberg effect.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    90
// (PDH behaves erratically if the counters are queried too often, especially counters that
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    91
// store and use values from two consecutive updates, like cpu load.)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    92
static const int min_update_interval_millis = 500;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    93
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    94
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    95
* Structs for PDH queries.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    96
*/
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    97
typedef struct {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    98
  HQUERY query;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
    99
  s8     lastUpdate; // Last time query was updated (current millis).
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   100
} UpdateQueryS, *UpdateQueryP;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   101
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   102
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   103
typedef struct {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   104
  UpdateQueryS query;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   105
  HCOUNTER     counter;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   106
  bool         initialized;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   107
} CounterQueryS, *CounterQueryP;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   108
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   109
typedef struct {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   110
  UpdateQueryS query;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   111
  HCOUNTER*    counters;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   112
  int          noOfCounters;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   113
  bool         initialized;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   114
} MultiCounterQueryS, *MultiCounterQueryP;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   115
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   116
typedef struct {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   117
  MultiCounterQueryP queries;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   118
  int                size;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   119
  bool               initialized;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   120
} MultiCounterQuerySetS, *MultiCounterQuerySetP;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   121
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   122
typedef struct {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   123
  MultiCounterQuerySetS set;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   124
  int                   process_index;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   125
} ProcessQueryS, *ProcessQueryP;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   126
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   127
static void pdh_cleanup(HQUERY* const query, HCOUNTER* const counter) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   128
  if (counter != NULL && *counter != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   129
    PdhDll::PdhRemoveCounter(*counter);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   130
    *counter = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   131
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   132
  if (query != NULL && *query != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   133
    PdhDll::PdhCloseQuery(*query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   134
    *query = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   135
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   136
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   137
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   138
static CounterQueryP create_counter_query() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   139
  CounterQueryP const query = NEW_C_HEAP_ARRAY(CounterQueryS, 1, mtInternal);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   140
  memset(query, 0, sizeof(CounterQueryS));
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   141
  return query;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   142
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   143
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   144
static void destroy_counter_query(CounterQueryP query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   145
  assert(query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   146
  pdh_cleanup(&query->query.query, &query->counter);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   147
  FREE_C_HEAP_ARRAY(CounterQueryS, query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   148
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   149
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   150
static MultiCounterQueryP create_multi_counter_query() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   151
  MultiCounterQueryP const query = NEW_C_HEAP_ARRAY(MultiCounterQueryS, 1, mtInternal);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   152
  memset(query, 0, sizeof(MultiCounterQueryS));
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   153
  return query;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   154
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   155
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   156
static void destroy_counter_query(MultiCounterQueryP counter_query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   157
  if (counter_query != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   158
    for (int i = 0; i < counter_query->noOfCounters; ++i) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   159
      pdh_cleanup(NULL, &counter_query->counters[i]);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   160
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   161
    FREE_C_HEAP_ARRAY(char, counter_query->counters);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   162
    pdh_cleanup(&counter_query->query.query, NULL);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   163
    FREE_C_HEAP_ARRAY(MultiCounterQueryS, counter_query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   164
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   165
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   166
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   167
static void destroy_multi_counter_query(MultiCounterQuerySetP counter_query_set) {
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   168
  for (int i = 0; i < counter_query_set->size; i++) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   169
    for (int j = 0; j < counter_query_set->queries[i].noOfCounters; ++j) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   170
      pdh_cleanup(NULL, &counter_query_set->queries[i].counters[j]);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   171
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   172
    FREE_C_HEAP_ARRAY(char, counter_query_set->queries[i].counters);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   173
    pdh_cleanup(&counter_query_set->queries[i].query.query, NULL);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   174
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   175
  FREE_C_HEAP_ARRAY(MultiCounterQueryS, counter_query_set->queries);
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   176
}
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   177
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   178
static void destroy_counter_query(MultiCounterQuerySetP counter_query_set) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   179
  destroy_multi_counter_query(counter_query_set);
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   180
  FREE_C_HEAP_ARRAY(MultiCounterQuerySetS, counter_query_set);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   181
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   182
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   183
static void destroy_counter_query(ProcessQueryP process_query) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   184
  destroy_multi_counter_query(&process_query->set);
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   185
  FREE_C_HEAP_ARRAY(ProcessQueryS, process_query);
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   186
}
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   187
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   188
static int open_query(HQUERY* query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   189
  return PdhDll::PdhOpenQuery(NULL, 0, query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   190
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   191
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   192
template <typename QueryP>
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   193
static int open_query(QueryP query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   194
  return open_query(&query->query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   195
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   196
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   197
static int allocate_counters(MultiCounterQueryP query, size_t nofCounters) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   198
  assert(query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   199
  assert(!query->initialized, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   200
  assert(0 == query->noOfCounters, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   201
  assert(query->counters == NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   202
  query->counters = (HCOUNTER*)NEW_C_HEAP_ARRAY(char, nofCounters * sizeof(HCOUNTER), mtInternal);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   203
  if (query->counters == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   204
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   205
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   206
  memset(query->counters, 0, nofCounters * sizeof(HCOUNTER));
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   207
  query->noOfCounters = (int)nofCounters;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   208
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   209
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   210
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   211
static int allocate_counters(MultiCounterQuerySetP query_set, size_t nofCounters) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   212
  assert(query_set != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   213
  assert(!query_set->initialized, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   214
  for (int i = 0; i < query_set->size; ++i) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   215
    if (allocate_counters(&query_set->queries[i], nofCounters) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   216
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   217
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   218
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   219
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   220
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   221
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   222
static int allocate_counters(ProcessQueryP process_query, size_t nofCounters) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   223
  assert(process_query != NULL, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   224
  return allocate_counters(&process_query->set, nofCounters);
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   225
}
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   226
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   227
static void deallocate_counters(MultiCounterQueryP query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   228
  if (query->counters != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   229
    FREE_C_HEAP_ARRAY(char, query->counters);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   230
    query->counters = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   231
    query->noOfCounters = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   232
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   233
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   234
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   235
static OSReturn add_counter(UpdateQueryP query, HCOUNTER* counter, const char* path, bool first_sample_on_init) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   236
  assert(query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   237
  assert(counter != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   238
  assert(path != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   239
  if (query->query == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   240
    if (open_query(query) != ERROR_SUCCESS) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   241
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   242
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   243
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   244
  assert(query->query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   245
  PDH_STATUS status = PdhDll::PdhAddCounter(query->query, path, 0, counter);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   246
  if (PDH_CSTATUS_NO_OBJECT == status || PDH_CSTATUS_NO_COUNTER == status) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   247
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   248
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   249
  /*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   250
  * According to the MSDN documentation, rate counters must be read twice:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   251
  *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   252
  * "Obtaining the value of rate counters such as Page faults/sec requires that
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   253
  *  PdhCollectQueryData be called twice, with a specific time interval between
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   254
  *  the two calls, before calling PdhGetFormattedCounterValue. Call Sleep to
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   255
  *  implement the waiting period between the two calls to PdhCollectQueryData."
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   256
  *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   257
  *  Take the first sample here already to allow for the next "real" sample
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   258
  *  to succeed.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   259
  */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   260
  if (first_sample_on_init) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   261
    PdhDll::PdhCollectQueryData(query->query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   262
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   263
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   264
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   265
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   266
template <typename QueryP>
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   267
static OSReturn add_counter(QueryP counter_query, HCOUNTER* counter, const char* path, bool first_sample_on_init) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   268
  assert(counter_query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   269
  assert(counter != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   270
  assert(path != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   271
  return add_counter(&counter_query->query, counter, path, first_sample_on_init);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   272
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   273
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   274
static OSReturn add_counter(CounterQueryP counter_query, const char* path, bool first_sample_on_init) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   275
  if (add_counter(counter_query, &counter_query->counter, path, first_sample_on_init) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   276
    // performance counter might be disabled in the registry
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   277
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   278
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   279
  counter_query->initialized = true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   280
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   281
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   282
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   283
static OSReturn add_process_counter(MultiCounterQueryP query, int slot_index, const char* path, bool first_sample_on_init) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   284
  assert(query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   285
  assert(slot_index < query->noOfCounters, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   286
  assert(query->counters[slot_index] == NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   287
  const OSReturn ret = add_counter(query, &query->counters[slot_index], path, first_sample_on_init);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   288
  if (OS_OK == ret) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   289
    if (slot_index + 1 == query->noOfCounters) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   290
      query->initialized = true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   291
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   292
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   293
  return ret;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   294
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   295
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   296
static int collect_query_data(UpdateQueryP update_query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   297
  assert(update_query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   298
  const s8 now = os::javaTimeMillis();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   299
  if (now - update_query->lastUpdate > min_update_interval_millis) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   300
    if (PdhDll::PdhCollectQueryData(update_query->query) != ERROR_SUCCESS) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   301
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   302
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   303
    update_query->lastUpdate = now;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   304
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   305
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   306
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   307
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   308
template <typename Query>
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   309
static int collect_query_data(Query* counter_query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   310
  assert(counter_query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   311
  return collect_query_data(&counter_query->query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   312
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   313
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   314
static int formatted_counter_value(HCOUNTER counter, DWORD format, PDH_FMT_COUNTERVALUE* const value) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   315
  assert(value != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   316
  if (PdhDll::PdhGetFormattedCounterValue(counter, format, NULL, value) != ERROR_SUCCESS) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   317
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   318
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   319
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   320
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   321
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   322
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   323
* Working against the Process object and it's related counters is inherently problematic
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   324
* when using the PDH API:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   325
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   326
* Using PDH, a process is not primarily identified by the process id,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   327
* but with a sequential number, for example \Process(java#0), \Process(java#1), ...
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   328
* The really bad part is that this list is reset as soon as a process exits:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   329
* If \Process(java#1) exits, \Process(java#3) now becomes \Process(java#2) etc.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   330
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   331
* The PDH api requires a process identifier to be submitted when registering
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   332
* a query, but as soon as the list resets, the query is invalidated (since the name changed).
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   333
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   334
* Solution:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   335
* The #number identifier for a Process query can only decrease after process creation.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   336
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   337
* We therefore create an array of counter queries for all process object instances
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   338
* up to and including ourselves:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   339
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   340
* Ex. we come in as third process instance (java#2), we then create and register
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   341
* queries for the following Process object instances:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   342
* java#0, java#1, java#2
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   343
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   344
* current_query_index_for_process() keeps track of the current "correct" query
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   345
* (in order to keep this index valid when the list resets from underneath,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   346
* ensure to call current_query_index_for_process() before every query involving
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   347
* Process object instance data).
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   348
*
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   349
* if unable to query, returns OS_ERR(-1)
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   350
*/
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   351
static int current_query_index_for_process() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   352
  assert(process_image_name != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   353
  assert(pdh_IDProcess_counter_fmt != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   354
  HQUERY tmpQuery = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   355
  if (open_query(&tmpQuery) != ERROR_SUCCESS) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   356
    return OS_ERR;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   357
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   358
  char counter[512];
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   359
  HCOUNTER handle_counter = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   360
  // iterate over all instance indexes and try to find our own pid
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   361
  for (int index = 0; index < max_intx; index++) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   362
    jio_snprintf(counter, sizeof(counter) - 1, pdh_IDProcess_counter_fmt, index);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   363
    assert(strlen(counter) < sizeof(counter), "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   364
    if (PdhDll::PdhAddCounter(tmpQuery, counter, 0, &handle_counter) != ERROR_SUCCESS) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   365
      pdh_cleanup(&tmpQuery, &handle_counter);
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   366
      return OS_ERR;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   367
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   368
    const PDH_STATUS res = PdhDll::PdhCollectQueryData(tmpQuery);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   369
    if (res == PDH_INVALID_HANDLE || res == PDH_NO_DATA) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   370
      pdh_cleanup(&tmpQuery, &handle_counter);
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   371
      return OS_ERR;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   372
    } else {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   373
      PDH_FMT_COUNTERVALUE counter_value;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   374
      formatted_counter_value(handle_counter, PDH_FMT_LONG, &counter_value);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   375
      pdh_cleanup(NULL, &handle_counter);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   376
      if ((LONG)os::current_process_id() == counter_value.longValue) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   377
        pdh_cleanup(&tmpQuery, NULL);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   378
        return index;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   379
      }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   380
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   381
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   382
  pdh_cleanup(&tmpQuery, NULL);
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   383
  return OS_ERR;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   384
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   385
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   386
static ProcessQueryP create_process_query() {
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   387
  const int current_process_idx = current_query_index_for_process();
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   388
  if (OS_ERR == current_process_idx) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   389
    return NULL;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   390
  }
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   391
  ProcessQueryP const process_query = NEW_C_HEAP_ARRAY(ProcessQueryS, 1, mtInternal);
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   392
  memset(process_query, 0, sizeof(ProcessQueryS));
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   393
  process_query->set.queries = NEW_C_HEAP_ARRAY(MultiCounterQueryS, current_process_idx + 1, mtInternal);
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   394
  memset(process_query->set.queries, 0, sizeof(MultiCounterQueryS) * (current_process_idx + 1));
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   395
  process_query->process_index = current_process_idx;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   396
  process_query->set.size = current_process_idx + 1;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   397
  assert(process_query->set.size > process_query->process_index, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   398
  return process_query;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   399
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   400
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   401
static MultiCounterQueryP current_process_counter_query(ProcessQueryP process_query) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   402
  assert(process_query != NULL, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   403
  assert(process_query->process_index < process_query->set.size, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   404
  return &process_query->set.queries[process_query->process_index];
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   405
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   406
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   407
static void clear_multi_counter(MultiCounterQueryP query) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   408
  for (int i = 0; i < query->noOfCounters; ++i) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   409
    pdh_cleanup(NULL, &query->counters[i]);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   410
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   411
  pdh_cleanup(&query->query.query, NULL);
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   412
  query->initialized = false;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   413
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   414
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   415
static int ensure_valid_process_query_index(ProcessQueryP process_query) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   416
  assert(process_query != NULL, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   417
  const int previous_process_idx = process_query->process_index;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   418
  if (previous_process_idx == 0) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   419
    return previous_process_idx;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   420
  }
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   421
  const int current_process_idx = current_query_index_for_process();
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   422
  if (current_process_idx == previous_process_idx || OS_ERR == current_process_idx ||
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   423
    current_process_idx >= process_query->set.size) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   424
    return previous_process_idx;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   425
  }
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   426
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   427
  assert(current_process_idx >= 0 && current_process_idx < process_query->set.size, "out of bounds!");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   428
  while (current_process_idx < process_query->set.size - 1) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   429
    const int new_size = --process_query->set.size;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   430
    clear_multi_counter(&process_query->set.queries[new_size]);
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   431
  }
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   432
  assert(current_process_idx < process_query->set.size, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   433
  process_query->process_index = current_process_idx;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   434
  return current_process_idx;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   435
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   436
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   437
static MultiCounterQueryP current_process_query(ProcessQueryP process_query) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   438
  assert(process_query != NULL, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   439
  const int current_process_idx = ensure_valid_process_query_index(process_query);
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   440
  assert(current_process_idx == process_query->process_index, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   441
  assert(current_process_idx < process_query->set.size, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   442
  return &process_query->set.queries[current_process_idx];
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   443
}
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   444
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   445
static int collect_process_query_data(ProcessQueryP process_query) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   446
  assert(process_query != NULL, "invariant");
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   447
  return collect_query_data(current_process_query(process_query));
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   448
}
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   449
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   450
static int query_process_counter(ProcessQueryP process_query, int slot_index, DWORD format, PDH_FMT_COUNTERVALUE* const value) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   451
  MultiCounterQueryP const current_query = current_process_counter_query(process_query);
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   452
  assert(current_query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   453
  assert(slot_index < current_query->noOfCounters, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   454
  assert(current_query->counters[slot_index] != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   455
  return formatted_counter_value(current_query->counters[slot_index], format, value);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   456
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   457
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   458
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   459
 * Construct a fully qualified PDH path
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   460
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   461
 * @param objectName   a PDH Object string representation(required)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   462
 * @param counterName  a PDH Counter string representation(required)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   463
 * @param imageName    a process image name string, ex. "java" (opt)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   464
 * @param instance     an instance string, ex. "0", "1", ... (opt)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   465
 * @return             the fully qualified PDH path.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   466
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   467
 * Caller will need a ResourceMark.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   468
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   469
 * (PdhMakeCounterPath() seems buggy on concatenating instances, hence this function instead)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   470
 */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   471
static const char* make_fully_qualified_counter_path(const char* object_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   472
                                                     const char* counter_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   473
                                                     const char* image_name = NULL,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   474
                                                     const char* instance = NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   475
  assert(object_name != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   476
  assert(counter_name != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   477
  size_t full_counter_path_len = strlen(object_name) + strlen(counter_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   478
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   479
  char* full_counter_path;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   480
  size_t jio_snprintf_result = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   481
  if (image_name) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   482
    /*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   483
    * For paths using the "Process" Object.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   484
    *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   485
    * Examples:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   486
    * form:   "\object_name(image_name#instance)\counter_name"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   487
    * actual: "\Process(java#2)\ID Process"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   488
    */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   489
    full_counter_path_len += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   490
    full_counter_path_len += strlen(image_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   491
    /*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   492
    * image_name must be passed together with an associated
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   493
    * instance "number" ("0", "1", "2", ...).
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   494
    * This is required in order to create valid "Process" Object paths.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   495
    *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   496
    * Examples: "\Process(java#0)", \Process(java#1"), ...
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   497
    */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   498
    assert(instance != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   499
    full_counter_path_len += strlen(instance);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   500
    full_counter_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, full_counter_path_len + 1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   501
    if (full_counter_path == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   502
      return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   503
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   504
    jio_snprintf_result = jio_snprintf(full_counter_path,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   505
                                       full_counter_path_len + 1,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   506
                                       PROCESS_OBJECT_INSTANCE_COUNTER_FMT,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   507
                                       object_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   508
                                       image_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   509
                                       instance,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   510
                                       counter_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   511
  } else {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   512
    if (instance) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   513
      /*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   514
      * For paths where the Object has multiple instances.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   515
      *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   516
      * Examples:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   517
      * form:   "\object_name(instance)\counter_name"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   518
      * actual: "\Processor(0)\% Privileged Time"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   519
      */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   520
      full_counter_path_len += strlen(instance);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   521
      full_counter_path_len += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   522
    } else {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   523
      /*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   524
      * For "normal" paths.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   525
      *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   526
      * Examples:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   527
      * form:   "\object_name\counter_name"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   528
      * actual: "\Memory\Available Mbytes"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   529
      */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   530
      full_counter_path_len += OBJECT_COUNTER_FMT_LEN;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   531
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   532
    full_counter_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, full_counter_path_len + 1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   533
    if (full_counter_path == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   534
      return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   535
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   536
    if (instance) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   537
      jio_snprintf_result = jio_snprintf(full_counter_path,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   538
                                         full_counter_path_len + 1,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   539
                                         OBJECT_WITH_INSTANCES_COUNTER_FMT,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   540
                                         object_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   541
                                         instance,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   542
                                         counter_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   543
    } else {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   544
      jio_snprintf_result = jio_snprintf(full_counter_path,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   545
                                         full_counter_path_len + 1,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   546
                                         OBJECT_COUNTER_FMT,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   547
                                         object_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   548
                                         counter_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   549
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   550
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   551
  assert(full_counter_path_len == jio_snprintf_result, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   552
  return full_counter_path;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   553
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   554
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   555
static void log_invalid_pdh_index(DWORD index) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   556
  log_warning(os)("Unable to resolve PDH index: (%ld)", index);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   557
  log_warning(os)("Please check the registry if this performance object/counter is disabled");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   558
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   559
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   560
static bool is_valid_pdh_index(DWORD index) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   561
  DWORD dummy = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   562
  if (PdhDll::PdhLookupPerfNameByIndex(NULL, index, NULL, &dummy) != PDH_MORE_DATA) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   563
    log_invalid_pdh_index(index);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   564
    return false;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   565
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   566
  return true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   567
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   568
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   569
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   570
 * Maps an index to a resource area allocated string for the localized PDH artifact.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   571
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   572
 * Caller will need a ResourceMark.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   573
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   574
 * @param index    the counter index as specified in the registry
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   575
 * @param ppBuffer pointer to a char*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   576
 * @return         OS_OK if successful, OS_ERR on failure.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   577
 */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   578
static OSReturn lookup_name_by_index(DWORD index, char** p_string) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   579
  assert(p_string != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   580
  if (!is_valid_pdh_index(index)) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   581
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   582
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   583
  // determine size needed
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   584
  DWORD size = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   585
  PDH_STATUS status = PdhDll::PdhLookupPerfNameByIndex(NULL, index, NULL, &size);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   586
  assert(status == PDH_MORE_DATA, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   587
  *p_string = NEW_RESOURCE_ARRAY_RETURN_NULL(char, size);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   588
  if (*p_string== NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   589
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   590
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   591
  if (PdhDll::PdhLookupPerfNameByIndex(NULL, index, *p_string, &size) != ERROR_SUCCESS) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   592
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   593
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   594
  if (0 == size || *p_string == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   595
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   596
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   597
  // windows vista does not null-terminate the string (although the docs says it will)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   598
  (*p_string)[size - 1] = '\0';
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   599
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   600
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   601
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   602
static const char* copy_string_to_c_heap(const char* string) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   603
  assert(string != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   604
  const size_t len = strlen(string);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   605
  char* const cheap_allocated_string = NEW_C_HEAP_ARRAY(char, len + 1, mtInternal);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   606
  if (NULL == cheap_allocated_string) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   607
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   608
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   609
  strncpy(cheap_allocated_string, string, len + 1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   610
  return cheap_allocated_string;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   611
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   612
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   613
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   614
* Maps an index to a resource area allocated string for the localized PDH artifact.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   615
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   616
* Caller will need a ResourceMark.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   617
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   618
* @param index    the counter index as specified in the registry
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   619
* @return         localized pdh artifact string if successful, NULL on failure.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   620
*/
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   621
static const char* pdh_localized_artifact(DWORD pdh_artifact_index) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   622
  char* pdh_localized_artifact_string = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   623
  // get localized name from pdh artifact index
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   624
  if (lookup_name_by_index(pdh_artifact_index, &pdh_localized_artifact_string) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   625
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   626
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   627
  return pdh_localized_artifact_string;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   628
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   629
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   630
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   631
 * Returns the PDH string identifying the current process image name.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   632
 * Use this prefix when getting counters from the PDH process object
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   633
 * representing your process.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   634
 * Ex. "Process(java#0)\Virtual Bytes" - where "java" is the PDH process
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   635
 * image description.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   636
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   637
 * Caller needs ResourceMark.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   638
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   639
 * @return the process image description. NULL if the call failed.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   640
*/
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   641
static const char* pdh_process_image_name() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   642
  char* module_name = NEW_RESOURCE_ARRAY_RETURN_NULL(char, MAX_PATH);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   643
  if (NULL == module_name) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   644
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   645
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   646
  // Find our module name and use it to extract the image name used by PDH
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   647
  DWORD getmfn_return = GetModuleFileName(NULL, module_name, MAX_PATH);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   648
  if (getmfn_return >= MAX_PATH || 0 == getmfn_return) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   649
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   650
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   651
  if (os::get_last_error() == ERROR_INSUFFICIENT_BUFFER) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   652
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   653
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   654
  char* process_image_name = strrchr(module_name, '\\'); //drop path
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   655
  process_image_name++;                                  //skip slash
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   656
  char* dot_pos = strrchr(process_image_name, '.');      //drop .exe
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   657
  dot_pos[0] = '\0';
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   658
  return process_image_name;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   659
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   660
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   661
static void deallocate_pdh_constants() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   662
  if (process_image_name != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   663
    FREE_C_HEAP_ARRAY(char, process_image_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   664
    process_image_name = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   665
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   666
  if (pdh_IDProcess_counter_fmt != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   667
    FREE_C_HEAP_ARRAY(char, pdh_IDProcess_counter_fmt);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   668
    pdh_IDProcess_counter_fmt = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   669
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   670
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   671
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   672
static int allocate_pdh_constants() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   673
  assert(process_image_name == NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   674
  const char* pdh_image_name = pdh_process_image_name();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   675
  if (pdh_image_name == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   676
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   677
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   678
  process_image_name = copy_string_to_c_heap(pdh_image_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   679
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   680
  const char* pdh_localized_process_object = pdh_localized_artifact(PDH_PROCESS_IDX);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   681
  if (pdh_localized_process_object == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   682
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   683
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   684
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   685
  const char* pdh_localized_IDProcess_counter = pdh_localized_artifact(PDH_ID_PROCESS_IDX);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   686
  if (pdh_localized_IDProcess_counter == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   687
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   688
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   689
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   690
  size_t pdh_IDProcess_counter_fmt_len = strlen(process_image_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   691
  pdh_IDProcess_counter_fmt_len += strlen(pdh_localized_process_object);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   692
  pdh_IDProcess_counter_fmt_len += strlen(pdh_localized_IDProcess_counter);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   693
  pdh_IDProcess_counter_fmt_len += PROCESS_OBJECT_INSTANCE_COUNTER_FMT_LEN;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   694
  pdh_IDProcess_counter_fmt_len += 2; // "%d"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   695
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   696
  assert(pdh_IDProcess_counter_fmt == NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   697
  pdh_IDProcess_counter_fmt = NEW_C_HEAP_ARRAY_RETURN_NULL(char, pdh_IDProcess_counter_fmt_len + 1, mtInternal);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   698
  if (pdh_IDProcess_counter_fmt == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   699
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   700
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   701
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   702
  /* "\Process(java#%d)\ID Process" */
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   703
  const size_t len = jio_snprintf(pdh_IDProcess_counter_fmt,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   704
                                  pdh_IDProcess_counter_fmt_len + 1,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   705
                                  PROCESS_OBJECT_INSTANCE_COUNTER_FMT,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   706
                                  pdh_localized_process_object,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   707
                                  process_image_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   708
                                  "%d",
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   709
                                  pdh_localized_IDProcess_counter);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   710
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   711
  assert(pdh_IDProcess_counter_fmt != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   712
  assert(len == pdh_IDProcess_counter_fmt_len, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   713
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   714
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   715
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   716
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   717
 * Enuerate the Processor PDH object and returns a buffer containing the enumerated instances.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   718
 * Caller needs ResourceMark;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   719
 *
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   720
 * @return  buffer if successful, NULL on failure.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   721
*/
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   722
static const char* enumerate_cpu_instances() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   723
  char* processor; //'Processor' == PDH_PROCESSOR_IDX
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   724
  if (lookup_name_by_index(PDH_PROCESSOR_IDX, &processor) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   725
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   726
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   727
  DWORD c_size = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   728
  DWORD i_size = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   729
  // enumerate all processors.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   730
  PDH_STATUS pdhStat = PdhDll::PdhEnumObjectItems(NULL, // reserved
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   731
                                                  NULL, // local machine
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   732
                                                  processor, // object to enumerate
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   733
                                                  NULL,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   734
                                                  &c_size,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   735
                                                  NULL, // instance buffer is NULL and
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   736
                                                  &i_size,  // pass 0 length in order to get the required size
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   737
                                                  PERF_DETAIL_WIZARD, // counter detail level
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   738
                                                  0);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   739
  if (PdhDll::PdhStatusFail((pdhStat))) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   740
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   741
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   742
  char* const instances = NEW_RESOURCE_ARRAY_RETURN_NULL(char, i_size);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   743
  if (instances == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   744
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   745
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   746
  c_size = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   747
  pdhStat = PdhDll::PdhEnumObjectItems(NULL, // reserved
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   748
                                       NULL, // local machine
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   749
                                       processor, // object to enumerate
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   750
                                       NULL,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   751
                                       &c_size,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   752
                                       instances, // now instance buffer is allocated to be filled in
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   753
                                       &i_size, // and the required size is known
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   754
                                       PERF_DETAIL_WIZARD, // counter detail level
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   755
                                       0);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   756
  if (PdhDll::PdhStatusFail((pdhStat))) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   757
    return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   758
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   759
  return instances;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   760
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   761
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   762
static int count_logical_cpus(const char* instances) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   763
  assert(instances != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   764
  // count logical instances.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   765
  DWORD count;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   766
  char* tmp;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   767
  for (count = 0, tmp = const_cast<char*>(instances); *tmp != '\0'; tmp = &tmp[strlen(tmp) + 1], count++);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   768
  // PDH reports an instance for each logical processor plus an instance for the total (_Total)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   769
  assert(count == os::processor_count() + 1, "invalid enumeration!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   770
  return count - 1;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   771
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   772
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   773
static int number_of_logical_cpus() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   774
  static int numberOfCPUS = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   775
  if (numberOfCPUS == 0) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   776
    const char* instances = enumerate_cpu_instances();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   777
    if (instances == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   778
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   779
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   780
    numberOfCPUS = count_logical_cpus(instances);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   781
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   782
  return numberOfCPUS;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   783
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   784
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   785
static double cpu_factor() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   786
  static DWORD  numCpus = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   787
  static double cpuFactor = .0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   788
  if (numCpus == 0) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   789
    numCpus = number_of_logical_cpus();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   790
    assert(os::processor_count() <= (int)numCpus, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   791
    cpuFactor = numCpus * 100;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   792
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   793
  return cpuFactor;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   794
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   795
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   796
static void log_error_message_on_no_PDH_artifact(const char* full_counter_name) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   797
  log_warning(os)("Unable to register PDH query for \"%s\"", full_counter_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   798
  log_warning(os)("Please check the registry if this performance object/counter is disabled");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   799
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   800
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   801
static int initialize_cpu_query_counters(MultiCounterQueryP cpu_query, DWORD pdh_counter_idx) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   802
  assert(cpu_query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   803
  assert(cpu_query->counters != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   804
  char* processor; //'Processor' == PDH_PROCESSOR_IDX
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   805
  if (lookup_name_by_index(PDH_PROCESSOR_IDX, &processor) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   806
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   807
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   808
  char* counter_name = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   809
  if (lookup_name_by_index(pdh_counter_idx, &counter_name) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   810
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   811
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   812
  if (cpu_query->query.query == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   813
    if (open_query(cpu_query)) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   814
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   815
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   816
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   817
  assert(cpu_query->query.query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   818
  size_t counter_len = strlen(processor);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   819
  counter_len += strlen(counter_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   820
  counter_len += OBJECT_WITH_INSTANCES_COUNTER_FMT_LEN; // "\\%s(%s)\\%s"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   821
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   822
  DWORD index;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   823
  char* tmp;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   824
  const char* instances = enumerate_cpu_instances();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   825
  for (index = 0, tmp = const_cast<char*>(instances); *tmp != '\0'; tmp = &tmp[strlen(tmp) + 1], index++) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   826
    const size_t tmp_len = strlen(tmp);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   827
    char* counter_path = NEW_RESOURCE_ARRAY_RETURN_NULL(char, counter_len + tmp_len + 1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   828
    if (counter_path == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   829
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   830
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   831
    const size_t jio_snprintf_result = jio_snprintf(counter_path,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   832
                                                    counter_len + tmp_len + 1,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   833
                                                    OBJECT_WITH_INSTANCES_COUNTER_FMT,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   834
                                                    processor,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   835
                                                    tmp, // instance "0", "1", .."_Total"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   836
                                                    counter_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   837
    assert(counter_len + tmp_len == jio_snprintf_result, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   838
    if (add_counter(cpu_query, &cpu_query->counters[index], counter_path, false) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   839
      // performance counter is disabled in registry and not accessible via PerfLib
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   840
      log_error_message_on_no_PDH_artifact(counter_path);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   841
      // return OS_OK to have the system continue to run without the missing counter
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   842
      return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   843
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   844
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   845
  cpu_query->initialized = true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   846
  // Query once to initialize the counters which require at least two samples
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   847
  // (like the % CPU usage) to calculate correctly.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   848
  collect_query_data(cpu_query);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   849
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   850
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   851
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   852
static int initialize_cpu_query(MultiCounterQueryP cpu_query, DWORD pdh_counter_idx) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   853
  assert(cpu_query != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   854
  assert(!cpu_query->initialized, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   855
  const int logical_cpu_count = number_of_logical_cpus();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   856
  assert(logical_cpu_count >= os::processor_count(), "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   857
  // we also add another counter for instance "_Total"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   858
  if (allocate_counters(cpu_query, logical_cpu_count + 1) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   859
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   860
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   861
  assert(cpu_query->noOfCounters == logical_cpu_count + 1, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   862
  return initialize_cpu_query_counters(cpu_query, pdh_counter_idx);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   863
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   864
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   865
static int initialize_process_counter(ProcessQueryP process_query, int slot_index, DWORD pdh_counter_index) {
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   866
  char* localized_process_object;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   867
  if (lookup_name_by_index(PDH_PROCESS_IDX, &localized_process_object) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   868
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   869
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   870
  assert(localized_process_object != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   871
  char* localized_counter_name;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   872
  if (lookup_name_by_index(pdh_counter_index, &localized_counter_name) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   873
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   874
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   875
  assert(localized_counter_name != NULL, "invariant");
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   876
  for (int i = 0; i < process_query->set.size; ++i) {
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   877
    char instanceIndexBuffer[32];
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   878
    const char* counter_path = make_fully_qualified_counter_path(localized_process_object,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   879
                                                                 localized_counter_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   880
                                                                 process_image_name,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   881
                                                                 itoa(i, instanceIndexBuffer, 10));
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   882
    if (counter_path == NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   883
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   884
    }
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   885
    MultiCounterQueryP const query = &process_query->set.queries[i];
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   886
    if (add_process_counter(query, slot_index, counter_path, true)) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   887
      return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   888
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   889
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   890
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   891
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   892
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   893
static CounterQueryP create_counter_query(DWORD pdh_object_idx, DWORD pdh_counter_idx) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   894
  if (!((is_valid_pdh_index(pdh_object_idx) && is_valid_pdh_index(pdh_counter_idx)))) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   895
    return NULL;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   896
  }
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   897
  CounterQueryP const query = create_counter_query();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   898
  const char* object = pdh_localized_artifact(pdh_object_idx);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   899
  assert(object != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   900
  const char* counter = pdh_localized_artifact(pdh_counter_idx);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   901
  assert(counter != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   902
  const char* full_counter_path = make_fully_qualified_counter_path(object, counter);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   903
  assert(full_counter_path != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   904
  add_counter(query, full_counter_path, true);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   905
  return query;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   906
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   907
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   908
static void deallocate() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   909
  deallocate_pdh_constants();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   910
  PdhDll::PdhDetach();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   911
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   912
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   913
static LONG critical_section = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   914
static LONG reference_count = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   915
static bool pdh_initialized = false;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   916
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   917
static void on_initialization_failure() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   918
  // still holder of critical section
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   919
  deallocate();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   920
  InterlockedExchangeAdd(&reference_count, -1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   921
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   922
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   923
static OSReturn initialize() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   924
  ResourceMark rm;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   925
  if (!PdhDll::PdhAttach()) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   926
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   927
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   928
  if (allocate_pdh_constants() != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   929
    on_initialization_failure();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   930
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   931
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   932
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   933
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   934
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   935
/*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   936
* Helper to initialize the PDH library, function pointers, constants and counters.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   937
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   938
* Reference counting allows for unloading of pdh.dll granted all sessions use the pair:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   939
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   940
*   pdh_acquire();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   941
*   pdh_release();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   942
*
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   943
* @return  OS_OK if successful, OS_ERR on failure.
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   944
*/
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   945
static bool pdh_acquire() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   946
  while (InterlockedCompareExchange(&critical_section, 1, 0) == 1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   947
  InterlockedExchangeAdd(&reference_count, 1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   948
  if (pdh_initialized) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   949
    return true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   950
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   951
  const OSReturn ret = initialize();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   952
  if (OS_OK == ret) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   953
    pdh_initialized = true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   954
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   955
  while (InterlockedCompareExchange(&critical_section, 0, 1) == 0);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   956
  return ret == OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   957
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   958
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   959
static void pdh_release() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   960
  while (InterlockedCompareExchange(&critical_section, 1, 0) == 1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   961
  const LONG prev_ref_count = InterlockedExchangeAdd(&reference_count, -1);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   962
  if (1 == prev_ref_count) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   963
    deallocate();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   964
    pdh_initialized = false;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   965
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   966
  while (InterlockedCompareExchange(&critical_section, 0, 1) == 0);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   967
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   968
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   969
class CPUPerformanceInterface::CPUPerformance : public CHeapObj<mtInternal> {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   970
  friend class CPUPerformanceInterface;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   971
 private:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   972
  CounterQueryP _context_switches;
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
   973
  ProcessQueryP _process_cpu_load;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   974
  MultiCounterQueryP _machine_cpu_load;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   975
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   976
  int cpu_load(int which_logical_cpu, double* cpu_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   977
  int context_switch_rate(double* rate);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   978
  int cpu_load_total_process(double* cpu_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   979
  int cpu_loads_process(double* jvm_user_load, double* jvm_kernel_load, double* psystemTotalLoad);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   980
  CPUPerformance();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   981
  ~CPUPerformance();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   982
  bool initialize();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   983
};
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   984
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   985
class SystemProcessInterface::SystemProcesses : public CHeapObj<mtInternal> {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   986
  friend class SystemProcessInterface;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   987
 private:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   988
  class ProcessIterator : public CHeapObj<mtInternal> {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   989
    friend class SystemProcessInterface::SystemProcesses;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   990
   private:
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   991
    HANDLE         _hProcessSnap;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   992
    PROCESSENTRY32 _pe32;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   993
    BOOL           _valid;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   994
    char           _exePath[MAX_PATH];
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   995
    ProcessIterator();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   996
    ~ProcessIterator();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   997
    bool initialize();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   998
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
   999
    int current(SystemProcess* const process_info);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1000
    int next_process();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1001
    bool is_valid() const { return _valid != FALSE; }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1002
    char* allocate_string(const char* str) const;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1003
    int snapshot();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1004
  };
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1005
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1006
  ProcessIterator* _iterator;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1007
  SystemProcesses();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1008
  ~SystemProcesses();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1009
  bool initialize();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1010
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1011
  // information about system processes
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1012
  int system_processes(SystemProcess** system_processes, int* no_of_sys_processes) const;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1013
};
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1014
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1015
CPUPerformanceInterface::CPUPerformance::CPUPerformance() : _context_switches(NULL), _process_cpu_load(NULL), _machine_cpu_load(NULL) {}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1016
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1017
bool CPUPerformanceInterface::CPUPerformance::initialize() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1018
  if (!pdh_acquire()) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1019
    return true;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1020
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1021
  _context_switches = create_counter_query(PDH_SYSTEM_IDX, PDH_CONTEXT_SWITCH_RATE_IDX);
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1022
  _process_cpu_load = create_process_query();
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1023
  if (_process_cpu_load == NULL) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1024
    return true;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1025
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1026
  if (allocate_counters(_process_cpu_load, 2) != OS_OK) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1027
    return true;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1028
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1029
  if (initialize_process_counter(_process_cpu_load, 0, PDH_PROCESSOR_TIME_IDX) != OS_OK) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1030
    return true;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1031
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1032
  if (initialize_process_counter(_process_cpu_load, 1, PDH_PRIV_PROCESSOR_TIME_IDX) != OS_OK) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1033
    return true;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1034
  }
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1035
  _process_cpu_load->set.initialized = true;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1036
  _machine_cpu_load = create_multi_counter_query();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1037
  if (_machine_cpu_load == NULL) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1038
    return true;
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1039
  }
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1040
  initialize_cpu_query(_machine_cpu_load, PDH_PROCESSOR_TIME_IDX);
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1041
  return true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1042
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1043
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1044
CPUPerformanceInterface::CPUPerformance::~CPUPerformance() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1045
  if (_context_switches != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1046
    destroy_counter_query(_context_switches);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1047
    _context_switches = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1048
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1049
  if (_process_cpu_load != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1050
    destroy_counter_query(_process_cpu_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1051
    _process_cpu_load = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1052
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1053
  if (_machine_cpu_load != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1054
    destroy_counter_query(_machine_cpu_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1055
    _machine_cpu_load = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1056
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1057
  pdh_release();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1058
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1059
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1060
CPUPerformanceInterface::CPUPerformanceInterface() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1061
  _impl = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1062
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1063
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1064
bool CPUPerformanceInterface::initialize() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1065
  _impl = new CPUPerformanceInterface::CPUPerformance();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1066
  return _impl != NULL && _impl->initialize();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1067
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1068
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1069
CPUPerformanceInterface::~CPUPerformanceInterface() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1070
  if (_impl != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1071
    delete _impl;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1072
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1073
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1074
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1075
int CPUPerformanceInterface::cpu_load(int which_logical_cpu, double* cpu_load) const {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1076
  return _impl->cpu_load(which_logical_cpu, cpu_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1077
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1078
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1079
int CPUPerformanceInterface::context_switch_rate(double* rate) const {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1080
  return _impl->context_switch_rate(rate);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1081
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1082
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1083
int CPUPerformanceInterface::cpu_load_total_process(double* cpu_load) const {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1084
  return _impl->cpu_load_total_process(cpu_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1085
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1086
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1087
int CPUPerformanceInterface::cpu_loads_process(double* pjvmUserLoad,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1088
                                               double* pjvmKernelLoad,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1089
                                               double* psystemTotalLoad) const {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1090
  return _impl->cpu_loads_process(pjvmUserLoad, pjvmKernelLoad, psystemTotalLoad);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1091
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1092
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1093
int CPUPerformanceInterface::CPUPerformance::cpu_load(int which_logical_cpu, double* cpu_load) {
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1094
  *cpu_load = .0;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1095
  if (_machine_cpu_load == NULL || !_machine_cpu_load->initialized) {
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1096
    return OS_ERR;
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1097
  }
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1098
  assert(_machine_cpu_load != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1099
  assert(which_logical_cpu < _machine_cpu_load->noOfCounters, "invariant");
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1100
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1101
  if (collect_query_data(_machine_cpu_load)) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1102
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1103
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1104
  // -1 is total (all cpus)
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1105
  const int counter_idx = -1 == which_logical_cpu ? _machine_cpu_load->noOfCounters - 1 : which_logical_cpu;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1106
  PDH_FMT_COUNTERVALUE counter_value;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1107
  formatted_counter_value(_machine_cpu_load->counters[counter_idx], PDH_FMT_DOUBLE, &counter_value);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1108
  *cpu_load = counter_value.doubleValue / 100;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1109
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1110
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1111
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1112
int CPUPerformanceInterface::CPUPerformance::cpu_load_total_process(double* cpu_load) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1113
  *cpu_load = .0;
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1114
  if (_process_cpu_load == NULL || !_process_cpu_load->set.initialized) {
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1115
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1116
  }
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1117
  assert(_process_cpu_load != NULL, "invariant");
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1118
  if (collect_process_query_data(_process_cpu_load)) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1119
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1120
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1121
  PDH_FMT_COUNTERVALUE counter_value;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1122
  if (query_process_counter(_process_cpu_load, 0, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &counter_value) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1123
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1124
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1125
  double process_load = counter_value.doubleValue / cpu_factor();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1126
  process_load = MIN2<double>(1, process_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1127
  process_load = MAX2<double>(0, process_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1128
  *cpu_load = process_load;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1129
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1130
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1131
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1132
int CPUPerformanceInterface::CPUPerformance::cpu_loads_process(double* pjvmUserLoad,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1133
                                                               double* pjvmKernelLoad,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1134
                                                               double* psystemTotalLoad) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1135
  assert(pjvmUserLoad != NULL, "pjvmUserLoad is NULL!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1136
  assert(pjvmKernelLoad != NULL, "pjvmKernelLoad is NULL!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1137
  assert(psystemTotalLoad != NULL, "psystemTotalLoad is NULL!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1138
  *pjvmUserLoad = .0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1139
  *pjvmKernelLoad = .0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1140
  *psystemTotalLoad = .0;
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1141
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1142
  if (_process_cpu_load == NULL || !_process_cpu_load->set.initialized) {
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1143
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1144
  }
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1145
  assert(_process_cpu_load != NULL, "invariant");
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1146
  if (collect_process_query_data(_process_cpu_load)) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1147
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1148
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1149
  double process_load = .0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1150
  PDH_FMT_COUNTERVALUE counter_value;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1151
  // Read  PDH_PROCESSOR_TIME_IDX
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1152
  if (query_process_counter(_process_cpu_load, 0, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &counter_value) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1153
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1154
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1155
  process_load = counter_value.doubleValue / cpu_factor();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1156
  process_load = MIN2<double>(1, process_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1157
  process_load = MAX2<double>(0, process_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1158
  // Read PDH_PRIV_PROCESSOR_TIME_IDX
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1159
  if (query_process_counter(_process_cpu_load, 1, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &counter_value) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1160
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1161
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1162
  double kernel_load = counter_value.doubleValue / cpu_factor();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1163
  kernel_load = MIN2<double>(1, kernel_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1164
  kernel_load = MAX2<double>(0, kernel_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1165
  *pjvmKernelLoad = kernel_load;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1166
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1167
  double user_load = process_load - kernel_load;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1168
  user_load = MIN2<double>(1, user_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1169
  user_load = MAX2<double>(0, user_load);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1170
  *pjvmUserLoad = user_load;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1171
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1172
  if (collect_query_data(_machine_cpu_load)) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1173
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1174
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1175
  if (formatted_counter_value(_machine_cpu_load->counters[_machine_cpu_load->noOfCounters - 1], PDH_FMT_DOUBLE, &counter_value) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1176
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1177
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1178
  double machine_load = counter_value.doubleValue / 100;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1179
  assert(machine_load >= 0, "machine_load is negative!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1180
  // clamp at user+system and 1.0
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1181
  if (*pjvmKernelLoad + *pjvmUserLoad > machine_load) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1182
    machine_load = MIN2(*pjvmKernelLoad + *pjvmUserLoad, 1.0);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1183
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1184
  *psystemTotalLoad = machine_load;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1185
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1186
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1187
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1188
int CPUPerformanceInterface::CPUPerformance::context_switch_rate(double* rate) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1189
  assert(rate != NULL, "invariant");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1190
  *rate = .0;
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1191
  if (_context_switches == NULL || !_context_switches->initialized) {
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1192
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1193
  }
50321
b186322970f4 8203321: assert(current_query_index < process_query_set->size) failed: invariant
mgronlun
parents: 50113
diff changeset
  1194
  assert(_context_switches != NULL, "invariant");
50113
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1195
  if (collect_query_data(_context_switches) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1196
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1197
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1198
  PDH_FMT_COUNTERVALUE counter_value;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1199
  if (formatted_counter_value(_context_switches->counter, PDH_FMT_DOUBLE, &counter_value) != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1200
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1201
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1202
  *rate = counter_value.doubleValue;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1203
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1204
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1205
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1206
SystemProcessInterface::SystemProcesses::ProcessIterator::ProcessIterator() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1207
  _hProcessSnap = INVALID_HANDLE_VALUE;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1208
  _valid = FALSE;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1209
  _pe32.dwSize = sizeof(PROCESSENTRY32);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1210
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1211
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1212
bool SystemProcessInterface::SystemProcesses::ProcessIterator::initialize() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1213
  return true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1214
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1215
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1216
int SystemProcessInterface::SystemProcesses::ProcessIterator::snapshot() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1217
  // take snapshot of all process in the system
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1218
  _hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1219
  if (_hProcessSnap == INVALID_HANDLE_VALUE) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1220
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1221
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1222
  // step to first process
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1223
  _valid = Process32First(_hProcessSnap, &_pe32);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1224
  return is_valid() ? OS_OK : OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1225
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1226
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1227
SystemProcessInterface::SystemProcesses::ProcessIterator::~ProcessIterator() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1228
  if (_hProcessSnap != INVALID_HANDLE_VALUE) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1229
    CloseHandle(_hProcessSnap);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1230
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1231
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1232
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1233
int SystemProcessInterface::SystemProcesses::ProcessIterator::current(SystemProcess* process_info) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1234
  assert(is_valid(), "no current process to be fetched!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1235
  assert(process_info != NULL, "process_info is NULL!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1236
  char* exePath = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1237
  HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, false, _pe32.th32ProcessID);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1238
  if (hProcess != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1239
    HMODULE hMod;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1240
    DWORD cbNeeded;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1241
    if (EnumProcessModules(hProcess, &hMod, sizeof(hMod), &cbNeeded) != 0) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1242
      if (GetModuleFileNameExA(hProcess, hMod, _exePath, sizeof(_exePath)) != 0) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1243
        exePath = _exePath;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1244
      }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1245
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1246
    CloseHandle (hProcess);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1247
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1248
  process_info->set_pid((int)_pe32.th32ProcessID);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1249
  process_info->set_name(allocate_string(_pe32.szExeFile));
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1250
  process_info->set_path(allocate_string(exePath));
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1251
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1252
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1253
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1254
char* SystemProcessInterface::SystemProcesses::ProcessIterator::allocate_string(const char* str) const {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1255
  if (str != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1256
    size_t len = strlen(str);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1257
    char* tmp = NEW_C_HEAP_ARRAY(char, len+1, mtInternal);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1258
    if (NULL == tmp) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1259
      return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1260
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1261
    strncpy(tmp, str, len);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1262
    tmp[len] = '\0';
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1263
    return tmp;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1264
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1265
  return NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1266
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1267
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1268
int SystemProcessInterface::SystemProcesses::ProcessIterator::next_process() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1269
  _valid = Process32Next(_hProcessSnap, &_pe32);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1270
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1271
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1272
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1273
SystemProcessInterface::SystemProcesses::SystemProcesses() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1274
  _iterator = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1275
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1276
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1277
bool SystemProcessInterface::SystemProcesses::initialize() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1278
  _iterator = new SystemProcessInterface::SystemProcesses::ProcessIterator();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1279
  return _iterator != NULL && _iterator->initialize();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1280
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1281
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1282
SystemProcessInterface::SystemProcesses::~SystemProcesses() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1283
  if (_iterator != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1284
    delete _iterator;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1285
    _iterator = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1286
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1287
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1288
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1289
int SystemProcessInterface::SystemProcesses::system_processes(SystemProcess** system_processes,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1290
                                                              int* no_of_sys_processes) const {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1291
  assert(system_processes != NULL, "system_processes pointer is NULL!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1292
  assert(no_of_sys_processes != NULL, "system_processes counter pointers is NULL!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1293
  assert(_iterator != NULL, "iterator is NULL!");
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1294
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1295
  // initialize pointers
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1296
  *no_of_sys_processes = 0;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1297
  *system_processes = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1298
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1299
  // take process snapshot
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1300
  if (_iterator->snapshot() != OS_OK) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1301
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1302
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1303
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1304
  while (_iterator->is_valid()) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1305
    SystemProcess* tmp = new SystemProcess();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1306
    _iterator->current(tmp);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1307
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1308
    //if already existing head
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1309
    if (*system_processes != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1310
      //move "first to second"
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1311
      tmp->set_next(*system_processes);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1312
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1313
    // new head
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1314
    *system_processes = tmp;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1315
    // increment
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1316
    (*no_of_sys_processes)++;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1317
    // step forward
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1318
    _iterator->next_process();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1319
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1320
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1321
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1322
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1323
int SystemProcessInterface::system_processes(SystemProcess** system_procs,
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1324
                                             int* no_of_sys_processes) const {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1325
  return _impl->system_processes(system_procs, no_of_sys_processes);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1326
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1327
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1328
SystemProcessInterface::SystemProcessInterface() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1329
  _impl = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1330
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1331
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1332
bool SystemProcessInterface::initialize() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1333
  _impl = new SystemProcessInterface::SystemProcesses();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1334
  return _impl != NULL && _impl->initialize();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1335
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1336
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1337
SystemProcessInterface::~SystemProcessInterface() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1338
  if (_impl != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1339
    delete _impl;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1340
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1341
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1342
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1343
CPUInformationInterface::CPUInformationInterface() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1344
  _cpu_info = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1345
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1346
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1347
bool CPUInformationInterface::initialize() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1348
  _cpu_info = new CPUInformation();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1349
  if (NULL == _cpu_info) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1350
    return false;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1351
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1352
  _cpu_info->set_number_of_hardware_threads(VM_Version_Ext::number_of_threads());
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1353
  _cpu_info->set_number_of_cores(VM_Version_Ext::number_of_cores());
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1354
  _cpu_info->set_number_of_sockets(VM_Version_Ext::number_of_sockets());
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1355
  _cpu_info->set_cpu_name(VM_Version_Ext::cpu_name());
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1356
  _cpu_info->set_cpu_description(VM_Version_Ext::cpu_description());
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1357
  return true;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1358
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1359
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1360
CPUInformationInterface::~CPUInformationInterface() {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1361
  if (_cpu_info != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1362
    const char* cpu_name = _cpu_info->cpu_name();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1363
    if (cpu_name != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1364
      FREE_C_HEAP_ARRAY(char, cpu_name);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1365
      _cpu_info->set_cpu_name(NULL);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1366
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1367
    const char* cpu_desc = _cpu_info->cpu_description();
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1368
    if (cpu_desc != NULL) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1369
      FREE_C_HEAP_ARRAY(char, cpu_desc);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1370
      _cpu_info->set_cpu_description(NULL);
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1371
    }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1372
    delete _cpu_info;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1373
    _cpu_info = NULL;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1374
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1375
}
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1376
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1377
int CPUInformationInterface::cpu_information(CPUInformation& cpu_info) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1378
  if (NULL == _cpu_info) {
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1379
    return OS_ERR;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1380
  }
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1381
  cpu_info = *_cpu_info; // shallow copy assignment
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1382
  return OS_OK;
caf115bb98ad 8199712: Flight Recorder
egahlin
parents:
diff changeset
  1383
}
50879
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1384
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1385
class NetworkPerformanceInterface::NetworkPerformance : public CHeapObj<mtInternal> {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1386
  friend class NetworkPerformanceInterface;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1387
 private:
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1388
  bool _iphlp_attached;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1389
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1390
  NetworkPerformance();
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1391
  NetworkPerformance(const NetworkPerformance& rhs); // no impl
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1392
  NetworkPerformance& operator=(const NetworkPerformance& rhs); // no impl
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1393
  bool initialize();
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1394
  ~NetworkPerformance();
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1395
  int network_utilization(NetworkInterface** network_interfaces) const;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1396
};
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1397
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1398
NetworkPerformanceInterface::NetworkPerformance::NetworkPerformance()
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1399
: _iphlp_attached(false) {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1400
}
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1401
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1402
bool NetworkPerformanceInterface::NetworkPerformance::initialize() {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1403
  _iphlp_attached = IphlpDll::IphlpAttach();
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1404
  return _iphlp_attached;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1405
}
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1406
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1407
NetworkPerformanceInterface::NetworkPerformance::~NetworkPerformance() {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1408
  if (_iphlp_attached) {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1409
    IphlpDll::IphlpDetach();
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1410
  }
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1411
}
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1412
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1413
int NetworkPerformanceInterface::NetworkPerformance::network_utilization(NetworkInterface** network_interfaces) const {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1414
  MIB_IF_TABLE2* table;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1415
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1416
  if (IphlpDll::GetIfTable2(&table) != NO_ERROR) {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1417
    return OS_ERR;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1418
  }
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1419
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1420
  NetworkInterface* ret = NULL;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1421
  for (ULONG i = 0; i < table->NumEntries; ++i) {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1422
    if (table->Table[i].InterfaceAndOperStatusFlags.FilterInterface) {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1423
      continue;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1424
    }
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1425
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1426
    char buf[256];
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1427
    if (WideCharToMultiByte(CP_UTF8, 0, table->Table[i].Description, -1, buf, sizeof(buf), NULL, NULL) == 0) {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1428
      continue;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1429
    }
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1430
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1431
    NetworkInterface* cur = new NetworkInterface(buf, table->Table[i].InOctets, table->Table[i].OutOctets, ret);
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1432
    ret = cur;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1433
  }
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1434
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1435
  IphlpDll::FreeMibTable(table);
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1436
  *network_interfaces = ret;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1437
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1438
  return OS_OK;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1439
}
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1440
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1441
NetworkPerformanceInterface::NetworkPerformanceInterface() {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1442
  _impl = NULL;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1443
}
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1444
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1445
NetworkPerformanceInterface::~NetworkPerformanceInterface() {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1446
  if (_impl != NULL) {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1447
    delete _impl;
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1448
  }
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1449
}
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1450
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1451
bool NetworkPerformanceInterface::initialize() {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1452
  _impl = new NetworkPerformanceInterface::NetworkPerformance();
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1453
  return _impl != NULL && _impl->initialize();
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1454
}
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1455
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1456
int NetworkPerformanceInterface::network_utilization(NetworkInterface** network_interfaces) const {
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1457
  return _impl->network_utilization(network_interfaces);
d90c3cbf13df 8003209: JFR events for network utilization
rwestberg
parents: 50321
diff changeset
  1458
}