hwloc.h

Go to the documentation of this file.

/*
 * Copyright © 2009 CNRS, INRIA, Université Bordeaux 1
 * Copyright © 2009-2010 Cisco Systems, Inc.  All rights reserved.
 * See COPYING in top-level directory.
 */

#ifndef HWLOC_H
#define HWLOC_H

#include <hwloc/config.h>
#include <sys/types.h>
#include <stdio.h>
#include <limits.h>
#ifdef HWLOC_HAVE_STDINT_H
#include <stdint.h>
#endif

/*
 * Symbol transforms
 */
#include <hwloc/rename.h>

/*
 * Cpuset bitmask definitions
 */

#include <hwloc/cpuset.h>


#ifdef __cplusplus
extern "C" {
#endif


#define HWLOC_API_VERSION 0x00010000

struct hwloc_topology;
typedef struct hwloc_topology * hwloc_topology_t;

typedef enum {
  HWLOC_OBJ_SYSTEM,     
  HWLOC_OBJ_MACHINE,    
  HWLOC_OBJ_NODE,       
  HWLOC_OBJ_SOCKET,     
  HWLOC_OBJ_CACHE,      
  HWLOC_OBJ_CORE,       
  HWLOC_OBJ_PU,         
  HWLOC_OBJ_GROUP,      
  HWLOC_OBJ_MISC        
} hwloc_obj_type_t;

 int hwloc_compare_types (hwloc_obj_type_t type1, hwloc_obj_type_t type2) ;

enum hwloc_compare_types_e {
    HWLOC_TYPE_UNORDERED = INT_MAX      
};

union hwloc_obj_attr_u;

struct hwloc_obj_memory_s {
  uint64_t total_memory; 
  uint64_t local_memory; 
  unsigned page_types_len; 
  struct hwloc_obj_memory_page_type_s {
    uint64_t size;      
    uint64_t count;     
  } * page_types;
};

struct hwloc_obj {
  /* physical information */
  hwloc_obj_type_t type;                
  unsigned os_index;                    
  char *name;                           
  struct hwloc_obj_memory_s memory;

  union hwloc_obj_attr_u *attr;

  /* global position */
  unsigned depth;                       
  unsigned logical_index;               
  signed os_level;                      
  struct hwloc_obj *next_cousin;        
  struct hwloc_obj *prev_cousin;        
  /* parent */
  struct hwloc_obj *parent;             
  unsigned sibling_rank;                
  struct hwloc_obj *next_sibling;       
  struct hwloc_obj *prev_sibling;       
  /* children */
  unsigned arity;                       
  struct hwloc_obj **children;          
  struct hwloc_obj *first_child;        
  struct hwloc_obj *last_child;         
  /* misc */
  void *userdata;                       
  /* cpuset */
  hwloc_cpuset_t cpuset;                
  hwloc_cpuset_t complete_cpuset;       
  hwloc_cpuset_t online_cpuset;         
  hwloc_cpuset_t allowed_cpuset;        
  hwloc_cpuset_t nodeset;               
  hwloc_cpuset_t complete_nodeset;      
  hwloc_cpuset_t allowed_nodeset;       
};
typedef struct hwloc_obj * hwloc_obj_t;

union hwloc_obj_attr_u {
  struct hwloc_cache_attr_s {
    uint64_t size;                        
    unsigned depth;                       
  } cache;
  struct hwloc_machine_attr_s {
    char *dmi_board_vendor;               
    char *dmi_board_name;                 
  } machine;
  struct hwloc_group_attr_s {
    unsigned depth;                       
  } group;
};

 int hwloc_topology_init (hwloc_topology_t *topologyp);

 int hwloc_topology_load(hwloc_topology_t topology);

 void hwloc_topology_destroy (hwloc_topology_t topology);

 void hwloc_topology_check(hwloc_topology_t topology);

 int hwloc_topology_ignore_type(hwloc_topology_t topology, hwloc_obj_type_t type);

 int hwloc_topology_ignore_type_keep_structure(hwloc_topology_t topology, hwloc_obj_type_t type);

 int hwloc_topology_ignore_all_keep_structure(hwloc_topology_t topology);

enum hwloc_topology_flags_e {
  HWLOC_TOPOLOGY_FLAG_WHOLE_SYSTEM = (1<<0),
  HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM = (1<<1)
};

 int hwloc_topology_set_flags (hwloc_topology_t topology, unsigned long flags);

 int hwloc_topology_set_fsroot(hwloc_topology_t restrict topology, const char * restrict fsroot_path);

 int hwloc_topology_set_pid(hwloc_topology_t restrict topology, hwloc_pid_t pid);

 int hwloc_topology_set_synthetic(hwloc_topology_t restrict topology, const char * restrict description);

 int hwloc_topology_set_xml(hwloc_topology_t restrict topology, const char * restrict xmlpath);

struct hwloc_topology_discovery_support {
  unsigned char pu;
};

struct hwloc_topology_cpubind_support {
  unsigned char set_thisproc_cpubind;
  unsigned char get_thisproc_cpubind;
  unsigned char set_proc_cpubind;
  unsigned char get_proc_cpubind;
  unsigned char set_thisthread_cpubind;
  unsigned char get_thisthread_cpubind;
  unsigned char set_thread_cpubind;
  unsigned char get_thread_cpubind;
};

struct hwloc_topology_support {
  struct hwloc_topology_discovery_support *discovery;
  struct hwloc_topology_cpubind_support *cpubind;
};

 const struct hwloc_topology_support *hwloc_topology_get_support(hwloc_topology_t restrict topology);

 void hwloc_topology_export_xml(hwloc_topology_t topology, const char *xmlpath);

 hwloc_obj_t hwloc_topology_insert_misc_object_by_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t cpuset, const char *name);

 hwloc_obj_t hwloc_topology_insert_misc_object_by_parent(hwloc_topology_t topology, hwloc_obj_t parent, const char *name);

 unsigned hwloc_topology_get_depth(hwloc_topology_t restrict topology) ;

 int hwloc_get_type_depth (hwloc_topology_t topology, hwloc_obj_type_t type);

