linux_cpu_utils.c File Reference

Include dependency graph for linux_cpu_utils.c:

Go to the source code of this file.

Macros
#define	VENDOR_UNKNOWN   -1
#define	VENDOR_UNINITED   0
#define	VENDOR_INTEL_X86   1
#define	VENDOR_AMD   2
#define	VENDOR_IBM   3
#define	VENDOR_CRAY   4
#define	VENDOR_MIPS   8
#define	VENDOR_INTEL_IA64   9
#define	VENDOR_ARM_ARM   65
#define	VENDOR_ARM_BROADCOM   66
#define	VENDOR_ARM_CAVIUM   67
#define	VENDOR_ARM_FUJITSU   70
#define	VENDOR_ARM_HISILICON   72
#define	VENDOR_ARM_APM   80
#define	VENDOR_ARM_QUALCOMM   81
#define	_PATH_SYS_SYSTEM   "/sys/devices/system/"
#define	_PATH_SYS_CPU0   _PATH_SYS_SYSTEM "/cpu/cpu0"
#define	TOPOKEY_NUM_KEY   4
#define	VERKEY_NUM_KEY   4

Functions
static int	get_topology_info (const char *key, int *value)
static int	get_naming_info (const char *key, char *value)
static int	get_versioning_info (const char *key, int *value)
static int	get_cache_info (CPU_attr_e attr, int level, int *value)
static int	get_cache_level (const char *dirname, int *value)
static int	get_cache_type (const char *dirname, int *value)
static int	get_cache_size (const char *dirname, int *value)
static int	get_cache_line_size (const char *dirname, int *value)
static int	get_cache_associativity (const char *dirname, int *value)
static int	get_cache_partition_count (const char *dirname, int *value)
static int	get_cache_set_count (const char *dirname, int *value)
static int	get_mem_info (int node, int *value)
static int	get_thread_affinity (int thread, int *value)
static int	path_sibling (const char *path,...)
static char *	search_cpu_info (FILE *fp, const char *key)
static int	path_exist (const char *path,...)
static void	decode_vendor_string (char *s, int *vendor)
static int	get_vendor_id (void)
int	linux_cpu_get_vendor (char *vendor)
int	linux_cpu_get_name (char *name)
int	linux_cpu_get_attribute (CPU_attr_e attr, int *value)
int	linux_cpu_get_attribute_at (CPU_attr_e attr, int loc, int *value)
int	linux_cpu_set_affinity (int cpu)
int	linux_cpu_get_num_supported (void)
int	linux_cpu_store_affinity (void)
int	linux_cpu_load_affinity (void)
FILE *	xfopen (const char *path, const char *mode)
FILE *	path_vfopen (const char *mode, const char *path, va_list ap)

Variables
static cpu_set_t	saved_affinity
static _sysdetect_cache_level_info_t	clevel [PAPI_MAX_MEM_HIERARCHY_LEVELS]
static char	pathbuf [PATH_MAX] = "/"

Macro Definition Documentation

_PATH_SYS_CPU0

#define _PATH_SYS_CPU0   _PATH_SYS_SYSTEM "/cpu/cpu0"

Definition at line 30 of file linux_cpu_utils.c.

_PATH_SYS_SYSTEM

#define _PATH_SYS_SYSTEM   "/sys/devices/system/"

Definition at line 29 of file linux_cpu_utils.c.

TOPOKEY_NUM_KEY

#define TOPOKEY_NUM_KEY   4

VENDOR_AMD

#define VENDOR_AMD   2

Definition at line 16 of file linux_cpu_utils.c.

VENDOR_ARM_APM

#define VENDOR_ARM_APM   80

Definition at line 26 of file linux_cpu_utils.c.

VENDOR_ARM_ARM

#define VENDOR_ARM_ARM   65

Definition at line 21 of file linux_cpu_utils.c.

VENDOR_ARM_BROADCOM

#define VENDOR_ARM_BROADCOM   66

Definition at line 22 of file linux_cpu_utils.c.

VENDOR_ARM_CAVIUM

#define VENDOR_ARM_CAVIUM   67

Definition at line 23 of file linux_cpu_utils.c.

VENDOR_ARM_FUJITSU

#define VENDOR_ARM_FUJITSU   70

Definition at line 24 of file linux_cpu_utils.c.

VENDOR_ARM_HISILICON

#define VENDOR_ARM_HISILICON   72

Definition at line 25 of file linux_cpu_utils.c.

VENDOR_ARM_QUALCOMM

#define VENDOR_ARM_QUALCOMM   81

Definition at line 27 of file linux_cpu_utils.c.

