1 /*

     2  * Copyright (c) 2012, 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  *

    23  */

    24 

    25 #ifndef SHARE_VM_RUNTIME_OS_PERF_HPP

    26 #define SHARE_VM_RUNTIME_OS_PERF_HPP

    27 

    28 #include "utilities/macros.hpp"

    29 #include "memory/allocation.inline.hpp"

    30 #include "utilities/globalDefinitions.hpp"

    31 

    32 #define FUNCTIONALITY_NOT_IMPLEMENTED -8

    33 

    34 class EnvironmentVariable : public CHeapObj<mtInternal> {

    35  public:

    36   char* _key;

    37   char* _value;

    38 

    39   EnvironmentVariable() {

    40     _key = NULL;

    41     _value = NULL;

    42   }

    43 

    44   ~EnvironmentVariable() {

    45     if (_key != NULL) {

    46       FREE_C_HEAP_ARRAY(char, _key);

    47     }

    48     if (_value != NULL) {

    49       FREE_C_HEAP_ARRAY(char, _value);

    50     }

    51   }

    52 

    53   EnvironmentVariable(char* key, char* value) {

    54     _key = key;

    55     _value = value;

    56   }

    57 

    58 };

    59 

    60 

    61 class CPUInformation : public CHeapObj<mtInternal> {

    62  private:

    63   int   _no_of_sockets;

    64   int   _no_of_cores;

    65   int   _no_of_hw_threads;

    66   const char* _description;

    67   const char* _name;

    68 

    69  public:

    70   CPUInformation() {

    71     _no_of_sockets = 0;

    72     _no_of_cores = 0;

    73     _no_of_hw_threads = 0;

    74     _description = NULL;

    75     _name = NULL;

    76   }

    77 

    78   int number_of_sockets(void) const {

    79     return _no_of_sockets;

    80   }

    81 

    82   void set_number_of_sockets(int no_of_sockets) {

    83     _no_of_sockets = no_of_sockets;

    84   }

    85 

    86   int number_of_cores(void) const {

    87     return _no_of_cores;

    88   }

    89 

    90   void set_number_of_cores(int no_of_cores) {

    91     _no_of_cores = no_of_cores;

    92   }

    93 

    94   int number_of_hardware_threads(void) const {

    95     return _no_of_hw_threads;

    96   }

    97 

    98   void set_number_of_hardware_threads(int no_of_hw_threads) {

    99     _no_of_hw_threads = no_of_hw_threads;

   100   }

   101 

   102   const char* cpu_name(void)  const {

   103     return _name;

   104   }

   105 

   106   void set_cpu_name(const char* cpu_name) {

   107     _name = cpu_name;

   108   }

   109 

   110   const char* cpu_description(void) const {

   111     return _description;

   112   }

   113 

   114   void set_cpu_description(const char* cpu_description) {

   115     _description = cpu_description;

   116   }

   117 };

   118 

   119 class SystemProcess : public CHeapObj<mtInternal> {

   120  private:

   121   int   _pid;

   122   char* _name;

   123   char* _path;

   124   char* _command_line;

   125   SystemProcess* _next;

   126 

   127  public:

   128   SystemProcess() {

   129     _pid  = 0;

   130     _name = NULL;

   131     _path = NULL;

   132     _command_line = NULL;

   133     _next = NULL;

   134   }

   135 

   136   SystemProcess(int pid, char* name, char* path, char* command_line, SystemProcess* next) {

   137     _pid = pid;

   138     _name = name;

   139     _path = path;

   140     _command_line = command_line;

   141     _next = next;

   142   }

   143 

   144   void set_next(SystemProcess* sys_process) {

   145     _next = sys_process;

   146   }

   147 

   148   SystemProcess* next(void) const {

   149     return _next;

   150   }

   151 

   152   int pid(void) const {

   153     return _pid;

   154   }

   155 

   156   void set_pid(int pid) {

   157     _pid = pid;

   158   }

   159 

   160   const char* name(void) const {

   161     return _name;

   162   }

   163 

   164   void set_name(char* name) {

   165     _name = name;

   166   }

   167 

   168   const char* path(void) const {

   169     return _path;

   170   }

   171 

   172   void set_path(char* path) {

   173     _path = path;

   174   }

   175 

   176   const char* command_line(void) const {

   177     return _command_line;

   178   }

   179 

   180   void set_command_line(char* command_line) {

   181     _command_line = command_line;

   182   }

   183 

   184   virtual ~SystemProcess(void) {

   185     if (_name != NULL) {

   186       FREE_C_HEAP_ARRAY(char, _name);

   187     }

   188     if (_path != NULL) {

   189       FREE_C_HEAP_ARRAY(char, _path);

   190     }

   191     if (_command_line != NULL) {

   192       FREE_C_HEAP_ARRAY(char, _command_line);

   193     }

   194   }

   195 };

   196 

   197 class CPUInformationInterface : public CHeapObj<mtInternal> {

   198  private:

   199   CPUInformation* _cpu_info;

   200  public:

   201   CPUInformationInterface();

   202   bool initialize();

   203   ~CPUInformationInterface();

   204   int cpu_information(CPUInformation& cpu_info);

   205 };

   206 

   207 class CPUPerformanceInterface : public CHeapObj<mtInternal> {

   208  private:

   209   class CPUPerformance;

   210   CPUPerformance* _impl;

   211  public:

   212   CPUPerformanceInterface();

   213   ~CPUPerformanceInterface();

   214   bool initialize();

   215 

   216   int cpu_load(int which_logical_cpu, double* const cpu_load) const;

   217   int context_switch_rate(double* const rate) const;

   218   int cpu_load_total_process(double* const cpu_load) const;

   219   int cpu_loads_process(double* const pjvmUserLoad,

   220                         double* const pjvmKernelLoad,

   221                         double* const psystemTotalLoad) const;

   222 };

   223 

   224 class SystemProcessInterface : public CHeapObj<mtInternal> {

   225  private:

   226    class SystemProcesses;

   227    SystemProcesses* _impl;

   228  public:

   229    SystemProcessInterface();

   230    ~SystemProcessInterface();

   231    bool initialize();

   232 

   233   // information about system processes

   234   int system_processes(SystemProcess** system_procs, int* const no_of_sys_processes) const;

   235 };

   236 

   237 #endif // SHARE_VM_RUNTIME_OS_PERF_HPP