Skip to content

GitLab

Commit 6501432e authored by Hisham Muhammad's avatar Hisham Muhammad
Browse files

upgrade PLPA to 1.3.2

parent 8d0fff2f
Hide whitespace changes
Inline Side-by-side
plpa-1.1/src/plpa_map.c → plpa-1.3.2/src/libplpa/plpa_map.c
View file @ 6501432e
/* /*
* Copyright (c) 2007 Cisco Systems, Inc. All rights reserved. * Copyright (c) 2007-2008 Cisco Systems, Inc. All rights reserved.
* *
* Portions of this file originally contributed by Advanced Micro * Portions of this file originally contributed by Advanced Micro
* Devices, Inc. See notice below. * Devices, Inc. See notice below.
...@@ -36,13 +36,6 @@ ...@@ -36,13 +36,6 @@
Devices, Inc. Devices, Inc.
and any copyright holders and contributors. and any copyright holders and contributors.
+ In no event shall anyone redistributing or accessing or using this
material commence or participate in any arbitration or legal action
relating to this material against Advanced Micro Devices, Inc. or any
copyright holders or contributors. The foregoing shall survive any
expiration or termination of this license or any agreement or access
or use related to this material.
+ ANY BREACH OF ANY TERM OF THIS LICENSE SHALL RESULT IN THE IMMEDIATE + ANY BREACH OF ANY TERM OF THIS LICENSE SHALL RESULT IN THE IMMEDIATE
REVOCATION OF ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE THIS MATERIAL. REVOCATION OF ALL RIGHTS TO REDISTRIBUTE, ACCESS OR USE THIS MATERIAL.
...@@ -122,24 +115,28 @@ ...@@ -122,24 +115,28 @@
#include <fcntl.h> #include <fcntl.h>
#include <unistd.h> #include <unistd.h>
#include <stdio.h> #include <stdio.h>
#include <dirent.h>
#include <limits.h> #include <limits.h>
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdbool.h>
typedef struct tuple_t_ { typedef struct tuple_t_ {
int processor_id, socket, core; int processor_id, socket_id, core_id, online;
} tuple_t; } tuple_t;
static const char *sysfs_mount = "/sys";
static int supported = 0; static int supported = 0;
static int num_processors = -1; static int num_processors = -1;
static int max_processor_num = -1; static int max_processor_id = -1;
static int num_sockets = -1; static int num_sockets = -1;
static int max_socket_id = -1; static int max_socket_id = -1;
static int *max_core_id = NULL; static int *max_core_id = NULL;
static int *num_cores = NULL; static int *num_cores = NULL;
static int max_core_id_overall = -1; static int max_core_id_overall = -1;
static tuple_t *map_processor_id_to_tuple = NULL; static tuple_t *map_processor_id_to_tuple = NULL;
static tuple_t ***map_tuple_to_processor_id = NULL; static tuple_t **map_tuple_to_processor_id = NULL;
static PLPA_NAME(cache_behavior_t) cache_behavior = PLPA_NAME_CAPS(CACHE_IGNORE);
static void clear_cache(void) static void clear_cache(void)
{ {
...@@ -156,25 +153,31 @@ static void clear_cache(void) ...@@ -156,25 +153,31 @@ static void clear_cache(void)
map_processor_id_to_tuple = NULL; map_processor_id_to_tuple = NULL;
} }
if (NULL != map_tuple_to_processor_id) { if (NULL != map_tuple_to_processor_id) {
if (NULL != map_tuple_to_processor_id[0]) {
free(map_tuple_to_processor_id[0]);
map_tuple_to_processor_id = NULL;
}
free(map_tuple_to_processor_id); free(map_tuple_to_processor_id);
map_tuple_to_processor_id = NULL; map_tuple_to_processor_id = NULL;
} }
num_processors = max_processor_num = -1; num_processors = max_processor_id = -1;
num_sockets = max_socket_id = -1; num_sockets = max_socket_id = -1;
max_core_id_overall = -1; max_core_id_overall = -1;
} }
static void load_cache(const char *sysfs_mount) static void load_cache(void)
{ {
int i, j, k, invalid_entry, fd; int i, j, k, invalid_entry, fd, found_online;
char path[PATH_MAX], buf[8]; char path[PATH_MAX], buf[8];
PLPA_NAME(cpu_set_t) valid_processors;
PLPA_NAME(cpu_set_t) *cores_on_sockets; PLPA_NAME(cpu_set_t) *cores_on_sockets;
int found; int found;
DIR *dir;
struct dirent dentry, *dentryp = NULL;
#if PLPA_DEBUG
char *temp = getenv("PLPA_SYSFS_MOUNT");
if (temp) {
sysfs_mount = temp;
}
#endif
/* Check for the parent directory */ /* Check for the parent directory */
sprintf(path, "%s/devices/system/cpu", sysfs_mount); sprintf(path, "%s/devices/system/cpu", sysfs_mount);
...@@ -182,17 +185,42 @@ static void load_cache(const char *sysfs_mount) ...@@ -182,17 +185,42 @@ static void load_cache(const char *sysfs_mount)
return; return;
} }
/* Go through and find the max processor ID */ dir = opendir(path);
for (num_processors = max_processor_num = i = 0; if (NULL == dir) {
i < PLPA_BITMASK_CPU_MAX; ++i) { return;
sprintf(path, "%s/devices/system/cpu/cpu%d", sysfs_mount, i);
if (0 != access(path, (R_OK | X_OK))) {
max_processor_num = i - 1;
break;
}
++num_processors;
} }
/* Catch all entries of format "cpu%d", count them and maintain
max_processor_id */
num_processors = 0;
PLPA_CPU_ZERO(&valid_processors);
do {
int ret = readdir_r(dir, &dentry, &dentryp);
if (0 != ret) {
closedir(dir);
clear_cache();
return;
}
if (dentryp) {
int cpuid;
ret = sscanf(dentryp->d_name, "cpu%d", &cpuid);
if (1 == ret) {
++num_processors;
if (cpuid >= PLPA_BITMASK_CPU_MAX) {
closedir(dir);
clear_cache();
return;
} else if (cpuid > max_processor_id) {
max_processor_id = cpuid;
}
PLPA_CPU_SET(cpuid, &valid_processors);
}
}
} while (NULL != dentryp);
closedir(dir);
/* If we found no processors, then we have no topology info */ /* If we found no processors, then we have no topology info */
if (0 == num_processors) { if (0 == num_processors) {
clear_cache(); clear_cache();
...@@ -202,55 +230,115 @@ static void load_cache(const char *sysfs_mount) ...@@ -202,55 +230,115 @@ static void load_cache(const char *sysfs_mount)
/* Malloc space for the first map (processor ID -> tuple). /* Malloc space for the first map (processor ID -> tuple).
Include enough space for one invalid entry. */ Include enough space for one invalid entry. */
map_processor_id_to_tuple = malloc(sizeof(tuple_t) * map_processor_id_to_tuple = malloc(sizeof(tuple_t) *
(max_processor_num + 2)); (max_processor_id + 2));
if (NULL == map_processor_id_to_tuple) { if (NULL == map_processor_id_to_tuple) {
clear_cache();
return; return;
} }
for (i = 0; i <= max_processor_num; ++i) { for (i = 0; i <= max_processor_id; ++i) {
map_processor_id_to_tuple[i].processor_id = i; if (PLPA_CPU_ISSET(i, &valid_processors)) {
map_processor_id_to_tuple[i].socket = -1; map_processor_id_to_tuple[i].processor_id = i;
map_processor_id_to_tuple[i].core = -1; } else {
map_processor_id_to_tuple[i].processor_id = -1;
}
map_processor_id_to_tuple[i].socket_id = -1;
map_processor_id_to_tuple[i].core_id = -1;
} }
/* Set the invalid entry */ /* Set the invalid entry */
invalid_entry = i; invalid_entry = i;
map_processor_id_to_tuple[invalid_entry].processor_id = -1; map_processor_id_to_tuple[invalid_entry].processor_id = -1;
map_processor_id_to_tuple[invalid_entry].socket = -1; map_processor_id_to_tuple[invalid_entry].socket_id = -1;
map_processor_id_to_tuple[invalid_entry].core = -1; map_processor_id_to_tuple[invalid_entry].core_id = -1;
/* Build a cached map of (socket,core) tuples */ /* Build a cached map of (socket,core) tuples */
for (found = 0, i = 0; i <= max_processor_num; ++i) { for (found = 0, i = 0; i <= max_processor_id; ++i) {
sprintf(path, "%s/devices/system/cpu/cpu%d/topology/core_id",
/* Check for invalid processor ID */
if (map_processor_id_to_tuple[i].processor_id < 0) {
continue;
}
/* Read the "online" state for this processor. If the online
file is not there, then the kernel likely doesn't have
hotplug support so just assume that it's online. Some notes:
- the perms on the "online" file are root/600, so only root
will see this info
- if online is 0, then all the topology files disappear (!)
-- so PLPA needs to compensate for that
*/
found_online = 0;
sprintf(path, "%s/devices/system/cpu/cpu%d/online",
sysfs_mount, i); sysfs_mount, i);
fd = open(path, O_RDONLY); fd = open(path, O_RDONLY);
if ( fd < 0 ) { memset(buf, 0, sizeof(buf));
continue; if (fd >= 0 && read(fd, buf, sizeof(buf) - 1) > 0) {
found_online = 1;
sscanf(buf, "%d", &(map_processor_id_to_tuple[i].online));
} else {
map_processor_id_to_tuple[i].online = 1;
} }
if ( read(fd, buf, 7) <= 0 ) { if (fd >= 0) {
continue; close(fd);
} }
sscanf(buf, "%d", &(map_processor_id_to_tuple[i].core));
close(fd); /* Core ID */
sprintf(path, "%s/devices/system/cpu/cpu%d/topology/core_id",
sysfs_mount, i);
fd = open(path, O_RDONLY);
if (fd >= 0) {
memset(buf, 0, sizeof(buf));
if (read(fd, buf, sizeof(buf) - 1) > 0) {
sscanf(buf, "%d", &(map_processor_id_to_tuple[i].core_id));
} else {
map_processor_id_to_tuple[i].core_id = -1;
}
close(fd);
}
/* Special case: we didn't find the core_id file, but we *did*
find the online file and the processor is offline -- then
just mark the core ID as "unknown" and keep going (because
if a processor is offline, the core_id file won't exist --
grumble) */
else if (found_online && 0 == map_processor_id_to_tuple[i].online) {
map_processor_id_to_tuple[i].core_id = -1;
}
/* Socket ID */
sprintf(path, sprintf(path,
"%s/devices/system/cpu/cpu%d/topology/physical_package_id", "%s/devices/system/cpu/cpu%d/topology/physical_package_id",
sysfs_mount, i); sysfs_mount, i);
fd = open(path, O_RDONLY); fd = open(path, O_RDONLY);
if ( fd < 0 ) { if (fd >= 0) {
continue; memset(buf, 0, sizeof(buf));
if (read(fd, buf, sizeof(buf) - 1) > 0) {
sscanf(buf, "%d", &(map_processor_id_to_tuple[i].socket_id));
}
close(fd);
found = 1;
} }
if ( read(fd, buf, 7) <= 0 ) { /* Special case: we didn't find the socket_id file, but we
continue; *did* find the online file and the processor is offline --
then just mark the socket ID as "unknown" and keep going
(because if a processor is offline, the socket_id file won't
exist -- grumble) */
else if (found_online && 0 == map_processor_id_to_tuple[i].online) {
map_processor_id_to_tuple[i].socket_id = -1;
} }
sscanf(buf, "%d", &(map_processor_id_to_tuple[i].socket));
close(fd);
found = 1;
/* Keep a running tab on the max socket number */ /* Keep a running tab on the max socket number */
if (map_processor_id_to_tuple[i].socket > max_socket_id) { if (map_processor_id_to_tuple[i].socket_id > max_socket_id) {
max_socket_id = map_processor_id_to_tuple[i].socket; max_socket_id = map_processor_id_to_tuple[i].socket_id;
} }
} }
/* If we didn't find any core_id/physical_package_id's, then we
don't have the topology info */
if (!found) {
clear_cache();
return;
}
/* Now that we know the max number of sockets, allocate some /* Now that we know the max number of sockets, allocate some
arrays */ arrays */
max_core_id = malloc(sizeof(int) * (max_socket_id + 1)); max_core_id = malloc(sizeof(int) * (max_socket_id + 1));
...@@ -269,26 +357,23 @@ static void load_cache(const char *sysfs_mount) ...@@ -269,26 +357,23 @@ static void load_cache(const char *sysfs_mount)
} }
/* Find the max core number on each socket */ /* Find the max core number on each socket */
for (i = 0; i <= max_processor_num; ++i) { for (i = 0; i <= max_processor_id; ++i) {
if (map_processor_id_to_tuple[i].core > if (map_processor_id_to_tuple[i].processor_id < 0 ||
max_core_id[map_processor_id_to_tuple[i].socket]) { map_processor_id_to_tuple[i].socket_id < 0) {
max_core_id[map_processor_id_to_tuple[i].socket] = continue;
map_processor_id_to_tuple[i].core;
} }
if (max_core_id[map_processor_id_to_tuple[i].socket] > if (map_processor_id_to_tuple[i].core_id >
max_core_id[map_processor_id_to_tuple[i].socket_id]) {
max_core_id[map_processor_id_to_tuple[i].socket_id] =
map_processor_id_to_tuple[i].core_id;
}
if (max_core_id[map_processor_id_to_tuple[i].socket_id] >
max_core_id_overall) { max_core_id_overall) {
max_core_id_overall = max_core_id_overall =
max_core_id[map_processor_id_to_tuple[i].socket]; max_core_id[map_processor_id_to_tuple[i].socket_id];
} }
} }
/* If we didn't find any core_id/physical_package_id's, then we
don't have the topology info */
if (!found) {
clear_cache();
return;
}
/* Go through and count the number of unique sockets found. It /* Go through and count the number of unique sockets found. It
may not be the same as max_socket_id because there may be may not be the same as max_socket_id because there may be
"holes" -- e.g., sockets 0 and 3 are used, but sockets 1 and 2 "holes" -- e.g., sockets 0 and 3 are used, but sockets 1 and 2
...@@ -315,15 +400,15 @@ static void load_cache(const char *sysfs_mount) ...@@ -315,15 +400,15 @@ static void load_cache(const char *sysfs_mount)
for (i = 0; i <= max_socket_id; ++i) { for (i = 0; i <= max_socket_id; ++i) {
PLPA_CPU_ZERO(&(cores_on_sockets[i])); PLPA_CPU_ZERO(&(cores_on_sockets[i]));
} }
for (i = 0; i <= max_processor_num; ++i) { for (i = 0; i <= max_processor_id; ++i) {
if (map_processor_id_to_tuple[i].socket >= 0) { if (map_processor_id_to_tuple[i].socket_id >= 0) {
PLPA_CPU_SET(map_processor_id_to_tuple[i].core, PLPA_CPU_SET(map_processor_id_to_tuple[i].core_id,
&(cores_on_sockets[map_processor_id_to_tuple[i].socket])); &(cores_on_sockets[map_processor_id_to_tuple[i].socket_id]));
} }
} }
for (i = 0; i <= max_socket_id; ++i) { for (i = 0; i <= max_socket_id; ++i) {
int count = 0; int count = 0;
for (j = 0; j < PLPA_BITMASK_CPU_MAX; ++j) { for (j = 0; j <= max_core_id[i]; ++j) {
if (PLPA_CPU_ISSET(j, &(cores_on_sockets[i]))) { if (PLPA_CPU_ISSET(j, &(cores_on_sockets[i]))) {
++count; ++count;
} }
...@@ -332,49 +417,41 @@ static void load_cache(const char *sysfs_mount) ...@@ -332,49 +417,41 @@ static void load_cache(const char *sysfs_mount)
num_cores[i] = count; num_cores[i] = count;
} }
} }
free(cores_on_sockets);
/* Now go through and build the map in the other direction: /* Now go through and build the map in the other direction:
(socket,core) => processor_id. This map simply points to (socket,core) => processor_id. This map simply points to
entries in the other map (i.e., it's by reference instead of by entries in the other map (i.e., it's by reference instead of by
value). */ value). */
map_tuple_to_processor_id = malloc(sizeof(tuple_t **) * map_tuple_to_processor_id = malloc(sizeof(tuple_t *) *
(max_socket_id + 1)); ((max_socket_id + 1) *
(max_core_id_overall + 1)));
if (NULL == map_tuple_to_processor_id) { if (NULL == map_tuple_to_processor_id) {
clear_cache(); clear_cache();
return; return;
} }
map_tuple_to_processor_id[0] = malloc(sizeof(tuple_t *) *
((max_socket_id + 1) *
(max_core_id_overall + 1)));
if (NULL == map_tuple_to_processor_id[0]) {
clear_cache();
return;
}
/* Set pointers for 2nd dimension */
for (i = 1; i <= max_socket_id; ++i) {
map_tuple_to_processor_id[i] =
map_tuple_to_processor_id[i - 1] + max_core_id_overall + 1;
}
/* Compute map */ /* Compute map */
for (i = 0; i <= max_socket_id; ++i) { for (i = 0; i <= max_socket_id; ++i) {
for (j = 0; j <= max_core_id_overall; ++j) { for (j = 0; j <= max_core_id_overall; ++j) {
tuple_t **tuple_ptr = &map_tuple_to_processor_id[
i * (max_core_id_overall + 1) + j];
/* Default to the invalid entry in the other map, meaning /* Default to the invalid entry in the other map, meaning
that this (socket,core) combination doesn't exist that this (socket,core) combination doesn't exist
(e.g., the core number does not exist in this socket, (e.g., the core number does not exist in this socket,
although it does exist in other sockets). */ although it does exist in other sockets). */
map_tuple_to_processor_id[i][j] = *tuple_ptr = &map_processor_id_to_tuple[invalid_entry];
&map_processor_id_to_tuple[invalid_entry];
/* See if this (socket,core) tuple exists in the other /* See if this (socket,core) tuple exists in the other
map. If so, set this entry to point to it (overriding map. If so, set this entry to point to it (overriding
the invalid entry default). */ the invalid entry default). */
for (k = 0; k <= max_processor_num; ++k) { for (k = 0; k <= max_processor_id; ++k) {
if (map_processor_id_to_tuple[k].socket == i && if (map_processor_id_to_tuple[k].socket_id == i &&
map_processor_id_to_tuple[k].core == j) { map_processor_id_to_tuple[k].core_id == j) {
map_tuple_to_processor_id[i][j] = *tuple_ptr = &map_processor_id_to_tuple[k];
&map_processor_id_to_tuple[k];
#if defined(PLPA_DEBUG) && PLPA_DEBUG #if defined(PLPA_DEBUG) && PLPA_DEBUG
printf("Creating map: (socket %d, core %d) -> ID %d\n", printf("Creating map [%d]: (socket %d, core %d) -> ID %d\n",
i * (max_core_id_overall + 1) + j,
i, j, k); i, j, k);
#endif #endif
break; break;
...@@ -386,31 +463,27 @@ static void load_cache(const char *sysfs_mount) ...@@ -386,31 +463,27 @@ static void load_cache(const char *sysfs_mount)
supported = 1; supported = 1;
} }
/* Internal function to setup the mapping data. Guaranteed to be static int cache_action(void)
calling during PLPA_NAME(init), so we don't have to worry about
thread safety here. */
int PLPA_NAME(map_init)(void)
{ {
const char *sysfs_mount = "/sys"; switch (cache_behavior) {
char *temp; case PLPA_NAME_CAPS(CACHE_USE):
if (NULL == map_processor_id_to_tuple) {
load_cache();
}
break;
temp = getenv("PLPA_SYSFS_MOUNT"); case PLPA_NAME_CAPS(CACHE_IGNORE):
if (temp) { clear_cache();
sysfs_mount = temp; load_cache();
break;
default:
return EINVAL;
} }
load_cache(sysfs_mount);
return 0; return 0;
} }
/* Internal function to cleanup allocated memory. Only called by one
thread (during PLPA_NAME(finalize), so don't need to worry about
thread safety here. */
void PLPA_NAME(map_finalize)(void)
{
clear_cache();
}
/* Return whether this kernel supports topology information or not */ /* Return whether this kernel supports topology information or not */
int PLPA_NAME(have_topology_information)(int *supported_arg) int PLPA_NAME(have_topology_information)(int *supported_arg)
{ {
...@@ -432,7 +505,8 @@ int PLPA_NAME(have_topology_information)(int *supported_arg) ...@@ -432,7 +505,8 @@ int PLPA_NAME(have_topology_information)(int *supported_arg)
return 0; return 0;
} }
int PLPA_NAME(map_to_processor_id)(int socket, int core, int *processor_id) int PLPA_NAME(map_to_processor_id)(int socket_id, int core_id,
int *processor_id)
{ {
int ret; int ret;
...@@ -443,25 +517,31 @@ int PLPA_NAME(map_to_processor_id)(int socket, int core, int *processor_id) ...@@ -443,25 +517,31 @@ int PLPA_NAME(map_to_processor_id)(int socket, int core, int *processor_id)
} }
} }
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check for bozo arguments */ /* Check for bozo arguments */
if (NULL == processor_id) { if (NULL == processor_id) {
return EINVAL; return EINVAL;
} }
/* If this system doesn't support mapping, sorry Charlie */ /* Check cache behavior */
if (!supported) { if (0 != (ret = cache_action())) {
return ENOSYS; return ret;
} }
/* Check for some invalid entries */ /* Check for some invalid entries */
if (socket < 0 || socket > max_socket_id || if (socket_id < 0 || socket_id > max_socket_id ||
core < 0 || core > max_core_id_overall) { core_id < 0 || core_id > max_core_id[socket_id]) {
return ENOENT; return ENOENT;
} }
/* If the mapping returns -1, then this is a non-existent /* If the mapping returns -1, then this is a non-existent
socket/core combo (even though they fall within the max socket socket/core combo (even though they fall within the max socket
/ max core overall values) */ / max core overall values) */
ret = map_tuple_to_processor_id[socket][core]->processor_id; ret = map_tuple_to_processor_id[socket_id * (max_core_id_overall + 1) +
core_id]->processor_id;
if (-1 == ret) { if (-1 == ret) {
return ENOENT; return ENOENT;
} }
...@@ -471,7 +551,8 @@ int PLPA_NAME(map_to_processor_id)(int socket, int core, int *processor_id) ...@@ -471,7 +551,8 @@ int PLPA_NAME(map_to_processor_id)(int socket, int core, int *processor_id)
return 0; return 0;
} }
int PLPA_NAME(map_to_socket_core)(int processor_id, int *socket, int *core) int PLPA_NAME(map_to_socket_core)(int processor_id,
int *socket_id, int *core_id)
{ {
int ret; int ret;
...@@ -482,35 +563,52 @@ int PLPA_NAME(map_to_socket_core)(int processor_id, int *socket, int *core) ...@@ -482,35 +563,52 @@ int PLPA_NAME(map_to_socket_core)(int processor_id, int *socket, int *core)
} }
} }
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check for bozo arguments */ /* Check for bozo arguments */
if (NULL == socket || NULL == core) { if (NULL == socket_id || NULL == core_id) {
return EINVAL; return EINVAL;
} }
/* If this system doesn't support mapping, sorry Charlie */ /* Check cache behavior */
if (!supported) { if (0 != (ret = cache_action())) {
return ENOSYS; return ret;
} }
/* Check for some invalid entries */ /* Check for some invalid entries */
if (processor_id < 0 || processor_id > max_processor_num) { if (processor_id < 0 || processor_id > max_processor_id ||
map_processor_id_to_tuple[processor_id].processor_id < 0) {
return ENOENT; return ENOENT;
} }
ret = map_processor_id_to_tuple[processor_id].socket; ret = map_processor_id_to_tuple[processor_id].socket_id;
if (-1 == ret) { if (-1 == ret) {
return ENOENT; return ENOENT;
} }
/* Ok, all should be good -- return the mapping */ /* Ok, all should be good -- return the mapping */
*socket = ret; *socket_id = ret;
*core = map_processor_id_to_tuple[processor_id].core; *core_id = map_processor_id_to_tuple[processor_id].core_id;
return 0; return 0;
} }
/* Deprecated function */
int PLPA_NAME(get_processor_info)(int *num_processors_arg, int PLPA_NAME(get_processor_info)(int *num_processors_arg,
int *max_processor_num_arg) int *max_processor_id_arg)
{ {
int ret; return PLPA_NAME(get_processor_data)(PLPA_NAME_CAPS(COUNT_ALL),
num_processors_arg,
max_processor_id_arg);
}
int PLPA_NAME(get_processor_data)(PLPA_NAME(count_specification_t) count_spec,
int *num_processors_arg,
int *max_processor_id_arg)
{
int i, ret;
bool match;
/* Initialize if not already done so */ /* Initialize if not already done so */
if (!PLPA_NAME(initialized)) { if (!PLPA_NAME(initialized)) {
...@@ -519,19 +617,180 @@ int PLPA_NAME(get_processor_info)(int *num_processors_arg, ...@@ -519,19 +617,180 @@ int PLPA_NAME(get_processor_info)(int *num_processors_arg,
} }
} }
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check cache behavior */
if (0 != (ret = cache_action())) {
return ret;
}
/* Check for bozo arguments */ /* Check for bozo arguments */
if (NULL == max_processor_num_arg || NULL == num_processors_arg) { if (NULL == max_processor_id_arg || NULL == num_processors_arg) {
return EINVAL; return EINVAL;
} }
/* If we wanted all processors, we're done */
if (PLPA_NAME_CAPS(COUNT_ALL) == count_spec) {
*num_processors_arg = num_processors;
*max_processor_id_arg = max_processor_id;
} else {
/* Otherwise, count the appropriate type */
*num_processors_arg = 0;
*max_processor_id_arg = 0;
for (i = 0; i <= max_processor_id; ++i) {
if (map_processor_id_to_tuple[i].processor_id >= 0) {
match = false;
switch (count_spec) {
case PLPA_NAME_CAPS(COUNT_ONLINE):
if (map_processor_id_to_tuple[i].online) {
match = true;
}
break;
case PLPA_NAME_CAPS(COUNT_OFFLINE):
if (!map_processor_id_to_tuple[i].online) {
match = true;
}
break;
default:
/* Just so that compilers don't complain */
break;
}
if (match) {
++(*num_processors_arg);
if (*max_processor_id_arg <
map_processor_id_to_tuple[i].processor_id) {
*max_processor_id_arg =
map_processor_id_to_tuple[i].processor_id;
}
}
}
}
}
return 0;
}
/* Returns the Linux processor ID for the Nth processor (starting with
0). */
int PLPA_NAME(get_processor_id)(int processor_num,
PLPA_NAME(count_specification_t) count_spec,
int *processor_id)
{
int ret, i, count;
bool match;
/* Initialize if not already done so */
if (!PLPA_NAME(initialized)) {
if (0 != (ret = PLPA_NAME(init)())) {
return ret;
}
}
/* If this system doesn't support mapping, sorry Charlie */ /* If this system doesn't support mapping, sorry Charlie */
if (!supported) { if (!supported) {
return ENOSYS; return ENOSYS;
} }
/* All done */ /* Check for bozo arguments */
*num_processors_arg = num_processors; if (NULL == processor_id) {
*max_processor_num_arg = max_processor_num; return EINVAL;
}
/* Check cache behavior */
if (0 != (ret = cache_action())) {
return ret;
}
/* Check for out of range params */
if (processor_num < 0 || processor_num > num_processors) {
return EINVAL;
}
/* Find the processor_num'th processor */
for (count = i = 0; i <= max_processor_id; ++i) {
if (map_processor_id_to_tuple[i].processor_id >= 0) {
match = false;
switch (count_spec) {
case PLPA_NAME_CAPS(COUNT_ONLINE):
if (map_processor_id_to_tuple[i].online) {
match = true;
}
break;
case PLPA_NAME_CAPS(COUNT_OFFLINE):
if (!map_processor_id_to_tuple[i].online) {
match = true;
}
break;
case PLPA_NAME_CAPS(COUNT_ALL):
match = true;
break;
}
if (match) {
if (count++ == processor_num) {
*processor_id = map_processor_id_to_tuple[i].processor_id;
return 0;
}
}
}
}
/* Didn't find it */
return ENODEV;
}
/* Check to see if a given Linux processor ID exists / is online.
Returns 0 on success. */
int PLPA_NAME(get_processor_flags)(int processor_id,
int *exists_arg, int *online_arg)
{
int ret, exists, online;
/* Initialize if not already done so */
if (!PLPA_NAME(initialized)) {
if (0 != (ret = PLPA_NAME(init)())) {
return ret;
}
}
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check for bozo arguments */
if (NULL == exists_arg && NULL == online_arg) {
return EINVAL;
}
/* Check cache behavior */
if (0 != (ret = cache_action())) {
return ret;
}
/* Check for out of range params */
if (processor_id < 0 || processor_id > max_processor_id) {
return EINVAL;
}
exists = online = 0;
if (processor_id == map_processor_id_to_tuple[processor_id].processor_id) {
exists = 1;
if (map_processor_id_to_tuple[processor_id].online) {
online = 1;
}
}
if (NULL != exists_arg) {
*exists_arg = exists;
}
if (NULL != online_arg) {
*online_arg = online;
}
return 0; return 0;
} }
...@@ -547,24 +806,82 @@ int PLPA_NAME(get_socket_info)(int *num_sockets_arg, int *max_socket_id_arg) ...@@ -547,24 +806,82 @@ int PLPA_NAME(get_socket_info)(int *num_sockets_arg, int *max_socket_id_arg)
} }
} }
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check cache behavior */
if (0 != (ret = cache_action())) {
return ret;
}
/* Check for bozo arguments */ /* Check for bozo arguments */
if (NULL == max_socket_id_arg || NULL == num_sockets_arg) { if (NULL == max_socket_id_arg || NULL == num_sockets_arg) {
return EINVAL; return EINVAL;
} }
/* All done */
*num_sockets_arg = num_sockets;
*max_socket_id_arg = max_socket_id;
return 0;
}
/* Returns the Linux socket ID for the Nth socket (starting with 0). */
int PLPA_NAME(get_socket_id)(int socket_num, int *socket_id)
{
int ret, i, j, k, count;
/* Initialize if not already done so */
if (!PLPA_NAME(initialized)) {
if (0 != (ret = PLPA_NAME(init)())) {
return ret;
}
}
/* If this system doesn't support mapping, sorry Charlie */ /* If this system doesn't support mapping, sorry Charlie */
if (!supported) { if (!supported) {
return ENOSYS; return ENOSYS;
} }
/* All done */ /* Check for bozo arguments */
*num_sockets_arg = num_sockets; if (NULL == socket_id) {
*max_socket_id_arg = max_socket_id; return EINVAL;
return 0; }
/* Check cache behavior */
if (0 != (ret = cache_action())) {
return ret;
}
/* Check for out of range params */
if (socket_num < 0 || socket_num > num_sockets) {
return EINVAL;
}
/* Find the socket_num'th socket */
for (count = i = 0; i <= max_socket_id; ++i) {
/* See if any core in this socket is active. If so, count
this socket */
for (j = 0; j <= max_core_id_overall; ++j) {
k = i * (max_core_id_overall + 1) + j;
if (map_tuple_to_processor_id[k]->processor_id >= 0) {
if (count++ == socket_num) {
*socket_id = map_tuple_to_processor_id[k]->socket_id;
return 0;
}
/* Ok, we found one -- skip to the end of this socket */
j = max_core_id_overall + 1;
}
}
}
/* Didn't find it */
return ENODEV;
} }
/* Return the number of cores in a socket and the max core ID number */ /* Return the number of cores in a socket and the max core ID number */
int PLPA_NAME(get_core_info)(int socket, int *num_cores_arg, int PLPA_NAME(get_core_info)(int socket_id, int *num_cores_arg,
int *max_core_id_arg) int *max_core_id_arg)
{ {
int ret; int ret;
...@@ -576,27 +893,168 @@ int PLPA_NAME(get_core_info)(int socket, int *num_cores_arg, ...@@ -576,27 +893,168 @@ int PLPA_NAME(get_core_info)(int socket, int *num_cores_arg,
} }
} }
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check for bozo arguments */ /* Check for bozo arguments */
if (NULL == max_core_id_arg || NULL == num_cores_arg) { if (NULL == max_core_id_arg || NULL == num_cores_arg) {
return EINVAL; return EINVAL;
} }
/* If this system doesn't support mapping, sorry Charlie */ /* Check cache behavior */
if (!supported) { if (0 != (ret = cache_action())) {
return ENOSYS; return ret;
} }
/* Check for some invalid entries */ /* Check for some invalid entries */
if (socket < 0 || socket > max_socket_id || -1 == max_core_id[socket]) { if (socket_id < 0 || socket_id > max_socket_id ||
-1 == max_core_id[socket_id]) {
return ENOENT; return ENOENT;
} }
ret = num_cores[socket]; ret = num_cores[socket_id];
if (-1 == ret) { if (-1 == ret) {
return ENOENT; return ENOENT;
} }
/* All done */ /* All done */
*num_cores_arg = ret; *num_cores_arg = ret;
*max_core_id_arg = max_core_id[socket]; *max_core_id_arg = max_core_id[socket_id];
return 0;
}
/* Given a specific socket, returns the Linux core ID for the Nth core
(starting with 0) */
int PLPA_NAME(get_core_id)(int socket_id, int core_num, int *core_id)
{
int ret, i, j, count;
/* Initialize if not already done so */
if (!PLPA_NAME(initialized)) {
if (0 != (ret = PLPA_NAME(init)())) {
return ret;
}
}
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check for bozo arguments */
if (NULL == core_id) {
return EINVAL;
}
/* Check cache behavior */
if (0 != (ret = cache_action())) {
return ret;
}
/* Check for out of range params */
if (socket_id < 0 || socket_id > max_socket_id ||
core_num < 0 || core_num > max_core_id_overall) {
return EINVAL;
}
/* Find the core_num'th core */
for (count = i = 0, j = socket_id * (max_core_id_overall + 1);
i <= max_core_id_overall; ++i) {
if (map_tuple_to_processor_id[j + i]->processor_id >= 0) {
if (count++ == core_num) {
*core_id = map_tuple_to_processor_id[j + i]->core_id;
return 0;
}
}
}
/* Didn't find it */
return ENODEV;
}
/* Check to see if a given Linux (socket_id,core_id) tuple exists / is
online. Returns 0 on success. */
int PLPA_NAME(get_core_flags)(int socket_id, int core_id,
int *exists_arg, int *online_arg)
{
int ret, i, exists, online;
/* Initialize if not already done so */
if (!PLPA_NAME(initialized)) {
if (0 != (ret = PLPA_NAME(init)())) {
return ret;
}
}
/* If this system doesn't support mapping, sorry Charlie */
if (!supported) {
return ENOSYS;
}
/* Check for bozo arguments */
if (NULL == exists_arg && NULL == online_arg) {
return EINVAL;
}
/* Check cache behavior */
if (0 != (ret = cache_action())) {
return ret;
}
/* Check for out of range params */
if (socket_id < 0 || socket_id > max_socket_id ||
core_id < 0 || core_id > max_core_id_overall) {
return EINVAL;
}
exists = online = 0;
i = socket_id * (max_core_id_overall + 1) + core_id;
if (map_tuple_to_processor_id[i]->processor_id >= 0) {
exists = 1;
if (map_tuple_to_processor_id[i]->online) {
online = 1;
}
}
if (NULL != exists_arg) {
*exists_arg = exists;
}
if (NULL != online_arg) {
*online_arg = online;
}
return 0;
}
/* Set PLPA's caching behavior */
int PLPA_NAME(set_cache_behavior)(PLPA_NAME(cache_behavior_t) behavior)
{
switch (behavior) {
case PLPA_NAME_CAPS(CACHE_USE):
if (PLPA_NAME_CAPS(CACHE_USE) != cache_behavior) {
load_cache();
cache_behavior = PLPA_NAME_CAPS(CACHE_USE);
}
break;
case PLPA_NAME_CAPS(CACHE_IGNORE):
if (PLPA_NAME_CAPS(CACHE_IGNORE) != cache_behavior) {
clear_cache();
cache_behavior = PLPA_NAME_CAPS(CACHE_IGNORE);
}
break;
case PLPA_NAME_CAPS(CACHE_REFRESH):
if (PLPA_NAME_CAPS(CACHE_USE) != cache_behavior) {
return EINVAL;
}
clear_cache();
load_cache();
break;
default:
return EINVAL;
}
return 0; return 0;
} }
plpa-1.1/src/plpa_runtime.c → plpa-1.3.2/src/libplpa/plpa_runtime.c
View file @ 6501432e
...@@ -35,7 +35,7 @@ int PLPA_NAME(init)(void) ...@@ -35,7 +35,7 @@ int PLPA_NAME(init)(void)
/* Otherwise, initialize all the sybsystems */ /* Otherwise, initialize all the sybsystems */
if (0 != (ret = pthread_mutex_init(&mutex, NULL)) || if (0 != (ret = pthread_mutex_init(&mutex, NULL)) ||
0 != (ret = PLPA_NAME(api_probe_init)()) || 0 != (ret = PLPA_NAME(api_probe_init)()) ||
0 != (ret = PLPA_NAME(map_init)())) { 0 != (ret = PLPA_NAME(set_cache_behavior)(PLPA_NAME_CAPS(CACHE_USE)))) {
return ret; return ret;
} }
...@@ -66,7 +66,7 @@ int PLPA_NAME(finalize)(void) ...@@ -66,7 +66,7 @@ int PLPA_NAME(finalize)(void)
} }
/* Ok, we're the last one. Cleanup. */ /* Ok, we're the last one. Cleanup. */
PLPA_NAME(map_finalize)(); PLPA_NAME(set_cache_behavior)(PLPA_NAME_CAPS(CACHE_IGNORE));
pthread_mutex_destroy(&mutex); pthread_mutex_destroy(&mutex);
PLPA_NAME(initialized) = 0; PLPA_NAME(initialized) = 0;
return 0; return 0;
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment