archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-09-18 18:14:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8189922: UseNUMA memory interleaving vs membind

Browse source 
Reviewed-by: gromero, drwhite, dholmes, tschatzl
This commit is contained in:
Swati Sharma 2018-07-19 16:56:05 -04:00 • committed by Gustavo Romero
parent 39cd4bdd52
commit 0440d172a0
2 changed files with 61 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

31
src/hotspot/os/linux/os_linux.cpp
View file

@ -2841,9 +2841,10 @@ size_t os::numa_get_leaf_groups(int *ids, size_t size) {
// Map all node ids in which it is possible to allocate memory. Also nodes are
// not always consecutively available, i.e. available from 0 to the highest
// node number.
// node number. If the nodes have been bound explicitly using numactl membind,
// then allocate memory from those nodes only.
for (int node = 0; node <= highest_node_number; node++) {
if (Linux::isnode_in_configured_nodes((unsigned int)node)) {
if (Linux::isnode_in_bound_nodes((unsigned int)node)) {
ids[i++] = node;
}
}
@ -2944,6 +2945,8 @@ bool os::Linux::libnuma_init() {
libnuma_dlsym(handle, "numa_bitmask_isbitset")));
set_numa_distance(CAST_TO_FN_PTR(numa_distance_func_t,
libnuma_dlsym(handle, "numa_distance")));
set_numa_get_membind(CAST_TO_FN_PTR(numa_get_membind_func_t,
libnuma_v2_dlsym(handle, "numa_get_membind")));
if (numa_available() != -1) {
set_numa_all_nodes((unsigned long*)libnuma_dlsym(handle, "numa_all_nodes"));
@ -3008,17 +3011,23 @@ void os::Linux::rebuild_cpu_to_node_map() {
unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size, mtInternal);
for (size_t i = 0; i < node_num; i++) {
// Check if node is configured (not a memory-less node). If it is not, find
// the closest configured node.
if (!isnode_in_configured_nodes(nindex_to_node()->at(i))) {
// the closest configured node. Check also if node is bound, i.e. it's allowed
// to allocate memory from the node. If it's not allowed, map cpus in that node
// to the closest node from which memory allocation is allowed.
if (!isnode_in_configured_nodes(nindex_to_node()->at(i)) ||
!isnode_in_bound_nodes(nindex_to_node()->at(i))) {
closest_distance = INT_MAX;
// Check distance from all remaining nodes in the system. Ignore distance
// from itself and from another non-configured node.
// from itself, from another non-configured node, and from another non-bound
// node.
for (size_t m = 0; m < node_num; m++) {
if (m != i && isnode_in_configured_nodes(nindex_to_node()->at(m))) {
if (m != i &&
isnode_in_configured_nodes(nindex_to_node()->at(m)) &&
isnode_in_bound_nodes(nindex_to_node()->at(m))) {
distance = numa_distance(nindex_to_node()->at(i), nindex_to_node()->at(m));
// If a closest node is found, update. There is always at least one
// configured node in the system so there is always at least one node
// close.
// configured and bound node in the system so there is always at least
// one node close.
if (distance != 0 && distance < closest_distance) {
closest_distance = distance;
closest_node = nindex_to_node()->at(m);
@ -3068,6 +3077,7 @@ os::Linux::numa_interleave_memory_v2_func_t os::Linux::_numa_interleave_memory_v
os::Linux::numa_set_bind_policy_func_t os::Linux::_numa_set_bind_policy;
os::Linux::numa_bitmask_isbitset_func_t os::Linux::_numa_bitmask_isbitset;
os::Linux::numa_distance_func_t os::Linux::_numa_distance;
os::Linux::numa_get_membind_func_t os::Linux::_numa_get_membind;
unsigned long* os::Linux::_numa_all_nodes;
struct bitmask* os::Linux::_numa_all_nodes_ptr;
struct bitmask* os::Linux::_numa_nodes_ptr;
@ -5049,8 +5059,9 @@ jint os::init_2(void) {
if (!Linux::libnuma_init()) {
UseNUMA = false;
} else {
if ((Linux::numa_max_node() < 1)) {
// There's only one node(they start from 0), disable NUMA.
if ((Linux::numa_max_node() < 1) || Linux::isbound_to_single_node()) {
// If there's only one node (they start from 0) or if the process
// is bound explicitly to a single node using membind, disable NUMA.
UseNUMA = false;
}
}

42
src/hotspot/os/linux/os_linux.hpp
View file

@ -228,6 +228,7 @@ class Linux {
typedef int (*numa_tonode_memory_func_t)(void *start, size_t size, int node);
typedef void (*numa_interleave_memory_func_t)(void *start, size_t size, unsigned long *nodemask);
typedef void (*numa_interleave_memory_v2_func_t)(void *start, size_t size, struct bitmask* mask);
typedef struct bitmask* (*numa_get_membind_func_t)(void);
typedef void (*numa_set_bind_policy_func_t)(int policy);
typedef int (*numa_bitmask_isbitset_func_t)(struct bitmask *bmp, unsigned int n);
@ -244,6 +245,7 @@ class Linux {
static numa_set_bind_policy_func_t _numa_set_bind_policy;
static numa_bitmask_isbitset_func_t _numa_bitmask_isbitset;
static numa_distance_func_t _numa_distance;
static numa_get_membind_func_t _numa_get_membind;
static unsigned long* _numa_all_nodes;
static struct bitmask* _numa_all_nodes_ptr;
static struct bitmask* _numa_nodes_ptr;
@ -259,6 +261,7 @@ class Linux {
static void set_numa_set_bind_policy(numa_set_bind_policy_func_t func) { _numa_set_bind_policy = func; }
static void set_numa_bitmask_isbitset(numa_bitmask_isbitset_func_t func) { _numa_bitmask_isbitset = func; }
static void set_numa_distance(numa_distance_func_t func) { _numa_distance = func; }
static void set_numa_get_membind(numa_get_membind_func_t func) { _numa_get_membind = func; }
static void set_numa_all_nodes(unsigned long* ptr) { _numa_all_nodes = ptr; }
static void set_numa_all_nodes_ptr(struct bitmask **ptr) { _numa_all_nodes_ptr = (ptr == NULL ? NULL : *ptr); }
static void set_numa_nodes_ptr(struct bitmask **ptr) { _numa_nodes_ptr = (ptr == NULL ? NULL : *ptr); }
@ -299,7 +302,7 @@ class Linux {
if (_numa_bitmask_isbitset != NULL && _numa_all_nodes_ptr != NULL) {
return _numa_bitmask_isbitset(_numa_all_nodes_ptr, n);
} else
return 0;
return false;
}
// Check if numa node exists in the system (including zero memory nodes).
static bool isnode_in_existing_nodes(unsigned int n) {
@ -318,7 +321,42 @@ class Linux {
// substitute.
return _numa_bitmask_isbitset(_numa_all_nodes_ptr, n);
} else
return 0;
return false;
}
// Check if node is in bound node set.
static bool isnode_in_bound_nodes(int node) {
if (_numa_get_membind != NULL && _numa_bitmask_isbitset != NULL) {
return _numa_bitmask_isbitset(_numa_get_membind(), node);
} else {
return false;
}
}
// Check if bound to only one numa node.
// Returns true if bound to a single numa node, otherwise returns false.
static bool isbound_to_single_node() {
int nodes = 0;
struct bitmask* bmp = NULL;
unsigned int node = 0;
unsigned int highest_node_number = 0;
if (_numa_get_membind != NULL && _numa_max_node != NULL && _numa_bitmask_isbitset != NULL) {
bmp = _numa_get_membind();
highest_node_number = _numa_max_node();
} else {
return false;
}
for (node = 0; node <= highest_node_number; node++) {
if (_numa_bitmask_isbitset(bmp, node)) {
nodes++;
}
}
if (nodes == 1) {
return true;
} else {
return false;
}
}
};