VENDOR_CRAY

#define VENDOR_CRAY   4

Definition at line 18 of file linux_cpu_utils.c.

VENDOR_IBM

#define VENDOR_IBM   3

Definition at line 17 of file linux_cpu_utils.c.

VENDOR_INTEL_IA64

#define VENDOR_INTEL_IA64   9

Definition at line 20 of file linux_cpu_utils.c.

VENDOR_INTEL_X86

#define VENDOR_INTEL_X86   1

Definition at line 15 of file linux_cpu_utils.c.

VENDOR_MIPS

#define VENDOR_MIPS   8

Definition at line 19 of file linux_cpu_utils.c.

VENDOR_UNINITED

#define VENDOR_UNINITED   0

Definition at line 14 of file linux_cpu_utils.c.

VENDOR_UNKNOWN

#define VENDOR_UNKNOWN   -1

Definition at line 13 of file linux_cpu_utils.c.

VERKEY_NUM_KEY

#define VERKEY_NUM_KEY   4

Function Documentation

decode_vendor_string()

void decode_vendor_string ( char *  s, int *  vendor  )

static

Definition at line 859 of file linux_cpu_utils.c.

{
    if (strcasecmp(s, "GenuineIntel") == 0)
        *vendor = VENDOR_INTEL_X86;
    else if ((strcasecmp(s, "AMD") == 0) ||
             (strcasecmp(s, "AuthenticAMD") == 0 ))
        *vendor = VENDOR_AMD;
    else if (strcasecmp(s, "IBM") == 0)
        *vendor = VENDOR_IBM;
    else if (strcasecmp(s, "Cray") == 0)
        *vendor = VENDOR_CRAY;
    else if (strcasecmp(s, "ARM_ARM") == 0)
        *vendor = VENDOR_ARM_ARM;
    else if (strcasecmp(s, "ARM_BROADCOM") == 0)
        *vendor = VENDOR_ARM_BROADCOM;
    else if (strcasecmp(s, "ARM_CAVIUM") == 0)
        *vendor = VENDOR_ARM_CAVIUM;
    else if (strcasecmp(s, "ARM_FUJITSU") == 0)
        *vendor = VENDOR_ARM_FUJITSU;
    else if (strcasecmp(s, "ARM_HISILICON") == 0)
        *vendor = VENDOR_ARM_HISILICON;
    else if (strcasecmp(s, "ARM_APM") == 0)
        *vendor = VENDOR_ARM_APM;
    else if (strcasecmp(s, "ARM_QUALCOMM") == 0)
        *vendor = VENDOR_ARM_QUALCOMM;
    else if (strcasecmp(s, "MIPS") == 0)
        *vendor = VENDOR_MIPS;
    else if (strcasecmp(s, "SiCortex") == 0)
        *vendor = VENDOR_MIPS;
    else
        *vendor = VENDOR_UNKNOWN;
}

Here is the caller graph for this function:

get_cache_associativity()

int get_cache_associativity ( const char *  dirname, int *  value  )

static

Definition at line 650 of file linux_cpu_utils.c.

{
    char filename[BUFSIZ];
    int associativity;
 
    sprintf(filename, "/sys/devices/system/cpu/cpu0/cache/%s/ways_of_associativity",
            dirname);
 
    FILE *fff = fopen(filename, "r");
    if (fff == NULL) {
        MEMDBG("Cannot open associativity\n");
        return CPU_ERROR;
    }
 
    int result = fscanf(fff, "%d", &associativity);
    fclose(fff);
    if (result != 1) {
        MEMDBG("Could not read cache associativity\n");
        return CPU_ERROR;
    }
 
    *value = associativity;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_cache_info()

int get_cache_info ( CPU_attr_e  attr, int  level, int *  value  )

static

Definition at line 430 of file linux_cpu_utils.c.

{
    int type = 0;
    int size, line_size, associativity, sets;
    DIR *dir;
    struct dirent *d;
    int max_level = 0;
    int *level_count, level_index;
    static _sysdetect_cache_level_info_t *L;
 
    if (L) {
        return cpu_get_cache_info(attr, level, L, val);
    }
 
    L = clevel;
 
    /* open Linux cache dir                 */
    /* assume all CPUs same as cpu0.        */
    /* Not necessarily a good assumption    */
 
    dir = opendir("/sys/devices/system/cpu/cpu0/cache");
    if (dir == NULL) {
        goto fn_fail;
    }
 
    while(1) {
        d = readdir(dir);
        if (d == NULL)
            break;
 
        if (strncmp(d->d_name, "index", 5))
            continue;
 
        if (get_cache_level(d->d_name, &level_index)) {
            goto fn_fail;
        }
 
        if (get_cache_type(d->d_name, &type)) {
            goto fn_fail;
        }
        level_count = &L[level_index].num_caches;
        L[level_index].cache[*level_count].type = type;
 
        if (get_cache_size(d->d_name, &size)) {
            goto fn_fail;
        }
        /* Linux reports in kB, PAPI expects in Bytes */
        L[level_index].cache[*level_count].size = size * 1024;
 
        if (get_cache_line_size(d->d_name, &line_size)) {
            goto fn_fail;
        }
        L[level_index].cache[*level_count].line_size = line_size;
 
        if (get_cache_associativity(d->d_name, &associativity)) {
            goto fn_fail;
        }
        L[level_index].cache[*level_count].associativity = associativity;
 
        int partitions;
        if (get_cache_partition_count(d->d_name, &partitions)) {
            goto fn_fail;
        }
 
        if (get_cache_set_count(d->d_name, &sets)) {
            goto fn_fail;
        }
        L[level_index].cache[*level_count].num_lines =
            (sets * associativity * partitions);
 
        if (((size * 1024) / line_size / associativity) != sets) {
            MEMDBG("Warning!  sets %d != expected %d\n",
                   sets, ((size * 1024) / line_size / associativity));
        }
 
        if (level > max_level) {
            max_level = level;
        }
 
        if (level >= PAPI_MAX_MEM_HIERARCHY_LEVELS) {
            MEMDBG("Exceeded maximum cache level %d\n",
                   PAPI_MAX_MEM_HIERARCHY_LEVELS);
            break;
        }
 
        ++(*level_count);
    }
 
    closedir(dir);
    return cpu_get_cache_info(attr, level, L, val);
 
  fn_fail:
    closedir(dir);
    return CPU_ERROR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_cache_level()

int get_cache_level ( const char *  dirname, int *  value  )

static

Definition at line 527 of file linux_cpu_utils.c.

{
    char filename[BUFSIZ];
    int level_index;
 
    sprintf(filename, "/sys/devices/system/cpu/cpu0/cache/%s/level",
            dirname);
 
    FILE *fff = fopen(filename,"r");
    if (fff == NULL) {
        MEMDBG("Cannot open level.\n");
        return CPU_ERROR;
    }
 
    int result = fscanf(fff, "%d", &level_index);
    fclose(fff);
    if (result != 1) {
        MEMDBG("Could not read cache level\n");
        return CPU_ERROR;
    }
 
    /* Index arrays from 0 */
    level_index -= 1;
    *value = level_index;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_cache_line_size()

int get_cache_line_size ( const char *  dirname, int *  value  )

static

Definition at line 623 of file linux_cpu_utils.c.

{
    char filename[BUFSIZ];
    int line_size;
 
    sprintf(filename, "/sys/devices/system/cpu/cpu0/cache/%s/coherency_line_size",
            dirname);
 
    FILE *fff = fopen(filename, "r");
    if (fff == NULL) {
        MEMDBG("Cannot open linesize\n");
        return CPU_ERROR;
    }
 
    int result = fscanf(fff, "%d", &line_size);
    fclose(fff);
    if (result != 1) {
        MEMDBG("Could not read cache line-size\n");
        return CPU_ERROR;
    }
 
    *value = line_size;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_cache_partition_count()

int get_cache_partition_count ( const char *  dirname, int *  value  )

static

Definition at line 677 of file linux_cpu_utils.c.

{
    char filename[BUFSIZ];
    int partitions;
 
    sprintf(filename, "/sys/devices/system/cpu/cpu0/cache/%s/physical_line_partition",
            dirname);
 
    FILE *fff = fopen(filename, "r");
    if (fff == NULL) {
        MEMDBG("Cannot open partitions\n");
        return CPU_ERROR;
    }
 
    int result = fscanf(fff, "%d", &partitions);
    fclose(fff);
    if (result != 1) {
        MEMDBG("Could not read partitions count\n");
        return CPU_ERROR;
    }
 
    *value = partitions;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_cache_set_count()

int get_cache_set_count ( const char *  dirname, int *  value  )

static

Definition at line 704 of file linux_cpu_utils.c.

{
    char filename[BUFSIZ];
    int sets;
 
    sprintf(filename, "/sys/devices/system/cpu/cpu0/cache/%s/number_of_sets",
            dirname);
 
    FILE *fff = fopen(filename, "r");
    if (fff == NULL) {
        MEMDBG("Cannot open sets\n");
        return CPU_ERROR;
    }
 
    int result = fscanf(fff, "%d", &sets);
    fclose(fff);
    if (result != 1) {
        MEMDBG("Could not read cache sets\n");
        return CPU_ERROR;
    }
 
    *value = sets;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_cache_size()

int get_cache_size ( const char *  dirname, int *  value  )

static

Definition at line 596 of file linux_cpu_utils.c.

{
    char filename[BUFSIZ];
    int size;
 
    sprintf(filename, "/sys/devices/system/cpu/cpu0/cache/%s/size",
            dirname);
 
    FILE *fff = fopen(filename, "r");
    if (fff == NULL) {
        MEMDBG("Cannot open size\n");
        return CPU_ERROR;
    }
 
    int result = fscanf(fff, "%d", &size);
    fclose(fff);
    if (result != 1) {
        MEMDBG("Could not read cache size\n");
        return CPU_ERROR;
    }
 
    *value = size;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_cache_type()

int get_cache_type ( const char *  dirname, int *  value  )

static

Definition at line 556 of file linux_cpu_utils.c.

{
    char filename[BUFSIZ];
    char type_string[BUFSIZ];
    int type;
 
    sprintf(filename, "/sys/devices/system/cpu/cpu0/cache/%s/type",
            dirname);
 
    FILE *fff = fopen(filename, "r");
    if (fff == NULL) {
        MEMDBG("Cannot open type\n");
        return CPU_ERROR;
    }
 
    char *result = fgets(type_string, BUFSIZ, fff);
    fclose(fff);
    if (result == NULL) {
        MEMDBG("Could not read cache type\n");
        return CPU_ERROR;
    }
 
    if (!strcmp(type_string, "Data")) {
        type = PAPI_MH_TYPE_DATA;
    }
 
    if (!strcmp(type_string, "Instruction")) {
        type = PAPI_MH_TYPE_INST;
    }
 
    if (!strcmp(type_string, "Unified")) {
        type = PAPI_MH_TYPE_UNIFIED;
    }
 
    *value = type;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_mem_info()

int get_mem_info ( int  node, int *  value  )

static

Definition at line 731 of file linux_cpu_utils.c.

{
    if (path_exist(_PATH_SYS_SYSTEM "/node/node%d", node)) {
        char filename[PAPI_MAX_STR_LEN];
        sprintf(filename, _PATH_SYS_SYSTEM "/node/node%d/meminfo", node);
        FILE *fp = fopen(filename, "r");
        if (!fp) {
            return CPU_ERROR;
        }
 
        char search_str[PAPI_MIN_STR_LEN];
        sprintf(search_str, "Node %d MemTotal", node);
        char *str = search_cpu_info(fp, search_str);
        if (str) {
            sprintf(search_str, "%s", str);
            int len = strlen(search_str);
            search_str[len-3] = '\0'; /* Remove trailing "KB" */
            *val = atoi(search_str);
        }
 
        fclose(fp);
    }
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_naming_info()

int get_naming_info ( const char *  key, char *  value  )

static

Definition at line 348 of file linux_cpu_utils.c.

{
    if (!strcmp(key, "none")) {
        strcpy(val, "UNKNOWN");
        return CPU_SUCCESS;
    }
 
    FILE *fp = fopen("/proc/cpuinfo", "r");
    if (fp == NULL) {
        return CPU_ERROR;
    }
 
    char *str = search_cpu_info(fp, key);
    if (str) {
        strncpy(val, str, PAPI_MAX_STR_LEN);
        val[PAPI_MAX_STR_LEN - 1] = 0;
    }
 
    fclose(fp);
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_thread_affinity()

int get_thread_affinity ( int  thread, int *  value  )

static

Definition at line 758 of file linux_cpu_utils.c.

{
    if (!path_exist(_PATH_SYS_SYSTEM "/cpu/cpu0/node0")) {
        *val = 0;
        return CPU_SUCCESS;
    }
 
    int i = 0;
    while (!path_exist(_PATH_SYS_SYSTEM "/cpu/cpu%d/node%d", thread, i)) {
        ++i;
    }
    *val = i;
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_topology_info()

int get_topology_info ( const char *  key, int *  value  )

static

Definition at line 293 of file linux_cpu_utils.c.

{
    int status = CPU_SUCCESS;
    static int sockets, nodes, threads, cores;
 
    if (!strcmp("sockets", key) && sockets) {
        *val = sockets;
        return status;
    } else if (!strcmp("nodes", key) && nodes) {
        *val = nodes;
        return status;
    } else if (!strcmp("threads", key) && threads) {
        *val = threads;
        return status;
    } else if (!strcmp("cores", key) && cores) {
        *val = cores;
        return status;
    }
 
    /* Query topology information once and store results for later */
    int totalcpus = 0;
 
    while (path_exist(_PATH_SYS_SYSTEM "/cpu/cpu%d", totalcpus)) {
        ++totalcpus;
    }
 
    if (path_exist(_PATH_SYS_CPU0 "/topology/thread_siblings")) {
        threads = path_sibling(_PATH_SYS_CPU0 "/topology/thread_siblings");
    }
 
    if (path_exist(_PATH_SYS_CPU0 "/topology/core_siblings")) {
        cores = path_sibling(_PATH_SYS_CPU0 "/topology/core_siblings") / threads;
    }
 
    sockets = totalcpus / cores / threads;
 
    while (path_exist(_PATH_SYS_SYSTEM "/node/node%d", nodes))
        ++nodes;
 
    if (!strcmp("sockets", key)) {
        *val = sockets;
    } else if (!strcmp("nodes", key)) {
        *val = (nodes == 0) ? nodes = 1 : nodes;
    } else if (!strcmp("cores", key)) {
        *val = cores;
    } else if (!strcmp("threads", key)) {
        *val = threads;
    } else {
        status = CPU_ERROR;
    }
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_vendor_id()

int get_vendor_id ( void  )

static

Definition at line 893 of file linux_cpu_utils.c.

{
    static int vendor_id; // VENDOR_UNINITED;
 
    if (vendor_id != VENDOR_UNINITED)
        return vendor_id;
 
    FILE *fp = fopen("/proc/cpuinfo", "r");
    if (fp == NULL) {
        return CPU_ERROR;
    }
 
    char vendor_string[PAPI_MAX_STR_LEN] = "";
    char *s = search_cpu_info(fp, "vendor_id");
    if (s) {
        strncpy(vendor_string, s, PAPI_MAX_STR_LEN);
        vendor_string[PAPI_MAX_STR_LEN - 1] = 0;
    } else {
        s = search_cpu_info(fp, "vendor");
        if (s) {
            strncpy(vendor_string, s, PAPI_MAX_STR_LEN);
            vendor_string[PAPI_MAX_STR_LEN - 1] = 0;
        } else {
            s = search_cpu_info(fp, "system type");
            if (s) {
                strncpy(vendor_string, s, PAPI_MAX_STR_LEN);
                vendor_string[PAPI_MAX_STR_LEN - 1] = 0;
            } else {
                s = search_cpu_info(fp, "platform");
                if (s) {
                    if (strcasecmp(s, "pSeries") == 0 ||
                        strcasecmp(s, "PowerNV") == 0 ||
                        strcasecmp(s, "PowerMac") == 0) {
                        strcpy(vendor_string, "IBM");
                    }
                } else {
                    s = search_cpu_info(fp, "CPU implementer");
                    if (s) {
                        int tmp;
                        sscanf(s, "%x", &tmp);
                        switch(tmp) {
                            case VENDOR_ARM_ARM:
                                strcpy(vendor_string, "ARM_ARM");
                                break;
                            case VENDOR_ARM_BROADCOM:
                                strcpy(vendor_string, "ARM_BROADCOM");
                                break;
                            case VENDOR_ARM_CAVIUM:
                                strcpy(vendor_string, "ARM_CAVIUM");
                                break;
                            case VENDOR_ARM_FUJITSU:
                                strcpy(vendor_string, "ARM_FUJITSU");
                                break;
                            case VENDOR_ARM_HISILICON:
                                strcpy(vendor_string, "ARM_HISILICON");
                                break;
                            case VENDOR_ARM_APM:
                                strcpy(vendor_string, "ARM_APM");
                                break;
                            case VENDOR_ARM_QUALCOMM:
                                strcpy(vendor_string, "ARM_QUALCOMM");
                                break;
                            default:
                                strcpy(vendor_string, "UNKNOWN");
                        }
                    }
                }
            }
        }
    }
 
    if (strlen(vendor_string)) {
        decode_vendor_string(vendor_string, &vendor_id);
    }
 
    fclose(fp);
    return vendor_id;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_versioning_info()

int get_versioning_info ( const char *  key, int *  value  )

static

Definition at line 372 of file linux_cpu_utils.c.

{
    if (!strcmp(key, "none")) {
        *val = -1;
        return CPU_SUCCESS;
    }
 
    if (!strcmp(key, "vendor_id") || !strcmp(key, "CPU implementer")) {
        *val = get_vendor_id();
        return CPU_SUCCESS;
    }
 
    FILE *fp = fopen("/proc/cpuinfo", "r");
    if (fp == NULL) {
        return CPU_ERROR;
    }
 
    char *str = search_cpu_info(fp, key);
    if (str) {
        /* FIXME: this is a ugly hack to handle old (prior to Linux 3.19) ARM64 */
        if (strcmp(key, "CPU architecture") == 0) {
            /* Prior version 3.19 'CPU architecture' is always 'AArch64'
             * so we convert it to '8', which is the value since 3.19. */
            if (strstr(str, "AArch64"))
                *val = 8;
            else
                *val = strtol(str, NULL, 10);
 
            /* Old Fallbacks if the above didn't work (e.g. Raspberry Pi) */
            if (*val < 0) {
                str = search_cpu_info(fp, "Processor");
                if (str) {
                    char *t = strchr(str, '(');
                    int tmp = *(t + 2) - '0';
                    *val = tmp;
                } else {
                    /* Try the model name and look inside of parens */
                    str = search_cpu_info(fp, "model name");
                    if (str) {
                        char *t = strchr(str, '(');
                        int tmp = *(t + 2) - '0';
                        *val = tmp;
                    }
                }
            }
        } else {
            sscanf(str, "%x", val);
        }
    }
 
    fclose(fp);
 
    return CPU_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

linux_cpu_get_attribute()

int linux_cpu_get_attribute	(	CPU_attr_e	attr,
		int *	value
	)

Definition at line 120 of file linux_cpu_utils.c.

{
    int status = CPU_SUCCESS;
 
#define TOPOKEY_NUM_KEY 4
#define VERKEY_NUM_KEY 4
 
    int topo_idx = TOPOKEY_NUM_KEY;
    int ver_idx = VERKEY_NUM_KEY;
 
    const char *topokey[TOPOKEY_NUM_KEY] = {
        "sockets",
        "nodes",
        "threads",
        "cores",
    };
 
    const char *verkey_x86[VERKEY_NUM_KEY] = {
        "cpu family",       /* cpuid_family */
        "model",            /* cpuid_model */
        "stepping",         /* cpuid_stepping */
        "vendor_id",        /* vendor id */
    };
 
    const char *verkey_ibm[VERKEY_NUM_KEY] = {
        "none",             /* cpuid_family */
        "none",             /* cpuid_model */
        "revision",         /* cpuid_stepping */
        "vendor_id",        /* vendor id */
    };
 
    const char *verkey_arm[VERKEY_NUM_KEY] = {
        "CPU architecture", /* cpuid_family */
        "CPU part",         /* cpuid_model */
        "CPU variant",      /* cpuid_stepping */
        "CPU implementer",  /* vendor id */
    };
 
    const char *verkey_dum[VERKEY_NUM_KEY] = {
        "none",
        "none",
        "none",
        "none",
    };
 
    const char **verkey_ptr = NULL;
 
    int vendor_id = get_vendor_id();
 
    if (vendor_id == VENDOR_INTEL_X86 || vendor_id == VENDOR_AMD) {
        verkey_ptr = verkey_x86;
    } else if (vendor_id == VENDOR_IBM) {
        verkey_ptr = verkey_ibm;
    } else if (vendor_id == VENDOR_ARM_ARM       ||
               vendor_id == VENDOR_ARM_BROADCOM  ||
               vendor_id == VENDOR_ARM_CAVIUM    ||
               vendor_id == VENDOR_ARM_FUJITSU   ||
               vendor_id == VENDOR_ARM_HISILICON ||
               vendor_id == VENDOR_ARM_APM       ||
               vendor_id == VENDOR_ARM_QUALCOMM) {
        verkey_ptr = verkey_arm;
    } else {
        verkey_ptr = verkey_dum;
    }
 
    switch(attr) {
        case CPU_ATTR__NUM_SOCKETS:
            --topo_idx;
            // fall through
        case CPU_ATTR__NUM_NODES:
            --topo_idx;
            // fall through
        case CPU_ATTR__NUM_THREADS:
            --topo_idx;
            // fall through
        case CPU_ATTR__NUM_CORES:
            --topo_idx;
            status = get_topology_info(topokey[topo_idx], value);
            break;
        case CPU_ATTR__CPUID_FAMILY:
            --ver_idx;
            // fall through
        case CPU_ATTR__CPUID_MODEL:
            --ver_idx;
            // fall through
        case CPU_ATTR__CPUID_STEPPING:
            --ver_idx;
            // fall through
        case CPU_ATTR__VENDOR_ID:
            --ver_idx;
            status = get_versioning_info(verkey_ptr[ver_idx], value);
            break;
        case CPU_ATTR__CACHE_MAX_NUM_LEVELS:
            *value = PAPI_MAX_MEM_HIERARCHY_LEVELS;
            break;
        default:
            status = CPU_ERROR;
    }
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

linux_cpu_get_attribute_at()

int linux_cpu_get_attribute_at	(	CPU_attr_e	attr,
		int	loc,
		int *	value
	)

Definition at line 223 of file linux_cpu_utils.c.

{
    int status = CPU_SUCCESS;
 
    switch(attr) {
        case CPU_ATTR__CACHE_INST_PRESENT:
        case CPU_ATTR__CACHE_DATA_PRESENT:
        case CPU_ATTR__CACHE_UNIF_PRESENT:
        case CPU_ATTR__CACHE_INST_TOT_SIZE:
        case CPU_ATTR__CACHE_INST_LINE_SIZE:
        case CPU_ATTR__CACHE_INST_NUM_LINES:
        case CPU_ATTR__CACHE_INST_ASSOCIATIVITY:
        case CPU_ATTR__CACHE_DATA_TOT_SIZE:
        case CPU_ATTR__CACHE_DATA_LINE_SIZE:
        case CPU_ATTR__CACHE_DATA_NUM_LINES:
        case CPU_ATTR__CACHE_DATA_ASSOCIATIVITY:
        case CPU_ATTR__CACHE_UNIF_TOT_SIZE:
        case CPU_ATTR__CACHE_UNIF_LINE_SIZE:
        case CPU_ATTR__CACHE_UNIF_NUM_LINES:
        case CPU_ATTR__CACHE_UNIF_ASSOCIATIVITY:
            status = get_cache_info(attr, loc, value);
            break;
        case CPU_ATTR__NUMA_MEM_SIZE:
            status = get_mem_info(loc, value);
            break;
        case CPU_ATTR__HWTHREAD_NUMA_AFFINITY:
            status = get_thread_affinity(loc, value);
            break;
        default:
            status = CPU_ERROR;
    }
 
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

linux_cpu_get_name()

int linux_cpu_get_name

(

char *

name

)

Definition at line 89 of file linux_cpu_utils.c.

{
    const char *namekey_x86 = "model name";
    const char *namekey_ibm = "model";
    const char *namekey_arm = "model name";
    const char *namekey_dum = "none";
 
    const char *namekey_ptr = NULL;
 
    int vendor_id = get_vendor_id();
 
    if (vendor_id == VENDOR_INTEL_X86 || vendor_id == VENDOR_AMD) {
        namekey_ptr = namekey_x86;
    } else if (vendor_id == VENDOR_IBM) {
        namekey_ptr = namekey_ibm;
    } else if (vendor_id == VENDOR_ARM_ARM       ||
               vendor_id == VENDOR_ARM_BROADCOM  ||
               vendor_id == VENDOR_ARM_CAVIUM    ||
               vendor_id == VENDOR_ARM_FUJITSU   ||
               vendor_id == VENDOR_ARM_HISILICON ||
               vendor_id == VENDOR_ARM_APM       ||
               vendor_id == VENDOR_ARM_QUALCOMM) {
        namekey_ptr = namekey_arm;
    } else {
        namekey_ptr = namekey_dum;
    }
 
    return get_naming_info(namekey_ptr, name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

linux_cpu_get_num_supported()

int linux_cpu_get_num_supported

(

void

)

Definition at line 270 of file linux_cpu_utils.c.

{
    return sysconf(_SC_NPROCESSORS_CONF);
}

Here is the caller graph for this function:

linux_cpu_get_vendor()

int linux_cpu_get_vendor

(

char *

vendor

)

Definition at line 52 of file linux_cpu_utils.c.

{
    const char *namekey_x86  = "vendor_id";
    const char *namekey_ia64 = "vendor";
    const char *namekey_ibm  = "platform";
    const char *namekey_mips = "system type";
    const char *namekey_arm  = "CPU implementer";
    const char *namekey_dum  = "none";
 
    const char *namekey_ptr = NULL;
 
    int vendor_id = get_vendor_id();
 
    if (vendor_id == VENDOR_INTEL_X86 || vendor_id == VENDOR_AMD) {
        namekey_ptr = namekey_x86;
    } else if (vendor_id == VENDOR_INTEL_IA64) {
        namekey_ptr = namekey_ia64;
    } else if (vendor_id == VENDOR_IBM) {
        namekey_ptr = namekey_ibm;
    } else if (vendor_id == VENDOR_MIPS) {
        namekey_ptr = namekey_mips;
    } else if (vendor_id == VENDOR_ARM_ARM       ||
               vendor_id == VENDOR_ARM_BROADCOM  ||
               vendor_id == VENDOR_ARM_CAVIUM    ||
               vendor_id == VENDOR_ARM_FUJITSU   ||
               vendor_id == VENDOR_ARM_HISILICON ||
               vendor_id == VENDOR_ARM_APM       ||
               vendor_id == VENDOR_ARM_QUALCOMM) {
        namekey_ptr = namekey_arm;
    } else {
        namekey_ptr = namekey_dum;
    }
 
    return get_naming_info(namekey_ptr, vendor);
}

Here is the call graph for this function:

Here is the caller graph for this function:

linux_cpu_load_affinity()

int linux_cpu_load_affinity

(

void

)

Definition at line 287 of file linux_cpu_utils.c.

{
    return sched_setaffinity(0, sizeof(cpu_set_t), &saved_affinity);
}

Here is the caller graph for this function:

linux_cpu_set_affinity()

int linux_cpu_set_affinity

(

int

cpu

)

Definition at line 259 of file linux_cpu_utils.c.

{
    cpu_set_t cpuset;
 
    CPU_ZERO(&cpuset);
    CPU_SET(cpu, &cpuset);
 
    return sched_setaffinity(0, sizeof(cpuset), &cpuset);
}

Here is the caller graph for this function:

linux_cpu_store_affinity()

int linux_cpu_store_affinity

(

void

)

Definition at line 278 of file linux_cpu_utils.c.

{
    if (!CPU_COUNT(&saved_affinity))
        return sched_getaffinity(0, sizeof(cpu_set_t), &saved_affinity);
 
    return CPU_SUCCESS;
}

Here is the caller graph for this function:

path_exist()

int path_exist ( const char *  path,   ...  )

static

Definition at line 849 of file linux_cpu_utils.c.

{
    va_list ap;
    va_start(ap, path);
    vsnprintf(pathbuf, sizeof ( pathbuf ), path, ap);
    va_end(ap);
    return access(pathbuf, F_OK) == 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

path_sibling()

int path_sibling ( const char *  path,   ...  )

static

Definition at line 791 of file linux_cpu_utils.c.

{
    int c;
    long n;
    int result = CPU_SUCCESS;
    char s[2];
    FILE *fp;
    va_list ap;
    va_start( ap, path );
    fp = path_vfopen( "r", path, ap );
    va_end( ap );
 
    while ((c = fgetc(fp)) != EOF) {
        if (isxdigit(c)) {
            s[0] = (char) c;
            s[1] = '\0';
            for (n = strtol(s, NULL, 16); n > 0; n /= 2) {
                if (n % 2)
                    result++;
            }
        }
    }
 
    fclose(fp);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

path_vfopen()

FILE * path_vfopen	(	const char *	mode,
		const char *	path,
		va_list	ap
	)

Definition at line 784 of file linux_cpu_utils.c.

{
    vsnprintf( pathbuf, sizeof ( pathbuf ), path, ap );
    return xfopen( pathbuf, mode );
}

Here is the call graph for this function:

Here is the caller graph for this function:

search_cpu_info()

char * search_cpu_info ( FILE *  fp, const char *  key  )

static

Definition at line 819 of file linux_cpu_utils.c.

{
    static char line[PAPI_HUGE_STR_LEN] = "";
    char *s, *start = NULL;
 
    rewind(f);
 
    while (fgets(line, PAPI_HUGE_STR_LEN,f) != NULL) {
        s=strstr(line, search_str);
        if (s != NULL) {
            /* skip all characters in line up to the colon */
            /* and then spaces */
            s=strchr(s, ':');
            if (s == NULL) break;
            s++;
            while (isspace(*s)) {
                s++;
            }
            start = s;
            /* Find and clear newline */
            s=strrchr(start, '\n');
            if (s != NULL) *s = 0;
            break;
        }
    }
 
    return start;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xfopen()

FILE * xfopen	(	const char *	path,
		const char *	mode
	)

Definition at line 777 of file linux_cpu_utils.c.

{
    FILE *fd = fopen(path, mode);
    return fd;
}

Here is the caller graph for this function:

Variable Documentation

clevel

_sysdetect_cache_level_info_t clevel[PAPI_MAX_MEM_HIERARCHY_LEVELS]

static

Definition at line 427 of file linux_cpu_utils.c.

pathbuf

char pathbuf[PATH_MAX] = "/"

static

Definition at line 774 of file linux_cpu_utils.c.

saved_affinity

cpu_set_t saved_affinity

static

Definition at line 275 of file linux_cpu_utils.c.