enum hwloc_get_type_depth_e {
    HWLOC_TYPE_DEPTH_UNKNOWN = -1, 
    HWLOC_TYPE_DEPTH_MULTIPLE = -2 
};

 hwloc_obj_type_t hwloc_get_depth_type (hwloc_topology_t topology, unsigned depth) ;

 unsigned hwloc_get_nbobjs_by_depth (hwloc_topology_t topology, unsigned depth) ;

static inline int 
hwloc_get_nbobjs_by_type (hwloc_topology_t topology, hwloc_obj_type_t type)
{
        int depth = hwloc_get_type_depth(topology, type);
        if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
                return 0;
        if (depth == HWLOC_TYPE_DEPTH_MULTIPLE)
                return -1; /* FIXME: agregate nbobjs from different levels? */
        return hwloc_get_nbobjs_by_depth(topology, depth);
}

 int hwloc_topology_is_thissystem(hwloc_topology_t  restrict topology) ;

 hwloc_obj_t hwloc_get_obj_by_depth (hwloc_topology_t topology, unsigned depth, unsigned idx) ;

static inline hwloc_obj_t 
hwloc_get_obj_by_type (hwloc_topology_t topology, hwloc_obj_type_t type, unsigned idx)
{
  int depth = hwloc_get_type_depth(topology, type);
  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
    return NULL;
  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE)
    return NULL;
  return hwloc_get_obj_by_depth(topology, depth, idx);
}

 const char * hwloc_obj_type_string (hwloc_obj_type_t type) ;

 hwloc_obj_type_t hwloc_obj_type_of_string (const char * string) ;

 int hwloc_obj_type_snprintf(char * restrict string, size_t size, hwloc_obj_t obj,
                                   int verbose);

 int hwloc_obj_attr_snprintf(char * restrict string, size_t size, hwloc_obj_t obj, const char * restrict separator,
                                   int verbose);

 int hwloc_obj_snprintf(char * restrict string, size_t size,
                             hwloc_topology_t topology, hwloc_obj_t obj,
                             const char * restrict indexprefix, int verbose);

 int hwloc_obj_cpuset_snprintf(char * restrict str, size_t size, size_t nobj, const hwloc_obj_t * restrict objs);

typedef enum {
  HWLOC_CPUBIND_PROCESS = (1<<0), 
  HWLOC_CPUBIND_THREAD = (1<<1),  
  HWLOC_CPUBIND_STRICT = (1<<2)   
} hwloc_cpubind_policy_t;

 int hwloc_set_cpubind(hwloc_topology_t topology, hwloc_const_cpuset_t set,
                            int policy);

 int hwloc_get_cpubind(hwloc_topology_t topology, hwloc_cpuset_t set, int policy);

 int hwloc_set_proc_cpubind(hwloc_topology_t topology, hwloc_pid_t pid, hwloc_const_cpuset_t set, int policy);

 int hwloc_get_proc_cpubind(hwloc_topology_t topology, hwloc_pid_t pid, hwloc_cpuset_t set, int policy);

#ifdef hwloc_thread_t

 int hwloc_set_thread_cpubind(hwloc_topology_t topology, hwloc_thread_t tid, hwloc_const_cpuset_t set, int policy);
#endif

#ifdef hwloc_thread_t

 int hwloc_get_thread_cpubind(hwloc_topology_t topology, hwloc_thread_t tid, hwloc_cpuset_t set, int policy);
#endif

#ifdef __cplusplus
} /* extern "C" */
#endif


/* high-level helpers */
#include <hwloc/helper.h>


#endif /* HWLOC_H */