infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-05-24 20:38:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

8143125: [aix] Further Developments for AIX

Browse Source 
Port newest AIX port developemnts to OpenJDK.

Reviewed-by: goetz, simonis
This commit is contained in:
Thomas Stuefe 2015-11-16 10:58:14 +01:00
parent c661a50764
commit ff732e0835
14 changed files with 1718 additions and 437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
hotspot/src/os/aix/vm/globals_aix.hpp
View File

@ -29,37 +29,61 @@
//
// Defines Aix specific flags. They are not available on other platforms.
//
// (Please keep the switches sorted alphabetically.)
#define RUNTIME_OS_FLAGS(develop, develop_pd, product, product_pd, diagnostic, notproduct, range, constraint) \
\
/* Whether to allow the VM to run if EXTSHM=ON. EXTSHM is an environment */ \
/* variable used on AIX to activate certain hacks which allow more shm segments */\
/* for 32bit processes. For 64bit processes, it is pointless and may have */ \
/* harmful side effects (e.g. for some reasonn prevents allocation of 64k pages */\
/* via shmctl). */ \
/* Per default we quit with an error if that variable is found; for certain */ \
/* customer scenarios, we may want to be able to run despite that variable. */ \
product(bool, AllowExtshm, false, \
"Allow VM to run with EXTSHM=ON.") \
\
product(intx, AttachListenerTimeout, 1000, \
"Timeout in ms the attach listener waits for a request") \
range(0, 2147483) \
\
/* Maximum expected size of the data segment. That correlates with the */ \
/* to the maximum C Heap consumption we expect. */ \
/* We need to know this because we need to leave "breathing space" for the */ \
/* data segment when placing the java heap. If that space is too small, we */ \
/* reduce our chance of getting a low heap address (needed for compressed */ \
/* Oops). */ \
product(uintx, MaxExpectedDataSegmentSize, (SIZE_4G * 2), \
"Maximum expected Data Segment Size.") \
\
/* Use optimized addresses for the polling page. */ \
product(bool, OptimizePollingPageLocation, true, \
"Optimize the location of the polling page used for Safepoints") \
\
/* Use 64K pages for virtual memory (shmat). */ \
product(bool, Use64KPages, true, \
"Use 64K pages if available.") \
\
/* If UseLargePages == true allow or deny usage of 16M pages. 16M pages are */ \
/* a scarce resource and there may be situations where we do not want the VM */ \
/* to run with 16M pages. (Will fall back to 64K pages). */ \
product_pd(bool, Use16MPages, \
"Use 16M pages if available.") \
/* If VM uses 64K paged memory (shmat) for virtual memory: threshold below */ \
/* which virtual memory allocations are done with 4K memory (mmap). This is */ \
/* mainly for test purposes. */ \
develop(uintx, Use64KPagesThreshold, 0, \
"4K/64K page allocation threshold.") \
\
/* use optimized addresses for the polling page, */ \
/* e.g. map it to a special 32-bit address. */ \
product_pd(bool, OptimizePollingPageLocation, \
"Optimize the location of the polling page used for Safepoints") \
\
product_pd(intx, AttachListenerTimeout, \
"Timeout in ms the attach listener waits for a request") \
range(0, 2147483) \
/* Normally AIX commits memory on touch, but sometimes it is helpful to have */ \
/* explicit commit behaviour. This flag, if true, causes the VM to touch */ \
/* memory on os::commit_memory() (which normally is a noop). */ \
product(bool, UseExplicitCommit, false, \
"Explicit commit for virtual memory.") \
\
// Per default, do not allow 16M pages. 16M pages have to be switched on specifically.
define_pd_global(bool, Use16MPages, false);
define_pd_global(bool, OptimizePollingPageLocation, true);
define_pd_global(intx, AttachListenerTimeout, 1000);
//
// Defines Aix-specific default values. The flags are available on all
// platforms, but they may have different default values on other platforms.
//
// UseLargePages means nothing, for now, on AIX.
// Use Use64KPages or Use16MPages instead.
define_pd_global(bool, UseLargePages, false);
define_pd_global(bool, UseLargePagesIndividualAllocation, false);
define_pd_global(bool, UseOSErrorReporting, false);

38
hotspot/src/os/aix/vm/libo4.cpp Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright 2012, 2015 SAP AG. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
// This is only a stub. Will flesh out later when/if we add further support
// for PASE.
#include "libo4.hpp"
bool libo4::init() { return false; }
void libo4::cleanup() {}
bool libo4::get_memory_info (unsigned long long* p_virt_total, unsigned long long* p_real_total,
unsigned long long* p_real_free, unsigned long long* p_pgsp_total, unsigned long long* p_pgsp_free) {
return false;
}
bool libo4::get_load_avg (double* p_avg1, double* p_avg5, double* p_avg15) { return false; }
bool libo4::realpath (const char* file_name, char* resolved_name, int resolved_name_len) { return false; }

77
hotspot/src/os/aix/vm/libo4.hpp Normal file
View File

@ -0,0 +1,77 @@
/*
* Copyright 2012, 2015 SAP AG. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*
*/
// A C++ wrapper around the libo4 porting library. The libo4 porting library
// is a set of bridge functions into native AS/400 functionality.
#ifndef OS_AIX_VM_LIBO4_HPP
#define OS_AIX_VM_LIBO4_HPP
class libo4 {
public:
// Initialize the libo4 porting library.
// Returns true if succeeded, false if error.
static bool init();
// cleanup of the libo4 porting library.
static void cleanup();
// returns a number of memory statistics from the
// AS/400.
//
// Specify NULL for numbers you are not interested in.
//
// returns false if an error happened. Activate OsMisc trace for
// trace output.
//
static bool get_memory_info (unsigned long long* p_virt_total, unsigned long long* p_real_total,
unsigned long long* p_real_free, unsigned long long* p_pgsp_total, unsigned long long* p_pgsp_free);
// returns information about system load
// (similar to "loadavg()" under other Unices)
//
// Specify NULL for numbers you are not interested in.
//
// returns false if an error happened. Activate OsMisc trace for
// trace output.
//
static bool get_load_avg (double* p_avg1, double* p_avg5, double* p_avg15);
// this is a replacement for the "realpath()" API which does not really work
// on PASE
//
// Specify NULL for numbers you are not interested in.
//
// returns false if an error happened. Activate OsMisc trace for
// trace output.
//
static bool realpath (const char* file_name,
char* resolved_name, int resolved_name_len);
};
#endif // OS_AIX_VM_LIBO4_HPP

299
hotspot/src/os/aix/vm/libperfstat_aix.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012, 2013 SAP AG. All rights reserved.
* Copyright 2012, 2015 SAP AG. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -22,49 +22,50 @@
*
*/
#include "runtime/arguments.hpp"
#include "libperfstat_aix.hpp"
#include "misc_aix.hpp"
// For dlopen and friends
#include <fcntl.h>
#include <dlfcn.h>
#include <sys/systemcfg.h>
// handle to the libperfstat
// Handle to the libperfstat.
static void* g_libhandle = NULL;
// whether initialization worked
static bool g_initialized = false;
typedef int (*fun_perfstat_cpu_total_t) (perfstat_id_t *name, perfstat_cpu_total_t* userbuff,
typedef int (*fun_perfstat_cpu_total_t) (perfstat_id_t *name, PERFSTAT_CPU_TOTAL_T_LATEST* userbuff,
int sizeof_userbuff, int desired_number);
typedef int (*fun_perfstat_memory_total_t) (perfstat_id_t *name, perfstat_memory_total_t* userbuff,
int sizeof_userbuff, int desired_number);
typedef int (*fun_perfstat_partition_total_t) (perfstat_id_t *name,
PERFSTAT_PARTITON_TOTAL_T_LATEST* userbuff, int sizeof_userbuff,
int desired_number);
typedef int (*fun_perfstat_wpar_total_t) (perfstat_id_wpar_t *name,
PERFSTAT_WPAR_TOTAL_T_LATEST* userbuff, int sizeof_userbuff,
int desired_number);
typedef void (*fun_perfstat_reset_t) ();
typedef cid_t (*fun_wpar_getcid_t) ();
static fun_perfstat_cpu_total_t g_fun_perfstat_cpu_total = NULL;
static fun_perfstat_memory_total_t g_fun_perfstat_memory_total = NULL;
static fun_perfstat_partition_total_t g_fun_perfstat_partition_total = NULL;
static fun_perfstat_wpar_total_t g_fun_perfstat_wpar_total = NULL;
static fun_perfstat_reset_t g_fun_perfstat_reset = NULL;
static fun_wpar_getcid_t g_fun_wpar_getcid = NULL;
bool libperfstat::init() {
if (g_initialized) {
return true;
}
g_initialized = false;
// dynamically load the libperfstat porting library.
// Dynamically load the libperfstat porting library.
g_libhandle = dlopen("/usr/lib/libperfstat.a(shr_64.o)", RTLD_MEMBER | RTLD_NOW);
if (!g_libhandle) {
if (Verbose) {
fprintf(stderr, "Cannot load libperfstat.a (dlerror: %s)", dlerror());
}
trcVerbose("Cannot load libperfstat.a (dlerror: %s)", dlerror());
return false;
}
// resolve function pointers
// Resolve function pointers
#define RESOLVE_FUN_NO_ERROR(name) \
g_fun_##name = (fun_##name##_t) dlsym(g_libhandle, #name);
@ -72,26 +73,28 @@ bool libperfstat::init() {
#define RESOLVE_FUN(name) \
RESOLVE_FUN_NO_ERROR(name) \
if (!g_fun_##name) { \
if (Verbose) { \
fprintf(stderr, "Cannot resolve " #name "() from libperfstat.a\n" \
trcVerbose("Cannot resolve " #name "() from libperfstat.a\n" \
" (dlerror: %s)", dlerror()); \
} \
return false; \
}
// These functions may or may not be there depending on the OS release.
RESOLVE_FUN_NO_ERROR(perfstat_partition_total);
RESOLVE_FUN_NO_ERROR(perfstat_wpar_total);
RESOLVE_FUN_NO_ERROR(wpar_getcid);
// These functions are required for every release.
RESOLVE_FUN(perfstat_cpu_total);
RESOLVE_FUN(perfstat_memory_total);
RESOLVE_FUN(perfstat_reset);
g_initialized = true;
trcVerbose("libperfstat loaded.");
return true;
}
void libperfstat::cleanup() {
g_initialized = false;
if (g_libhandle) {
dlclose(g_libhandle);
g_libhandle = NULL;
@ -99,26 +102,250 @@ void libperfstat::cleanup() {
g_fun_perfstat_cpu_total = NULL;
g_fun_perfstat_memory_total = NULL;
g_fun_perfstat_partition_total = NULL;
g_fun_perfstat_wpar_total = NULL;
g_fun_perfstat_reset = NULL;
g_fun_wpar_getcid = NULL;
}
int libperfstat::perfstat_memory_total(perfstat_id_t *name,
perfstat_memory_total_t* userbuff,
int sizeof_userbuff, int desired_number) {
assert(g_initialized, "libperfstat not initialized");
assert(g_fun_perfstat_memory_total, "");
if (g_fun_perfstat_memory_total == NULL) {
return -1;
}
return g_fun_perfstat_memory_total(name, userbuff, sizeof_userbuff, desired_number);
}
int libperfstat::perfstat_cpu_total(perfstat_id_t *name, perfstat_cpu_total_t* userbuff,
int libperfstat::perfstat_cpu_total(perfstat_id_t *name, PERFSTAT_CPU_TOTAL_T_LATEST* userbuff,
int sizeof_userbuff, int desired_number) {
assert(g_initialized, "libperfstat not initialized");
assert(g_fun_perfstat_cpu_total, "");
if (g_fun_perfstat_cpu_total == NULL) {
return -1;
}
return g_fun_perfstat_cpu_total(name, userbuff, sizeof_userbuff, desired_number);
}
void libperfstat::perfstat_reset() {
assert(g_initialized, "libperfstat not initialized");
assert(g_fun_perfstat_reset, "");
g_fun_perfstat_reset();
int libperfstat::perfstat_partition_total(perfstat_id_t *name, PERFSTAT_PARTITON_TOTAL_T_LATEST* userbuff,
int sizeof_userbuff, int desired_number) {
if (g_fun_perfstat_partition_total == NULL) {
return -1;
}
return g_fun_perfstat_partition_total(name, userbuff, sizeof_userbuff, desired_number);
}
int libperfstat::perfstat_wpar_total(perfstat_id_wpar_t *name, PERFSTAT_WPAR_TOTAL_T_LATEST* userbuff,
int sizeof_userbuff, int desired_number) {
if (g_fun_perfstat_wpar_total == NULL) {
return -1;
}
return g_fun_perfstat_wpar_total(name, userbuff, sizeof_userbuff, desired_number);
}
void libperfstat::perfstat_reset() {
if (g_fun_perfstat_reset != NULL) {
g_fun_perfstat_reset();
}
}
cid_t libperfstat::wpar_getcid() {
if (g_fun_wpar_getcid == NULL) {
return (cid_t) -1;
}
return g_fun_wpar_getcid();
}
//////////////////// convenience functions, release-independent /////////////////////////////
// Excerpts from systemcfg.h definitions newer than AIX 5.3 (our oldest build platform)
#define PV_6 0x100000 /* Power PC 6 */
#define PV_6_1 0x100001 /* Power PC 6 DD1.x */
#define PV_7 0x200000 /* Power PC 7 */
#define PV_5_Compat 0x0F8000 /* Power PC 5 */
#define PV_6_Compat 0x108000 /* Power PC 6 */
#define PV_7_Compat 0x208000 /* Power PC 7 */
#define PV_8 0x300000 /* Power PC 8 */
#define PV_8_Compat 0x308000 /* Power PC 8 */
// Retrieve global cpu information.
bool libperfstat::get_cpuinfo(cpuinfo_t* pci) {
assert(pci, "get_cpuinfo: invalid parameter");
memset(pci, 0, sizeof(cpuinfo_t));
PERFSTAT_CPU_TOTAL_T_LATEST psct;
memset (&psct, '\0', sizeof(psct));
if (-1 == libperfstat::perfstat_cpu_total(NULL, &psct, sizeof(PERFSTAT_CPU_TOTAL_T_LATEST), 1)) {
if (-1 == libperfstat::perfstat_cpu_total(NULL, &psct, sizeof(perfstat_cpu_total_t_61), 1)) {
if (-1 == libperfstat::perfstat_cpu_total(NULL, &psct, sizeof(perfstat_cpu_total_t_53), 1)) {
trcVerbose("perfstat_cpu_total() failed (errno=%d)", errno);
return false;
}
}
}
// Global cpu information.
strcpy (pci->description, psct.description);
pci->processorHZ = psct.processorHZ;
pci->ncpus = psct.ncpus;
for (int i = 0; i < 3; i++) {
pci->loadavg[i] = (double) psct.loadavg[i] / (1 << SBITS);
}
pci->user_clock_ticks = psct.user;
pci->sys_clock_ticks = psct.sys;
pci->idle_clock_ticks = psct.idle;
pci->wait_clock_ticks = psct.wait;
// Get the processor version from _system_configuration.
switch (_system_configuration.version) {
case PV_8:
strcpy(pci->version, "Power PC 8");
break;
case PV_7:
strcpy(pci->version, "Power PC 7");
break;
case PV_6_1:
strcpy(pci->version, "Power PC 6 DD1.x");
break;
case PV_6:
strcpy(pci->version, "Power PC 6");
break;
case PV_5:
strcpy(pci->version, "Power PC 5");
break;
case PV_5_2:
strcpy(pci->version, "Power PC 5_2");
break;
case PV_5_3:
strcpy(pci->version, "Power PC 5_3");
break;
case PV_5_Compat:
strcpy(pci->version, "PV_5_Compat");
break;
case PV_6_Compat:
strcpy(pci->version, "PV_6_Compat");
break;
case PV_7_Compat:
strcpy(pci->version, "PV_7_Compat");
break;
case PV_8_Compat:
strcpy(pci->version, "PV_8_Compat");
break;
default:
strcpy(pci->version, "unknown");
}
return true;
}
// Retrieve partition information.
bool libperfstat::get_partitioninfo(partitioninfo_t* ppi) {
assert(ppi, "get_partitioninfo: invalid parameter");
memset(ppi, 0, sizeof(partitioninfo_t));
PERFSTAT_PARTITON_TOTAL_T_LATEST pspt;
memset(&pspt, '\0', sizeof(pspt));
bool ame_details = true;
if (-1 == libperfstat::perfstat_partition_total(NULL, &pspt, sizeof(PERFSTAT_PARTITON_TOTAL_T_LATEST), 1)) {
if (-1 == libperfstat::perfstat_partition_total(NULL, &pspt, sizeof(perfstat_partition_total_t_71), 1)) {
ame_details = false;
if (-1 == libperfstat::perfstat_partition_total(NULL, &pspt, sizeof(perfstat_partition_total_t_61), 1)) {
if (-1 == libperfstat::perfstat_partition_total(NULL, &pspt, sizeof(perfstat_partition_total_t_53), 1)) {
if (-1 == libperfstat::perfstat_partition_total(NULL, &pspt, sizeof(perfstat_partition_total_t_53_5), 1)) {
trcVerbose("perfstat_partition_total() failed (errno=%d)", errno);
return false;
}
}
}
}
}
// partition type info
ppi->shared_enabled = pspt.type.b.shared_enabled;
ppi->smt_capable = pspt.type.b.smt_capable;
ppi->smt_enabled = pspt.type.b.smt_enabled;
ppi->lpar_capable = pspt.type.b.lpar_capable;
ppi->lpar_enabled = pspt.type.b.lpar_enabled;
ppi->dlpar_capable = pspt.type.b.dlpar_capable;
ppi->capped = pspt.type.b.capped;
ppi->kernel_is_64 = pspt.type.b.kernel_is_64;
ppi->pool_util_authority = pspt.type.b.pool_util_authority;
ppi->donate_capable = pspt.type.b.donate_capable;
ppi->donate_enabled = pspt.type.b.donate_enabled;
ppi->ams_capable = pspt.type.b.ams_capable;
ppi->ams_enabled = pspt.type.b.ams_enabled;
ppi->power_save = pspt.type.b.power_save;
ppi->ame_enabled = pspt.type.b.ame_enabled;
// partition total info
ppi->online_cpus = pspt.online_cpus;
ppi->entitled_proc_capacity = pspt.entitled_proc_capacity;
ppi->var_proc_capacity_weight = pspt.var_proc_capacity_weight;
ppi->phys_cpus_pool = pspt.phys_cpus_pool;
ppi->pool_id = pspt.pool_id;
ppi->entitled_pool_capacity = pspt.entitled_pool_capacity;
strcpy(ppi->name, pspt.name);
// Added values to ppi that we need for later computation of cpu utilization
// ( pool authorization needed for pool_idle_time ??? )
ppi->timebase_last = pspt.timebase_last;
ppi->pool_idle_time = pspt.pool_idle_time;
ppi->pcpu_tics_user = pspt.puser;
ppi->pcpu_tics_sys = pspt.psys;
ppi->pcpu_tics_idle = pspt.pidle;
ppi->pcpu_tics_wait = pspt.pwait;
// Additional AME information.
if (ame_details) {
ppi->true_memory = pspt.true_memory * 4096;
ppi->expanded_memory = pspt.expanded_memory * 4096;
ppi->target_memexp_factr = pspt.target_memexp_factr;
ppi->current_memexp_factr = pspt.current_memexp_factr;
ppi->cmcs_total_time = pspt.cmcs_total_time;
}
return true;
}
// Retrieve wpar information.
bool libperfstat::get_wparinfo(wparinfo_t* pwi) {
assert(pwi, "get_wparinfo: invalid parameter");
memset(pwi, 0, sizeof(wparinfo_t));
if (libperfstat::wpar_getcid() <= 0) {
return false;
}
PERFSTAT_WPAR_TOTAL_T_LATEST pswt;
memset (&pswt, '\0', sizeof(pswt));
if (-1 == libperfstat::perfstat_wpar_total(NULL, &pswt, sizeof(PERFSTAT_WPAR_TOTAL_T_LATEST), 1)) {
if (-1 == libperfstat::perfstat_wpar_total(NULL, &pswt, sizeof(perfstat_wpar_total_t_61), 1)) {
trcVerbose("perfstat_wpar_total() failed (errno=%d)", errno);
return false;
}
}
// WPAR type info.
pwi->app_wpar = pswt.type.b.app_wpar;
pwi->cpu_rset = pswt.type.b.cpu_rset;
pwi->cpu_xrset = pswt.type.b.cpu_xrset;
pwi->cpu_limits = pswt.type.b.cpu_limits;
pwi->mem_limits = pswt.type.b.mem_limits;
// WPAR total info.
strcpy(pwi->name, pswt.name);
pwi->wpar_id = pswt.wpar_id;
pwi->cpu_limit = pswt.cpu_limit;
pwi->mem_limit = pswt.mem_limit;
return true;
}

825
hotspot/src/os/aix/vm/libperfstat_aix.hpp
View File

@ -22,7 +22,7 @@
*
*/
// encapsulates the libperfstat library.
// Encapsulates the libperfstat library.
//
// The purpose of this code is to dynamically load the libperfstat library
// instead of statically linking against it. The libperfstat library is an
@ -32,7 +32,732 @@
#ifndef OS_AIX_VM_LIBPERFSTAT_AIX_HPP
#define OS_AIX_VM_LIBPERFSTAT_AIX_HPP
#include <libperfstat.h>
#include <sys/types.h>
#include <stdlib.h>
///////////////////////////////////////////////////////////////////////////////////////////////
// These are excerpts from the AIX 5.3, 6.1, 7.1 libperfstat.h -
// this is all we need from libperfstat.h and I want to avoid having to include <libperfstat.h>
//
// Note: I define all structures as if I were to include libperfstat.h on an AIX 5.2
// build machine.
//
// The ratio behind that is that if I would build on an AIX 5.2 build machine,
// include libperfstat.h and hard-link against libperfstat.a, the program should
// work without recompilation on all newer AIX versions.
//
#define IDENTIFIER_LENGTH 64 /* length of strings included in the structures */
typedef struct { /* structure element identifier */
char name[IDENTIFIER_LENGTH]; /* name of the identifier */
} perfstat_id_t;
#define CEC_ID_LEN 40 /* CEC identifier length */
#define MAXCORRALNAMELEN 25 /* length of the wpar name */
#define FIRST_WPARNAME "" /* pseudo-name for the first WPAR */
#define FIRST_WPARID -1 /* pseudo-id for the first WPAR */
typedef unsigned short cid_t; /* workload partition identifier */
typedef struct { /* Virtual memory utilization */
u_longlong_t virt_total; /* total virtual memory (in 4KB pages) */
u_longlong_t real_total; /* total real memory (in 4KB pages) */
u_longlong_t real_free; /* free real memory (in 4KB pages) */
u_longlong_t real_pinned; /* real memory which is pinned (in 4KB pages) */
u_longlong_t real_inuse; /* real memory which is in use (in 4KB pages) */
u_longlong_t pgbad; /* number of bad pages */
u_longlong_t pgexct; /* number of page faults */
u_longlong_t pgins; /* number of pages paged in */
u_longlong_t pgouts; /* number of pages paged out */
u_longlong_t pgspins; /* number of page ins from paging space */
u_longlong_t pgspouts; /* number of page outs from paging space */
u_longlong_t scans; /* number of page scans by clock */
u_longlong_t cycles; /* number of page replacement cycles */
u_longlong_t pgsteals; /* number of page steals */
u_longlong_t numperm; /* number of frames used for files (in 4KB pages) */
u_longlong_t pgsp_total; /* total paging space (in 4KB pages) */
u_longlong_t pgsp_free; /* free paging space (in 4KB pages) */
u_longlong_t pgsp_rsvd; /* reserved paging space (in 4KB pages) */
u_longlong_t real_system; /* real memory used by system segments (in 4KB pages). This is the sum of all the used pages in segment marked for system usage.
* Since segment classifications are not always guaranteed to be accurate, this number is only an approximation. */
u_longlong_t real_user; /* real memory used by non-system segments (in 4KB pages). This is the sum of all pages used in segments not marked for system usage.
* Since segment classifications are not always guaranteed to be accurate, this number is only an approximation. */
u_longlong_t real_process; /* real memory used by process segments (in 4KB pages). This is real_total-real_free-numperm-real_system. Since real_system is an
* approximation, this number is too. */
u_longlong_t virt_active; /* Active virtual pages. Virtual pages are considered active if they have been accessed */
} perfstat_memory_total_t;
typedef struct { /* global cpu information AIX 5.3 < TL10 */
int ncpus; /* number of active logical processors */
int ncpus_cfg; /* number of configured processors */
char description[IDENTIFIER_LENGTH]; /* processor description (type/official name) */
u_longlong_t processorHZ; /* processor speed in Hz */
u_longlong_t user; /* raw total number of clock ticks spent in user mode */
u_longlong_t sys; /* raw total number of clock ticks spent in system mode */
u_longlong_t idle; /* raw total number of clock ticks spent idle */
u_longlong_t wait; /* raw total number of clock ticks spent waiting for I/O */
u_longlong_t pswitch; /* number of process switches (change in currently running process) */
u_longlong_t syscall; /* number of system calls executed */
u_longlong_t sysread; /* number of read system calls executed */
u_longlong_t syswrite; /* number of write system calls executed */
u_longlong_t sysfork; /* number of forks system calls executed */
u_longlong_t sysexec; /* number of execs system calls executed */
u_longlong_t readch; /* number of characters tranferred with read system call */
u_longlong_t writech; /* number of characters tranferred with write system call */
u_longlong_t devintrs; /* number of device interrupts */
u_longlong_t softintrs; /* number of software interrupts */
time_t lbolt; /* number of ticks since last reboot */
u_longlong_t loadavg[3]; /* (1<<SBITS) times the average number of runnables processes during the last 1, 5 and 15 minutes.
* To calculate the load average, divide the numbers by (1<<SBITS). SBITS is defined in <sys/proc.h>. */
u_longlong_t runque; /* length of the run queue (processes ready) */
u_longlong_t swpque; /* ength of the swap queue (processes waiting to be paged in) */
u_longlong_t bread; /* number of blocks read */
u_longlong_t bwrite; /* number of blocks written */
u_longlong_t lread; /* number of logical read requests */
u_longlong_t lwrite; /* number of logical write requests */
u_longlong_t phread; /* number of physical reads (reads on raw devices) */
u_longlong_t phwrite; /* number of physical writes (writes on raw devices) */
u_longlong_t runocc; /* updated whenever runque is updated, i.e. the runqueue is occupied.
* This can be used to compute the simple average of ready processes */
u_longlong_t swpocc; /* updated whenever swpque is updated. i.e. the swpqueue is occupied.
* This can be used to compute the simple average processes waiting to be paged in */
u_longlong_t iget; /* number of inode lookups */
u_longlong_t namei; /* number of vnode lookup from a path name */
u_longlong_t dirblk; /* number of 512-byte block reads by the directory search routine to locate an entry for a file */
u_longlong_t msg; /* number of IPC message operations */
u_longlong_t sema; /* number of IPC semaphore operations */
u_longlong_t rcvint; /* number of tty receive interrupts */
u_longlong_t xmtint; /* number of tyy transmit interrupts */
u_longlong_t mdmint; /* number of modem interrupts */
u_longlong_t tty_rawinch; /* number of raw input characters */
u_longlong_t tty_caninch; /* number of canonical input characters (always zero) */
u_longlong_t tty_rawoutch; /* number of raw output characters */
u_longlong_t ksched; /* number of kernel processes created */
u_longlong_t koverf; /* kernel process creation attempts where:
* -the user has forked to their maximum limit
* -the configuration limit of processes has been reached */
u_longlong_t kexit; /* number of kernel processes that became zombies */
u_longlong_t rbread; /* number of remote read requests */
u_longlong_t rcread; /* number of cached remote reads */
u_longlong_t rbwrt; /* number of remote writes */
u_longlong_t rcwrt; /* number of cached remote writes */
u_longlong_t traps; /* number of traps */
int ncpus_high; /* index of highest processor online */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t decrintrs; /* number of decrementer tics interrupts */
u_longlong_t mpcrintrs; /* number of mpc's received interrupts */
u_longlong_t mpcsintrs; /* number of mpc's sent interrupts */
u_longlong_t phantintrs; /* number of phantom interrupts */
u_longlong_t idle_donated_purr; /* number of idle cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_donated_spurr; /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_purr; /* number of busy cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_spurr; /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_stolen_purr; /* number of idle cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t idle_stolen_spurr; /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_purr; /* number of busy cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_spurr; /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
short iowait; /* number of processes that are asleep waiting for buffered I/O */
short physio; /* number of processes waiting for raw I/O */
longlong_t twait; /* number of threads that are waiting for filesystem direct(cio) */
u_longlong_t hpi; /* number of hypervisor page-ins */
u_longlong_t hpit; /* Time spent in hypervisor page-ins (in nanoseconds) */
} perfstat_cpu_total_t_53;
typedef struct { /* global cpu information AIX 6.1|5.3 > TL09 */
int ncpus; /* number of active logical processors */
int ncpus_cfg; /* number of configured processors */
char description[IDENTIFIER_LENGTH]; /* processor description (type/official name) */
u_longlong_t processorHZ; /* processor speed in Hz */
u_longlong_t user; /* raw total number of clock ticks spent in user mode */
u_longlong_t sys; /* raw total number of clock ticks spent in system mode */
u_longlong_t idle; /* raw total number of clock ticks spent idle */
u_longlong_t wait; /* raw total number of clock ticks spent waiting for I/O */
u_longlong_t pswitch; /* number of process switches (change in currently running process) */
u_longlong_t syscall; /* number of system calls executed */
u_longlong_t sysread; /* number of read system calls executed */
u_longlong_t syswrite; /* number of write system calls executed */
u_longlong_t sysfork; /* number of forks system calls executed */
u_longlong_t sysexec; /* number of execs system calls executed */
u_longlong_t readch; /* number of characters tranferred with read system call */
u_longlong_t writech; /* number of characters tranferred with write system call */
u_longlong_t devintrs; /* number of device interrupts */
u_longlong_t softintrs; /* number of software interrupts */
time_t lbolt; /* number of ticks since last reboot */
u_longlong_t loadavg[3]; /* (1<<SBITS) times the average number of runnables processes during the last 1, 5 and 15 minutes.
* To calculate the load average, divide the numbers by (1<<SBITS). SBITS is defined in <sys/proc.h>. */
u_longlong_t runque; /* length of the run queue (processes ready) */
u_longlong_t swpque; /* length of the swap queue (processes waiting to be paged in) */
u_longlong_t bread; /* number of blocks read */
u_longlong_t bwrite; /* number of blocks written */
u_longlong_t lread; /* number of logical read requests */
u_longlong_t lwrite; /* number of logical write requests */
u_longlong_t phread; /* number of physical reads (reads on raw devices) */
u_longlong_t phwrite; /* number of physical writes (writes on raw devices) */
u_longlong_t runocc; /* updated whenever runque is updated, i.e. the runqueue is occupied.
* This can be used to compute the simple average of ready processes */
u_longlong_t swpocc; /* updated whenever swpque is updated. i.e. the swpqueue is occupied.
* This can be used to compute the simple average processes waiting to be paged in */
u_longlong_t iget; /* number of inode lookups */
u_longlong_t namei; /* number of vnode lookup from a path name */
u_longlong_t dirblk; /* number of 512-byte block reads by the directory search routine to locate an entry for a file */
u_longlong_t msg; /* number of IPC message operations */
u_longlong_t sema; /* number of IPC semaphore operations */
u_longlong_t rcvint; /* number of tty receive interrupts */
u_longlong_t xmtint; /* number of tyy transmit interrupts */
u_longlong_t mdmint; /* number of modem interrupts */
u_longlong_t tty_rawinch; /* number of raw input characters */
u_longlong_t tty_caninch; /* number of canonical input characters (always zero) */
u_longlong_t tty_rawoutch; /* number of raw output characters */
u_longlong_t ksched; /* number of kernel processes created */
u_longlong_t koverf; /* kernel process creation attempts where:
* -the user has forked to their maximum limit
* -the configuration limit of processes has been reached */
u_longlong_t kexit; /* number of kernel processes that became zombies */
u_longlong_t rbread; /* number of remote read requests */
u_longlong_t rcread; /* number of cached remote reads */
u_longlong_t rbwrt; /* number of remote writes */
u_longlong_t rcwrt; /* number of cached remote writes */
u_longlong_t traps; /* number of traps */
int ncpus_high; /* index of highest processor online */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t decrintrs; /* number of decrementer tics interrupts */
u_longlong_t mpcrintrs; /* number of mpc's received interrupts */
u_longlong_t mpcsintrs; /* number of mpc's sent interrupts */
u_longlong_t phantintrs; /* number of phantom interrupts */
u_longlong_t idle_donated_purr; /* number of idle cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_donated_spurr; /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_purr; /* number of busy cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_spurr; /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_stolen_purr; /* number of idle cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t idle_stolen_spurr; /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_purr; /* number of busy cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_spurr; /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
short iowait; /* number of processes that are asleep waiting for buffered I/O */
short physio; /* number of processes waiting for raw I/O */
longlong_t twait; /* number of threads that are waiting for filesystem direct(cio) */
u_longlong_t hpi; /* number of hypervisor page-ins */
u_longlong_t hpit; /* Time spent in hypervisor page-ins (in nanoseconds) */
u_longlong_t puser_spurr; /* number of spurr cycles spent in user mode */
u_longlong_t psys_spurr; /* number of spurr cycles spent in kernel mode */
u_longlong_t pidle_spurr; /* number of spurr cycles spent in idle mode */
u_longlong_t pwait_spurr; /* number of spurr cycles spent in wait mode */
int spurrflag; /* set if running in spurr mode */
} perfstat_cpu_total_t_61;
typedef struct { /* global cpu information AIX 7.1 */
int ncpus; /* number of active logical processors */
int ncpus_cfg; /* number of configured processors */
char description[IDENTIFIER_LENGTH]; /* processor description (type/official name) */
u_longlong_t processorHZ; /* processor speed in Hz */
u_longlong_t user; /* raw total number of clock ticks spent in user mode */
u_longlong_t sys; /* raw total number of clock ticks spent in system mode */
u_longlong_t idle; /* raw total number of clock ticks spent idle */
u_longlong_t wait; /* raw total number of clock ticks spent waiting for I/O */
u_longlong_t pswitch; /* number of process switches (change in currently running process) */
u_longlong_t syscall; /* number of system calls executed */
u_longlong_t sysread; /* number of read system calls executed */
u_longlong_t syswrite; /* number of write system calls executed */
u_longlong_t sysfork; /* number of forks system calls executed */
u_longlong_t sysexec; /* number of execs system calls executed */
u_longlong_t readch; /* number of characters tranferred with read system call */
u_longlong_t writech; /* number of characters tranferred with write system call */
u_longlong_t devintrs; /* number of device interrupts */
u_longlong_t softintrs; /* number of software interrupts */
time_t lbolt; /* number of ticks since last reboot */
u_longlong_t loadavg[3]; /* (1<<SBITS) times the average number of runnables processes during the last 1, 5 and 15 minutes.
* To calculate the load average, divide the numbers by (1<<SBITS). SBITS is defined in <sys/proc.h>. */
u_longlong_t runque; /* length of the run queue (processes ready) */
u_longlong_t swpque; /* ength of the swap queue (processes waiting to be paged in) */
u_longlong_t bread; /* number of blocks read */
u_longlong_t bwrite; /* number of blocks written */
u_longlong_t lread; /* number of logical read requests */
u_longlong_t lwrite; /* number of logical write requests */
u_longlong_t phread; /* number of physical reads (reads on raw devices) */
u_longlong_t phwrite; /* number of physical writes (writes on raw devices) */
u_longlong_t runocc; /* updated whenever runque is updated, i.e. the runqueue is occupied.
* This can be used to compute the simple average of ready processes */
u_longlong_t swpocc; /* updated whenever swpque is updated. i.e. the swpqueue is occupied.
* This can be used to compute the simple average processes waiting to be paged in */
u_longlong_t iget; /* number of inode lookups */
u_longlong_t namei; /* number of vnode lookup from a path name */
u_longlong_t dirblk; /* number of 512-byte block reads by the directory search routine to locate an entry for a file */
u_longlong_t msg; /* number of IPC message operations */
u_longlong_t sema; /* number of IPC semaphore operations */
u_longlong_t rcvint; /* number of tty receive interrupts */
u_longlong_t xmtint; /* number of tyy transmit interrupts */
u_longlong_t mdmint; /* number of modem interrupts */
u_longlong_t tty_rawinch; /* number of raw input characters */
u_longlong_t tty_caninch; /* number of canonical input characters (always zero) */
u_longlong_t tty_rawoutch; /* number of raw output characters */
u_longlong_t ksched; /* number of kernel processes created */
u_longlong_t koverf; /* kernel process creation attempts where:
* -the user has forked to their maximum limit
* -the configuration limit of processes has been reached */
u_longlong_t kexit; /* number of kernel processes that became zombies */
u_longlong_t rbread; /* number of remote read requests */
u_longlong_t rcread; /* number of cached remote reads */
u_longlong_t rbwrt; /* number of remote writes */
u_longlong_t rcwrt; /* number of cached remote writes */
u_longlong_t traps; /* number of traps */
int ncpus_high; /* index of highest processor online */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t decrintrs; /* number of decrementer tics interrupts */
u_longlong_t mpcrintrs; /* number of mpc's received interrupts */
u_longlong_t mpcsintrs; /* number of mpc's sent interrupts */
u_longlong_t phantintrs; /* number of phantom interrupts */
u_longlong_t idle_donated_purr; /* number of idle cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_donated_spurr; /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_purr; /* number of busy cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_spurr; /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_stolen_purr; /* number of idle cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t idle_stolen_spurr; /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_purr; /* number of busy cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_spurr; /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
short iowait; /* number of processes that are asleep waiting for buffered I/O */
short physio; /* number of processes waiting for raw I/O */
longlong_t twait; /* number of threads that are waiting for filesystem direct(cio) */
u_longlong_t hpi; /* number of hypervisor page-ins */
u_longlong_t hpit; /* Time spent in hypervisor page-ins (in nanoseconds) */
u_longlong_t puser_spurr; /* number of spurr cycles spent in user mode */
u_longlong_t psys_spurr; /* number of spurr cycles spent in kernel mode */
u_longlong_t pidle_spurr; /* number of spurr cycles spent in idle mode */
u_longlong_t pwait_spurr; /* number of spurr cycles spent in wait mode */
int spurrflag; /* set if running in spurr mode */
u_longlong_t version; /* version number (1, 2, etc.,) */
/* >>>>> END OF STRUCTURE DEFINITION <<<<< */
#define CURR_VERSION_CPU_TOTAL 1 /* Incremented by one for every new release *
* of perfstat_cpu_total_t data structure */
} perfstat_cpu_total_t_71;
typedef union {
uint w;
struct {
unsigned smt_capable :1; /* OS supports SMT mode */
unsigned smt_enabled :1; /* SMT mode is on */
unsigned lpar_capable :1; /* OS supports logical partitioning */
unsigned lpar_enabled :1; /* logical partitioning is on */
unsigned shared_capable :1; /* OS supports shared processor LPAR */
unsigned shared_enabled :1; /* partition runs in shared mode */
unsigned dlpar_capable :1; /* OS supports dynamic LPAR */
unsigned capped :1; /* partition is capped */
unsigned kernel_is_64 :1; /* kernel is 64 bit */
unsigned pool_util_authority :1; /* pool utilization available */
unsigned donate_capable :1; /* capable of donating cycles */
unsigned donate_enabled :1; /* enabled for donating cycles */
unsigned ams_capable:1; /* 1 = AMS(Active Memory Sharing) capable, 0 = Not AMS capable */
unsigned ams_enabled:1; /* 1 = AMS(Active Memory Sharing) enabled, 0 = Not AMS enabled */
unsigned power_save:1; /* 1 = Power saving mode is enabled */
unsigned ame_enabled:1; /* Active Memory Expansion is enabled */
unsigned shared_extended :1;
unsigned spare :15; /* reserved for future usage */
} b;
} perfstat_partition_type_t;
typedef struct { /* partition total information AIX 5.3 < TL6 */
char name[IDENTIFIER_LENGTH]; /* name of the logical partition */
perfstat_partition_type_t type; /* set of bits describing the partition */
int lpar_id; /* logical partition identifier */
int group_id; /* identifier of the LPAR group this partition is a member of */
int pool_id; /* identifier of the shared pool of physical processors this partition is a member of */
int online_cpus; /* number of virtual CPUs currently online on the partition */
int max_cpus; /* maximum number of virtual CPUs this parition can ever have */
int min_cpus; /* minimum number of virtual CPUs this partition must have */
u_longlong_t online_memory; /* amount of memory currently online */
u_longlong_t max_memory; /* maximum amount of memory this partition can ever have */
u_longlong_t min_memory; /* minimum amount of memory this partition must have */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
int max_proc_capacity; /* maximum number of processor units this partition can ever have */
int min_proc_capacity; /* minimum number of processor units this partition must have */
int proc_capacity_increment; /* increment value to the entitled capacity */
int unalloc_proc_capacity; /* number of processor units currently unallocated in the shared processor pool this partition belongs to */
int var_proc_capacity_weight; /* partition priority weight to receive extra capacity */
int unalloc_var_proc_capacity_weight; /* number of variable processor capacity weight units currently unallocated in the shared processor pool this partition belongs to */
int online_phys_cpus_sys; /* number of physical CPUs currently active in the system containing this partition */
int max_phys_cpus_sys; /* maximum possible number of physical CPUs in the system containing this partition */
int phys_cpus_pool; /* number of the physical CPUs currently in the shared processor pool this partition belong to */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t pool_idle_time; /* number of clock tics a processor in the shared pool was idle */
u_longlong_t phantintrs; /* number of phantom interrupts received by the partition */
u_longlong_t invol_virt_cswitch; /* number involuntary virtual CPU context switches */
u_longlong_t vol_virt_cswitch; /* number voluntary virtual CPU context switches */
u_longlong_t timebase_last; /* most recently cpu time base */
u_longlong_t reserved_pages; /* Currenlty number of 16GB pages. Cannot participate in DR operations */
u_longlong_t reserved_pagesize; /* Currently 16GB pagesize Cannot participate in DR operations */
} perfstat_partition_total_t_53_5;
typedef struct { /* partition total information AIX 5.3 < TL10 */
char name[IDENTIFIER_LENGTH]; /* name of the logical partition */
perfstat_partition_type_t type; /* set of bits describing the partition */
int lpar_id; /* logical partition identifier */
int group_id; /* identifier of the LPAR group this partition is a member of */
int pool_id; /* identifier of the shared pool of physical processors this partition is a member of */
int online_cpus; /* number of virtual CPUs currently online on the partition */
int max_cpus; /* maximum number of virtual CPUs this parition can ever have */
int min_cpus; /* minimum number of virtual CPUs this partition must have */
u_longlong_t online_memory; /* amount of memory currently online */
u_longlong_t max_memory; /* maximum amount of memory this partition can ever have */
u_longlong_t min_memory; /* minimum amount of memory this partition must have */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
int max_proc_capacity; /* maximum number of processor units this partition can ever have */
int min_proc_capacity; /* minimum number of processor units this partition must have */
int proc_capacity_increment; /* increment value to the entitled capacity */
int unalloc_proc_capacity; /* number of processor units currently unallocated in the shared processor pool this partition belongs to */
int var_proc_capacity_weight; /* partition priority weight to receive extra capacity */
int unalloc_var_proc_capacity_weight; /* number of variable processor capacity weight units currently unallocated in the shared processor pool this partition belongs to */
int online_phys_cpus_sys; /* number of physical CPUs currently active in the system containing this partition */
int max_phys_cpus_sys; /* maximum possible number of physical CPUs in the system containing this partition */
int phys_cpus_pool; /* number of the physical CPUs currently in the shared processor pool this partition belong to */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t pool_idle_time; /* number of clock tics a processor in the shared pool was idle */
u_longlong_t phantintrs; /* number of phantom interrupts received by the partition */
u_longlong_t invol_virt_cswitch; /* number involuntary virtual CPU context switches */
u_longlong_t vol_virt_cswitch; /* number voluntary virtual CPU context switches */
u_longlong_t timebase_last; /* most recently cpu time base */
u_longlong_t reserved_pages; /* Currenlty number of 16GB pages. Cannot participate in DR operations */
u_longlong_t reserved_pagesize; /* Currently 16GB pagesize Cannot participate in DR operations */
u_longlong_t idle_donated_purr; /* number of idle cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_donated_spurr; /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_purr; /* number of busy cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_spurr; /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_stolen_purr; /* number of idle cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t idle_stolen_spurr; /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_purr; /* number of busy cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_spurr; /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t shcpus_in_sys; /* Number of physical processors allocated for shared processor use */
u_longlong_t max_pool_capacity; /* Maximum processor capacity of partitions pool */
u_longlong_t entitled_pool_capacity; /* Entitled processor capacity of partitions pool */
u_longlong_t pool_max_time; /* Summation of maximum time that could be consumed by the pool (nano seconds) */
u_longlong_t pool_busy_time; /* Summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t pool_scaled_busy_time; /* Scaled summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t shcpu_tot_time; /* Summation of total time across all physical processors allocated for shared processor use (nano seconds) */
u_longlong_t shcpu_busy_time; /* Summation of busy (non-idle) time accumulated across all shared processor partitions (nano seconds) */
u_longlong_t shcpu_scaled_busy_time; /* Scaled summation of busy time accumulated across all shared processor partitions (nano seconds) */
int ams_pool_id; /* AMS pool id of the pool the LPAR belongs to */
int var_mem_weight; /* variable memory capacity weight */
u_longlong_t iome; /* I/O memory entitlement of the partition in bytes*/
u_longlong_t pmem; /* Physical memory currently backing the partition's logical memory in bytes*/
u_longlong_t hpi; /* number of hypervisor page-ins */
u_longlong_t hpit; /* Time spent in hypervisor page-ins (in nanoseconds)*/
u_longlong_t hypv_pagesize; /* Hypervisor page size in KB*/
} perfstat_partition_total_t_53;
typedef struct { /* partition total information AIX 6.1|5.3 > TL09 */
char name[IDENTIFIER_LENGTH]; /* name of the logical partition */
perfstat_partition_type_t type; /* set of bits describing the partition */
int lpar_id; /* logical partition identifier */
int group_id; /* identifier of the LPAR group this partition is a member of */
int pool_id; /* identifier of the shared pool of physical processors this partition is a member of */
int online_cpus; /* number of virtual CPUs currently online on the partition */
int max_cpus; /* maximum number of virtual CPUs this parition can ever have */
int min_cpus; /* minimum number of virtual CPUs this partition must have */
u_longlong_t online_memory; /* amount of memory currently online */
u_longlong_t max_memory; /* maximum amount of memory this partition can ever have */
u_longlong_t min_memory; /* minimum amount of memory this partition must have */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
int max_proc_capacity; /* maximum number of processor units this partition can ever have */
int min_proc_capacity; /* minimum number of processor units this partition must have */
int proc_capacity_increment; /* increment value to the entitled capacity */
int unalloc_proc_capacity; /* number of processor units currently unallocated in the shared processor pool this partition belongs to */
int var_proc_capacity_weight; /* partition priority weight to receive extra capacity */
int unalloc_var_proc_capacity_weight; /* number of variable processor capacity weight units currently unallocated in the shared processor pool this partition belongs to */
int online_phys_cpus_sys; /* number of physical CPUs currently active in the system containing this partition */
int max_phys_cpus_sys; /* maximum possible number of physical CPUs in the system containing this partition */
int phys_cpus_pool; /* number of the physical CPUs currently in the shared processor pool this partition belong to */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t pool_idle_time; /* number of clock tics a processor in the shared pool was idle */
u_longlong_t phantintrs; /* number of phantom interrupts received by the partition */
u_longlong_t invol_virt_cswitch; /* number involuntary virtual CPU context switches */
u_longlong_t vol_virt_cswitch; /* number voluntary virtual CPU context switches */
u_longlong_t timebase_last; /* most recently cpu time base */
u_longlong_t reserved_pages; /* Currenlty number of 16GB pages. Cannot participate in DR operations */
u_longlong_t reserved_pagesize; /* Currently 16GB pagesize Cannot participate in DR operations */
u_longlong_t idle_donated_purr; /* number of idle cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_donated_spurr; /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_purr; /* number of busy cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_spurr; /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_stolen_purr; /* number of idle cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t idle_stolen_spurr; /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_purr; /* number of busy cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_spurr; /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t shcpus_in_sys; /* Number of physical processors allocated for shared processor use */
u_longlong_t max_pool_capacity; /* Maximum processor capacity of partitions pool */
u_longlong_t entitled_pool_capacity; /* Entitled processor capacity of partitions pool */
u_longlong_t pool_max_time; /* Summation of maximum time that could be consumed by the pool (nano seconds) */
u_longlong_t pool_busy_time; /* Summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t pool_scaled_busy_time; /* Scaled summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t shcpu_tot_time; /* Summation of total time across all physical processors allocated for shared processor use (nano seconds) */
u_longlong_t shcpu_busy_time; /* Summation of busy (non-idle) time accumulated across all shared processor partitions (nano seconds) */
u_longlong_t shcpu_scaled_busy_time; /* Scaled summation of busy time accumulated across all shared processor partitions (nano seconds) */
int ams_pool_id; /* AMS pool id of the pool the LPAR belongs to */
int var_mem_weight; /* variable memory capacity weight */
u_longlong_t iome; /* I/O memory entitlement of the partition in bytes*/
u_longlong_t pmem; /* Physical memory currently backing the partition's logical memory in bytes*/
u_longlong_t hpi; /* number of hypervisor page-ins */
u_longlong_t hpit; /* Time spent in hypervisor page-ins (in nanoseconds)*/
u_longlong_t hypv_pagesize; /* Hypervisor page size in KB*/
uint online_lcpus; /* number of online logical cpus */
uint smt_thrds; /* number of hardware threads that are running */
u_longlong_t puser_spurr; /* number of spurr cycles spent in user mode */
u_longlong_t psys_spurr; /* number of spurr cycles spent in kernel mode */
u_longlong_t pidle_spurr; /* number of spurr cycles spent in idle mode */
u_longlong_t pwait_spurr; /* number of spurr cycles spent in wait mode */
int spurrflag; /* set if running in spurr mode */
} perfstat_partition_total_t_61;
typedef struct { /* partition total information AIX 7.1 */
char name[IDENTIFIER_LENGTH]; /* name of the logical partition */
perfstat_partition_type_t type; /* set of bits describing the partition */
int lpar_id; /* logical partition identifier */
int group_id; /* identifier of the LPAR group this partition is a member of */
int pool_id; /* identifier of the shared pool of physical processors this partition is a member of */
int online_cpus; /* number of virtual CPUs currently online on the partition */
int max_cpus; /* maximum number of virtual CPUs this parition can ever have */
int min_cpus; /* minimum number of virtual CPUs this partition must have */
u_longlong_t online_memory; /* amount of memory currently online */
u_longlong_t max_memory; /* maximum amount of memory this partition can ever have */
u_longlong_t min_memory; /* minimum amount of memory this partition must have */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
int max_proc_capacity; /* maximum number of processor units this partition can ever have */
int min_proc_capacity; /* minimum number of processor units this partition must have */
int proc_capacity_increment; /* increment value to the entitled capacity */
int unalloc_proc_capacity; /* number of processor units currently unallocated in the shared processor pool this partition belongs to */
int var_proc_capacity_weight; /* partition priority weight to receive extra capacity */
int unalloc_var_proc_capacity_weight; /* number of variable processor capacity weight units currently unallocated in the shared processor pool this partition belongs to */
int online_phys_cpus_sys; /* number of physical CPUs currently active in the system containing this partition */
int max_phys_cpus_sys; /* maximum possible number of physical CPUs in the system containing this partition */
int phys_cpus_pool; /* number of the physical CPUs currently in the shared processor pool this partition belong to */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t pool_idle_time; /* number of clock tics a processor in the shared pool was idle */
u_longlong_t phantintrs; /* number of phantom interrupts received by the partition */
u_longlong_t invol_virt_cswitch; /* number involuntary virtual CPU context switches */
u_longlong_t vol_virt_cswitch; /* number voluntary virtual CPU context switches */
u_longlong_t timebase_last; /* most recently cpu time base */
u_longlong_t reserved_pages; /* Currenlty number of 16GB pages. Cannot participate in DR operations */
u_longlong_t reserved_pagesize; /* Currently 16GB pagesize Cannot participate in DR operations */
u_longlong_t idle_donated_purr; /* number of idle cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_donated_spurr; /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_purr; /* number of busy cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_spurr; /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_stolen_purr; /* number of idle cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t idle_stolen_spurr; /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_purr; /* number of busy cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_spurr; /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t shcpus_in_sys; /* Number of physical processors allocated for shared processor use */
u_longlong_t max_pool_capacity; /* Maximum processor capacity of partitions pool */
u_longlong_t entitled_pool_capacity; /* Entitled processor capacity of partitions pool */
u_longlong_t pool_max_time; /* Summation of maximum time that could be consumed by the pool (nano seconds) */
u_longlong_t pool_busy_time; /* Summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t pool_scaled_busy_time; /* Scaled summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t shcpu_tot_time; /* Summation of total time across all physical processors allocated for shared processor use (nano seconds) */
u_longlong_t shcpu_busy_time; /* Summation of busy (non-idle) time accumulated across all shared processor partitions (nano seconds) */
u_longlong_t shcpu_scaled_busy_time; /* Scaled summation of busy time accumulated across all shared processor partitions (nano seconds) */
int ams_pool_id; /* AMS pool id of the pool the LPAR belongs to */
int var_mem_weight; /* variable memory capacity weight */
u_longlong_t iome; /* I/O memory entitlement of the partition in bytes*/
u_longlong_t pmem; /* Physical memory currently backing the partition's logical memory in bytes*/
u_longlong_t hpi; /* number of hypervisor page-ins */
u_longlong_t hpit; /* Time spent in hypervisor page-ins (in nanoseconds)*/
u_longlong_t hypv_pagesize; /* Hypervisor page size in KB*/
uint online_lcpus; /* number of online logical cpus */
uint smt_thrds; /* number of hardware threads that are running */
u_longlong_t puser_spurr; /* number of spurr cycles spent in user mode */
u_longlong_t psys_spurr; /* number of spurr cycles spent in kernel mode */
u_longlong_t pidle_spurr; /* number of spurr cycles spent in idle mode */
u_longlong_t pwait_spurr; /* number of spurr cycles spent in wait mode */
int spurrflag; /* set if running in spurr mode */
char hardwareid[CEC_ID_LEN]; /* CEC Identifier */
uint power_save_mode; /* Power save mode for the LPAR. Introduced through LI 53K PRF : Feature 728 292*/
ushort ame_version; /* AME Version */
u_longlong_t true_memory; /* True Memory Size in 4KB pages */
u_longlong_t expanded_memory; /* Expanded Memory Size in 4KB pages */
u_longlong_t target_memexp_factr; /* Target Memory Expansion Factor scaled by 100 */
u_longlong_t current_memexp_factr; /* Current Memory Expansion Factor scaled by 100 */
u_longlong_t target_cpool_size; /* Target Compressed Pool Size in bytes */
u_longlong_t max_cpool_size; /* Max Size of Compressed Pool in bytes */
u_longlong_t min_ucpool_size; /* Min Size of Uncompressed Pool in bytes */
u_longlong_t ame_deficit_size; /*Deficit memory size in bytes */
u_longlong_t version; /* version number (1, 2, etc.,) */
u_longlong_t cmcs_total_time; /* Total CPU time spent due to active memory expansion */
} perfstat_partition_total_t_71;
typedef struct { /* partition total information AIX 7.1 >= TL1*/
char name[IDENTIFIER_LENGTH]; /* name of the logical partition */
perfstat_partition_type_t type; /* set of bits describing the partition */
int lpar_id; /* logical partition identifier */
int group_id; /* identifier of the LPAR group this partition is a member of */
int pool_id; /* identifier of the shared pool of physical processors this partition is a member of */
int online_cpus; /* number of virtual CPUs currently online on the partition */
int max_cpus; /* maximum number of virtual CPUs this parition can ever have */
int min_cpus; /* minimum number of virtual CPUs this partition must have */
u_longlong_t online_memory; /* amount of memory currently online */
u_longlong_t max_memory; /* maximum amount of memory this partition can ever have */
u_longlong_t min_memory; /* minimum amount of memory this partition must have */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
int max_proc_capacity; /* maximum number of processor units this partition can ever have */
int min_proc_capacity; /* minimum number of processor units this partition must have */
int proc_capacity_increment; /* increment value to the entitled capacity */
int unalloc_proc_capacity; /* number of processor units currently unallocated in the shared processor pool this partition belongs to */
int var_proc_capacity_weight; /* partition priority weight to receive extra capacity */
int unalloc_var_proc_capacity_weight; /* number of variable processor capacity weight units currently unallocated in the shared processor pool this partition belongs to */
int online_phys_cpus_sys; /* number of physical CPUs currently active in the system containing this partition */
int max_phys_cpus_sys; /* maximum possible number of physical CPUs in the system containing this partition */
int phys_cpus_pool; /* number of the physical CPUs currently in the shared processor pool this partition belong to */
u_longlong_t puser; /* raw number of physical processor tics in user mode */
u_longlong_t psys; /* raw number of physical processor tics in system mode */
u_longlong_t pidle; /* raw number of physical processor tics idle */
u_longlong_t pwait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t pool_idle_time; /* number of clock tics a processor in the shared pool was idle */
u_longlong_t phantintrs; /* number of phantom interrupts received by the partition */
u_longlong_t invol_virt_cswitch; /* number involuntary virtual CPU context switches */
u_longlong_t vol_virt_cswitch; /* number voluntary virtual CPU context switches */
u_longlong_t timebase_last; /* most recently cpu time base */
u_longlong_t reserved_pages; /* Currenlty number of 16GB pages. Cannot participate in DR operations */
u_longlong_t reserved_pagesize; /* Currently 16GB pagesize Cannot participate in DR operations */
u_longlong_t idle_donated_purr; /* number of idle cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_donated_spurr; /* number of idle spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_purr; /* number of busy cycles donated by a dedicated partition enabled for donation */
u_longlong_t busy_donated_spurr; /* number of busy spurr cycles donated by a dedicated partition enabled for donation */
u_longlong_t idle_stolen_purr; /* number of idle cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t idle_stolen_spurr; /* number of idle spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_purr; /* number of busy cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t busy_stolen_spurr; /* number of busy spurr cycles stolen by the hypervisor from a dedicated partition */
u_longlong_t shcpus_in_sys; /* Number of physical processors allocated for shared processor use */
u_longlong_t max_pool_capacity; /* Maximum processor capacity of partitions pool */
u_longlong_t entitled_pool_capacity; /* Entitled processor capacity of partitions pool */
u_longlong_t pool_max_time; /* Summation of maximum time that could be consumed by the pool (nano seconds) */
u_longlong_t pool_busy_time; /* Summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t pool_scaled_busy_time; /* Scaled summation of busy (non-idle) time accumulated across all partitions in the pool (nano seconds) */
u_longlong_t shcpu_tot_time; /* Summation of total time across all physical processors allocated for shared processor use (nano seconds) */
u_longlong_t shcpu_busy_time; /* Summation of busy (non-idle) time accumulated across all shared processor partitions (nano seconds) */
u_longlong_t shcpu_scaled_busy_time; /* Scaled summation of busy time accumulated across all shared processor partitions (nano seconds) */
int ams_pool_id; /* AMS pool id of the pool the LPAR belongs to */
int var_mem_weight; /* variable memory capacity weight */
u_longlong_t iome; /* I/O memory entitlement of the partition in bytes*/
u_longlong_t pmem; /* Physical memory currently backing the partition's logical memory in bytes*/
u_longlong_t hpi; /* number of hypervisor page-ins */
u_longlong_t hpit; /* Time spent in hypervisor page-ins (in nanoseconds)*/
u_longlong_t hypv_pagesize; /* Hypervisor page size in KB*/
uint online_lcpus; /* number of online logical cpus */
uint smt_thrds; /* number of hardware threads that are running */
u_longlong_t puser_spurr; /* number of spurr cycles spent in user mode */
u_longlong_t psys_spurr; /* number of spurr cycles spent in kernel mode */
u_longlong_t pidle_spurr; /* number of spurr cycles spent in idle mode */
u_longlong_t pwait_spurr; /* number of spurr cycles spent in wait mode */
int spurrflag; /* set if running in spurr mode */
char hardwareid[CEC_ID_LEN]; /* CEC Identifier */
uint power_save_mode; /* Power save mode for the LPAR. Introduced through LI 53K PRF : Feature 728 292*/
ushort ame_version; /* AME Version */
u_longlong_t true_memory; /* True Memory Size in 4KB pages */
u_longlong_t expanded_memory; /* Expanded Memory Size in 4KB pages */
u_longlong_t target_memexp_factr; /* Target Memory Expansion Factor scaled by 100 */
u_longlong_t current_memexp_factr; /* Current Memory Expansion Factor scaled by 100 */
u_longlong_t target_cpool_size; /* Target Compressed Pool Size in bytes */
u_longlong_t max_cpool_size; /* Max Size of Compressed Pool in bytes */
u_longlong_t min_ucpool_size; /* Min Size of Uncompressed Pool in bytes */
u_longlong_t ame_deficit_size; /*Deficit memory size in bytes */
u_longlong_t version; /* version number (1, 2, etc.,) */
u_longlong_t cmcs_total_time; /* Total CPU time spent due to active memory expansion */
u_longlong_t purr_coalescing; /* If the calling partition is authorized to see pool wide statistics then PURR cycles consumed to coalesce data else set to zero.*/
u_longlong_t spurr_coalescing; /* If the calling partition is authorized to see pool wide statistics then SPURR cycles consumed to coalesce data else set to zero.*/
u_longlong_t MemPoolSize; /* Indicates the memory pool size of the pool that the partition belongs to (in bytes)., mpsz */
u_longlong_t IOMemEntInUse; /* I/O memory entitlement of the LPAR in use in bytes. iomu */
u_longlong_t IOMemEntFree; /* free I/O memory entitlement in bytes. iomf */
u_longlong_t IOHighWaterMark; /* high water mark of I/O memory entitlement usage in bytes. iohwn */
u_longlong_t purr_counter; /* number of purr cycles spent in user + kernel mode */
u_longlong_t spurr_counter; /* number of spurr cycles spent in user + kernel mode */
/* Marketing Requirement(MR): MR1124083744 */
u_longlong_t real_free; /* free real memory (in 4KB pages) */
u_longlong_t real_avail; /* number of pages available for user application (memfree + numperm - minperm - minfree) */
/* >>>>> END OF STRUCTURE DEFINITION <<<<< */
#define CURR_VERSION_PARTITION_TOTAL 5 /* Incremented by one for every new release *
* of perfstat_partition_total_t data structure */
} perfstat_partition_total_t_71_1;
typedef union { /* WPAR Type & Flags */
uint w;
struct {
unsigned app_wpar :1; /* Application WPAR */
unsigned cpu_rset :1; /* WPAR restricted to CPU resource set */
unsigned cpu_xrset:1; /* WPAR restricted to CPU Exclusive resource set */
unsigned cpu_limits :1; /* CPU resource limits enforced */
unsigned mem_limits :1; /* Memory resource limits enforced */
unsigned spare :27; /* reserved for future usage */
} b;
} perfstat_wpar_type_t;
typedef struct { /* Workload partition Information AIX 5.3 & 6.1*/
char name[MAXCORRALNAMELEN+1]; /* name of the Workload Partition */
perfstat_wpar_type_t type; /* set of bits describing the wpar */
cid_t wpar_id; /* workload partition identifier */
uint online_cpus; /* Number of Virtual CPUs in partition rset or number of virtual CPUs currently online on the Global partition*/
int cpu_limit; /* CPU limit in 100ths of % - 1..10000 */
int mem_limit; /* Memory limit in 100ths of % - 1..10000 */
u_longlong_t online_memory; /* amount of memory currently online in Global Partition */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
} perfstat_wpar_total_t_61;
typedef struct { /* Workload partition Information AIX 7.1*/
char name[MAXCORRALNAMELEN+1]; /* name of the Workload Partition */
perfstat_wpar_type_t type; /* set of bits describing the wpar */
cid_t wpar_id; /* workload partition identifier */
uint online_cpus; /* Number of Virtual CPUs in partition rset or number of virtual CPUs currently online on the Global partition*/
int cpu_limit; /* CPU limit in 100ths of % - 1..10000 */
int mem_limit; /* Memory limit in 100ths of % - 1..10000 */
u_longlong_t online_memory; /* amount of memory currently online in Global Partition */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
u_longlong_t version; /* version number (1, 2, etc.,) */
/* >>>>> END OF STRUCTURE DEFINITION <<<<< */
#define CURR_VERSION_WPAR_TOTAL 1 /* Incremented by one for every new release *
* of perfstat_wpar_total_t data structure */
} perfstat_wpar_total_t_71;
typedef void * rsethandle_t; /* Type to identify a resource set handle: rsethandle_t */
typedef enum { WPARNAME, WPARID, RSETHANDLE } wparid_specifier; /* Type of wparid_specifier */
typedef struct { /* WPAR identifier */
wparid_specifier spec; /* Specifier to choose wpar id or name */
union {
cid_t wpar_id; /* WPAR ID */
rsethandle_t rset; /* Rset Handle */
char wparname[MAXCORRALNAMELEN+1]; /* WPAR NAME */
} u;
char name[IDENTIFIER_LENGTH]; /* name of the structure element identifier */
} perfstat_id_wpar_t;
// end: libperfstat.h (AIX 5.2, 5.3, 6.1, 7.1)
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define PERFSTAT_PARTITON_TOTAL_T_LATEST perfstat_partition_total_t_71_1/* latest perfstat_partition_total_t structure */
#define PERFSTAT_CPU_TOTAL_T_LATEST perfstat_cpu_total_t_71 /* latest perfstat_cpu_total_t structure */
#define PERFSTAT_WPAR_TOTAL_T_LATEST perfstat_wpar_total_t_71 /* latest perfstat_wpar_total_t structure */
class libperfstat {
@ -41,19 +766,107 @@ public:
// Load the libperfstat library (must be in LIBPATH).
// Returns true if succeeded, false if error.
static bool init();
// cleanup of the libo4 porting library.
static void cleanup();
// direct wrappers for the libperfstat functionality. All they do is
// Direct wrappers for the libperfstat functionality. All they do is
// to call the functions with the same name via function pointers.
static int perfstat_cpu_total(perfstat_id_t *name, perfstat_cpu_total_t* userbuff,
// Get all available data also on newer AIX versions (PERFSTAT_CPU_TOTAL_T_LATEST).
static int perfstat_cpu_total(perfstat_id_t *name, PERFSTAT_CPU_TOTAL_T_LATEST* userbuff,
int sizeof_userbuff, int desired_number);
static int perfstat_memory_total(perfstat_id_t *name, perfstat_memory_total_t* userbuff,
int sizeof_userbuff, int desired_number);
static int perfstat_partition_total(perfstat_id_t *name, PERFSTAT_PARTITON_TOTAL_T_LATEST* userbuff,
int sizeof_userbuff, int desired_number);
static void perfstat_reset();
static int perfstat_wpar_total(perfstat_id_wpar_t *name, PERFSTAT_WPAR_TOTAL_T_LATEST* userbuff,
int sizeof_userbuff, int desired_number);
static cid_t wpar_getcid();
////////////////////////////////////////////////////////////////
// The convenience functions get_partitioninfo(), get_cpuinfo(), get_wparinfo() return
// information about partition, cpu and wpars, respectivly. They can be used without
// regard for which OS release we are on. On older AIX release, some output structure
// members will be 0.
// Result struct for get_partitioninfo().
struct partitioninfo_t {
// partition type info
unsigned smt_capable :1; /* OS supports SMT mode */
unsigned smt_enabled :1; /* SMT mode is on */
unsigned lpar_capable :1; /* OS supports logical partitioning */
unsigned lpar_enabled :1; /* logical partitioning is on */
unsigned shared_capable :1; /* OS supports shared processor LPAR */
unsigned shared_enabled :1; /* partition runs in shared mode */
unsigned dlpar_capable :1; /* OS supports dynamic LPAR */
unsigned capped :1; /* partition is capped */
unsigned kernel_is_64 :1; /* kernel is 64 bit */
unsigned pool_util_authority :1; /* pool utilization available */
unsigned donate_capable :1; /* capable of donating cycles */
unsigned donate_enabled :1; /* enabled for donating cycles */
unsigned ams_capable:1; /* 1 = AMS(Active Memory Sharing) capable, 0 = Not AMS capable */
unsigned ams_enabled:1; /* 1 = AMS(Active Memory Sharing) enabled, 0 = Not AMS enabled */
unsigned power_save:1; /* 1 = Power saving mode is enabled */
unsigned ame_enabled:1; /* Active Memory Expansion is enabled */
// partition total info
int online_cpus; /* number of virtual CPUs currently online on the partition */
int entitled_proc_capacity; /* number of processor units this partition is entitled to receive */
int var_proc_capacity_weight; /* partition priority weight to receive extra capacity */
int phys_cpus_pool; /* number of the physical CPUs currently in the shared processor pool this partition belong to */
int pool_id; /* identifier of the shared pool of physical processors this partition is a member of */
u_longlong_t entitled_pool_capacity; /* Entitled processor capacity of partitions pool */
char name[IDENTIFIER_LENGTH]; /* name of the logical partition */
u_longlong_t timebase_last; /* most recently cpu time base (an incremented long int on PowerPC) */
u_longlong_t pool_idle_time; /* pool idle time = number of clock tics a processor in the shared pool was idle */
u_longlong_t pcpu_tics_user; /* raw number of physical processor tics in user mode */
u_longlong_t pcpu_tics_sys; /* raw number of physical processor tics in system mode */
u_longlong_t pcpu_tics_idle; /* raw number of physical processor tics idle */
u_longlong_t pcpu_tics_wait; /* raw number of physical processor tics waiting for I/O */
u_longlong_t true_memory; /* True Memory Size in 4KB pages */
u_longlong_t expanded_memory; /* Expanded Memory Size in 4KB pages */
u_longlong_t target_memexp_factr; /* Target Memory Expansion Factor scaled by 100 */
u_longlong_t current_memexp_factr; /* Current Memory Expansion Factor scaled by 100 */
u_longlong_t cmcs_total_time; /* Total CPU time spent due to active memory expansion */
};
// Result struct for get_cpuinfo().
struct cpuinfo_t {
char description[IDENTIFIER_LENGTH]; // processor description (type/official name)
u_longlong_t processorHZ; // processor speed in Hz
int ncpus; // number of active logical processors
double loadavg[3]; // (1<<SBITS) times the average number of runnables processes during the last 1, 5 and 15 minutes.
// To calculate the load average, divide the numbers by (1<<SBITS). SBITS is defined in <sys/proc.h>.
char version[20]; // processor version from _system_configuration (sys/systemcfg.h)
unsigned long long user_clock_ticks; // raw total number of clock ticks spent in user mode
unsigned long long sys_clock_ticks; // raw total number of clock ticks spent in system mode
unsigned long long idle_clock_ticks; // raw total number of clock ticks spent idle
unsigned long long wait_clock_ticks; // raw total number of clock ticks spent waiting for I/O
};
// Result struct for get_wparinfo().
struct wparinfo_t {
char name[MAXCORRALNAMELEN+1]; /* name of the Workload Partition */
unsigned short wpar_id; /* workload partition identifier */
unsigned app_wpar :1; /* Application WPAR */
unsigned cpu_rset :1; /* WPAR restricted to CPU resource set */
unsigned cpu_xrset:1; /* WPAR restricted to CPU Exclusive resource set */
unsigned cpu_limits :1; /* CPU resource limits enforced */
unsigned mem_limits :1; /* Memory resource limits enforced */
int cpu_limit; /* CPU limit in 100ths of % - 1..10000 */
int mem_limit; /* Memory limit in 100ths of % - 1..10000 */
};
static bool get_partitioninfo(partitioninfo_t* ppi);
static bool get_cpuinfo(cpuinfo_t* pci);
static bool get_wparinfo(wparinfo_t* pwi);
};
#endif // OS_AIX_VM_LIBPERFSTAT_AIX_HPP

3
hotspot/src/os/aix/vm/loadlib_aix.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright 2012, 2013 SAP AG. All rights reserved.
* Copyright 2012, 2015 SAP AG. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -35,7 +35,6 @@
#endif
#include "loadlib_aix.hpp"
// for CritSect
#include "misc_aix.hpp"
#include "porting_aix.hpp"
#include "utilities/debug.hpp"

2
hotspot/src/os/aix/vm/misc_aix.cpp
View File

@ -26,6 +26,8 @@
#include "runtime/stubRoutines.hpp"
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
void MiscUtils::init_critsect(MiscUtils::critsect_t* cs) {
const int rc = pthread_mutex_init(cs, NULL);

3
hotspot/src/os/aix/vm/misc_aix.hpp
View File

@ -29,6 +29,8 @@
// misc_aix.hpp, misc_aix.cpp: convenience functions needed for the OpenJDK AIX
// port.
#include "utilities/globalDefinitions.hpp"
#include "runtime/globals.hpp"
#include "utilities/debug.hpp"
#include <pthread.h>
@ -40,7 +42,6 @@
} \
}
#define ERRBYE(s) { trcVerbose(s); return -1; }
#define trc(fmt, ...)
#define assert0(b) assert((b), "")
#define guarantee0(b) guarantee((b), "")

2
hotspot/src/os/aix/vm/osThread_aix.cpp
View File

@ -35,7 +35,7 @@
void OSThread::pd_initialize() {
assert(this != NULL, "check");
_thread_id = 0;
_pthread_id = 0;
_kernel_thread_id = 0;
_siginfo = NULL;
_ucontext = NULL;
_expanding_stack = 0;

25
hotspot/src/os/aix/vm/osThread_aix.hpp
View File

@ -27,7 +27,7 @@
#define OS_AIX_VM_OSTHREAD_AIX_HPP
public:
typedef pid_t thread_id_t;
typedef pthread_t thread_id_t;
private:
int _thread_type;
@ -43,9 +43,13 @@
private:
// _pthread_id is the pthread id, which is used by library calls
// (e.g. pthread_kill).
pthread_t _pthread_id;
// On AIX, we use the pthread id as OSThread::thread_id and keep the kernel thread id
// separately for diagnostic purposes.
//
// Note: this kernel thread id is saved at thread start. Depending on the
// AIX scheduling mode, this may not be the current thread id (usually not
// a problem though as we run with AIXTHREAD_SCOPE=S).
tid_t _kernel_thread_id;
sigset_t _caller_sigmask; // Caller's signal mask
@ -66,11 +70,16 @@
return false;
}
#endif // ASSERT
pthread_t pthread_id() const {
return _pthread_id;
tid_t kernel_thread_id() const {
return _kernel_thread_id;
}
void set_pthread_id(pthread_t tid) {
_pthread_id = tid;
void set_kernel_thread_id(tid_t tid) {
_kernel_thread_id = tid;
}
pthread_t pthread_id() const {
// Here: same as OSThread::thread_id()
return _thread_id;
}
// ***************************************************************

746
hotspot/src/os/aix/vm/os_aix.cpp
View File

File diff suppressed because it is too large Load Diff

69
hotspot/src/os/aix/vm/os_aix.hpp
View File

@ -34,9 +34,6 @@ static bool zero_page_read_protected() { return false; }
class Aix {
friend class os;
// Length of strings included in the libperfstat structures.
#define IDENTIFIER_LENGTH 64
static bool libjsig_is_loaded; // libjsig that interposes sigaction(),
// __sigaction(), signal() is loaded
static struct sigaction *(*get_signal_action)(int);
@ -45,13 +42,15 @@ class Aix {
static void check_signal_handler(int sig);
protected:
private:
static julong _physical_memory;
static pthread_t _main_thread;
static Mutex* _createThread_lock;
static int _page_size;
static int _logical_cpus;
// Page size of newly created pthreads.
static int _stack_page_size;
// -1 = uninitialized, 0 = AIX, 1 = OS/400 (PASE)
static int _on_pase;
@ -63,6 +62,9 @@ class Aix {
// for OS/400 e.g. 0x0504 for OS/400 V5R4
static int _os_version;
// 4 Byte kernel version: Version, Release, Tech Level, Service Pack.
static unsigned int _os_kernel_version;
// -1 = uninitialized,
// 0 - SPEC1170 not requested (XPG_SUS_ENV is OFF or not set)
// 1 - SPEC1170 requested (XPG_SUS_ENV is ON)
@ -73,35 +75,6 @@ class Aix {
// 1 - EXTSHM=ON
static int _extshm;
// page sizes on AIX.
//
// AIX supports four different page sizes - 4K, 64K, 16MB, 16GB. The latter two
// (16M "large" resp. 16G "huge" pages) require special setup and are normally
// not available.
//
// AIX supports multiple page sizes per process, for:
// - Stack (of the primordial thread, so not relevant for us)
// - Data - data, bss, heap, for us also pthread stacks
// - Text - text code
// - shared memory
//
// Default page sizes can be set via linker options (-bdatapsize, -bstacksize, ...)
// and via environment variable LDR_CNTRL (DATAPSIZE, STACKPSIZE, ...)
//
// For shared memory, page size can be set dynamically via shmctl(). Different shared memory
// regions can have different page sizes.
//
// More information can be found at AIBM info center:
// http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/multiple_page_size_app_support.htm
//
// -----
// We want to support 4K and 64K and, if the machine is set up correctly, 16MB pages.
//
// page size of the stack of newly created pthreads
// (should be LDR_CNTRL DATAPSIZE because stack is allocated on heap by pthread lib)
static int _stack_page_size;
static julong available_memory();
static julong physical_memory() { return _physical_memory; }
static void initialize_system_info();
@ -125,9 +98,6 @@ class Aix {
public:
static void init_thread_fpu_state();
static pthread_t main_thread(void) { return _main_thread; }
// returns kernel thread id (similar to LWP id on Solaris), which can be
// used to access /proc
static pid_t gettid();
static void set_createThread_lock(Mutex* lk) { _createThread_lock = lk; }
static Mutex* createThread_lock(void) { return _createThread_lock; }
static void hotspot_sigmask(Thread* thread);
@ -215,6 +185,14 @@ class Aix {
return _os_version;
}
// Get 4 byte AIX kernel version number:
// highest 2 bytes: Version, Release
// if available: lowest 2 bytes: Tech Level, Service Pack.
static unsigned int os_kernel_version() {
if (_os_kernel_version) return _os_kernel_version;
return os_version() << 16;
}
// Convenience method: returns true if running on PASE V5R4 or older.
static bool on_pase_V5R4_or_older() {
return on_pase() && os_version() <= 0x0504;
@ -257,27 +235,12 @@ class Aix {
};
// Result struct for get_cpuinfo().
struct cpuinfo_t {
char description[IDENTIFIER_LENGTH]; // processor description (type/official name)
u_longlong_t processorHZ; // processor speed in Hz
int ncpus; // number of active logical processors
double loadavg[3]; // (1<<SBITS) times the average number of runnables processes during the last 1, 5 and 15 minutes.
// To calculate the load average, divide the numbers by (1<<SBITS). SBITS is defined in <sys/proc.h>.
char version[20]; // processor version from _system_configuration (sys/systemcfg.h)
};
// Functions to retrieve memory information on AIX, PASE.
// (on AIX, using libperfstat, on PASE with libo4.so).
// Returns true if ok, false if error.
static bool get_meminfo(meminfo_t* pmi);
// Function to retrieve cpu information on AIX
// (on AIX, using libperfstat)
// Returns true if ok, false if error.
static bool get_cpuinfo(cpuinfo_t* pci);
}; // os::Aix class
};
class PlatformEvent : public CHeapObj<mtInternal> {

2
hotspot/src/os/aix/vm/os_aix.inline.hpp
View File

@ -60,6 +60,8 @@ inline bool os::allocate_stack_guard_pages() {
// On Aix, reservations are made on a page by page basis, nothing to do.
inline void os::pd_split_reserved_memory(char *base, size_t size,
size_t split, bool realloc) {
// TODO: Determine whether Sys V memory is split. If yes, we need to treat
// this the same way Windows treats its VirtualAlloc allocations.
}
// Bang the shadow pages if they need to be touched to be mapped.

6
hotspot/src/os_cpu/aix_ppc/vm/vmStructs_aix_ppc.hpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
* Copyright 2012, 2013 SAP AG. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@ -35,8 +35,7 @@
/******************************/ \
/* Threads (NOTE: incomplete) */ \
/******************************/ \
nonstatic_field(OSThread, _thread_id, pid_t) \
nonstatic_field(OSThread, _pthread_id, pthread_t)
nonstatic_field(OSThread, _thread_id, pthread_t) \
#define VM_TYPES_OS_CPU(declare_type, declare_toplevel_type, declare_oop_type, declare_integer_type, declare_unsigned_integer_type, declare_c1_toplevel_type, declare_c2_type, declare_c2_toplevel_type) \
@ -45,7 +44,6 @@
/* Posix Thread IDs */ \
/**********************/ \
\
declare_integer_type(pid_t) \
declare_unsigned_integer_type(pthread_t)
#define VM_INT_CONSTANTS_OS_CPU(declare_constant, declare_preprocessor_constant, declare_c1_constant, declare_c2_constant, declare_c2_preprocessor_constant)