Sys-Hwloc

 view release on metacpan or  search on metacpan

Hwloc.xs  view on Meta::CPAN

    return -1;

  hwloc_bitmap_zero(map);

  do {

    if(! isdigit(*s))
      return -1;

    b = a = strtoul(s, (char **)&s, 10);

    if(*s == '-') {
      s++;
      if(! isdigit(*s))
	return -1;
      b = strtoul(s, (char **)&s, 10);
    }

    if(a > b)
      return -1;

    while(a <= b)
      hwloc_bitmap_set(map, a++);

    if(*s == ',')
      s++;

  } while(*s != '\0' && *s != '\n');

  return 0;

}
#endif
#endif

/* =================================================================== */
/* XS Code below                                                       */
/* =================================================================== */

MODULE = Sys::Hwloc                  PACKAGE = Sys::Hwloc

INCLUDE: const-xs.inc

 # -------------------------------------------------------------------
 # API version (runtime)
 # -------------------------------------------------------------------

#ifdef HAVE_HWLOC_GET_API_VERSION
int
hwloc_get_api_version()
  PROTOTYPE:
  CODE:
    RETVAL = hwloc_get_api_version();
  OUTPUT:
    RETVAL

#else
void
hwloc_get_api_version()
  PROTOTYPE:
  PPCODE:
    XSRETURN_UNDEF;

#endif

 # -------------------------------------------------------------------
 # Topology object types
 # -------------------------------------------------------------------

int
hwloc_compare_types(type1,type2)
  hwloc_obj_type_t type1
  hwloc_obj_type_t type2
  PROTOTYPE: $$
  CODE:
    RETVAL = hwloc_compare_types(type1,type2);
  OUTPUT:
    RETVAL

 # -------------------------------------------------------------------
 # Create and destroy topologies
 # -------------------------------------------------------------------

void
hwloc_topology_check(topo)
  hwloc_topology_t topo
  PROTOTYPE: $
  ALIAS:
    Sys::Hwloc::Topology::check = 1
  PPCODE:
    PERL_UNUSED_VAR(ix);
    hwloc_topology_check(topo);


void
hwloc_topology_destroy(topo)
  hwloc_topology_t topo
  PROTOTYPE: $
  ALIAS:
    Sys::Hwloc::Topology::destroy = 1
  PPCODE:
    PERL_UNUSED_VAR(ix);
    if(topo) {
      hwloc_topology_destroy(topo);
      sv_setref_pv(ST(0), "Sys::Hwloc::Topology", (void *)NULL);
    }


hwloc_topology_t
hwloc_topology_init()
  PROTOTYPE:
  PREINIT:
    hwloc_topology_t t = NULL;
  CODE:  
    if(! hwloc_topology_init(&t))
      RETVAL = t;
    else
      XSRETURN_UNDEF;
  OUTPUT:
     RETVAL


int
hwloc_topology_load(topo)
  hwloc_topology_t topo
  PROTOTYPE: $
  ALIAS:
    Sys::Hwloc::Topology::load = 1
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_topology_load(topo);
  OUTPUT:
    RETVAL


 # -------------------------------------------------------------------
 # Configure topology detection
 # -------------------------------------------------------------------

int
hwloc_topology_ignore_type(topo,type)
  hwloc_topology_t topo
  hwloc_obj_type_t type
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Topology::ignore_type                     = 1
    Sys::Hwloc::hwloc_topology_ignore_type_keep_structure = 10
    Sys::Hwloc::Topology::ignore_type_keep_structure      = 11
  CODE:
    if(ix < 10)
      RETVAL = hwloc_topology_ignore_type(topo,type);
    else if(ix < 20)
      RETVAL = hwloc_topology_ignore_type_keep_structure(topo,type);
    else
      croak("Should not come here in Sys::Hwloc::hwloc_topology_ignore_type, alias = %d", (int)ix);
  OUTPUT:
    RETVAL


int
hwloc_topology_ignore_all_keep_structure(topo)

Hwloc.xs  view on Meta::CPAN

  const char       *string
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Topology::set_synthetic = 1
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_topology_set_synthetic(topo,string);
  OUTPUT:
    RETVAL


int
hwloc_topology_set_xml(topo,path)
  hwloc_topology_t  topo
  const char       *path
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Topology::set_xml = 1
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_topology_set_xml(topo,path);
  OUTPUT:
    RETVAL


#if HWLOC_XSAPI_VERSION
SV *
hwloc_topology_get_support(topo)
  hwloc_topology_t topo
  PROTOTYPE: $
  ALIAS:
    Sys::Hwloc::Topology::get_support = 1
  PREINIT:
    const struct hwloc_topology_support *st = NULL;
  CODE:
    PERL_UNUSED_VAR(ix);
    if((st = hwloc_topology_get_support(topo)))
      RETVAL = newRV((SV *)hwlocTopologySupport2HV(st));
    else
      XSRETURN_UNDEF;
  OUTPUT:
    RETVAL

#endif


 # -------------------------------------------------------------------
 # Tinker with topologies
 # ToDo: hwloc_topology_insert_misc_object_by_cpuset
 # ToDo: hwloc_topology_insert_misc_object_by_parent
 # -------------------------------------------------------------------

#if HWLOC_HAS_XML
void
hwloc_topology_export_xml(topo,path)
  hwloc_topology_t  topo
  const char       *path
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Topology::export_xml = 1
  PPCODE:
    PERL_UNUSED_VAR(ix);
    hwloc_topology_export_xml(topo,path);

#endif


 # -------------------------------------------------------------------
 # Get some topology information
 # -------------------------------------------------------------------

unsigned
hwloc_topology_get_depth(topo)
  hwloc_topology_t topo
  PROTOTYPE: $
  ALIAS:
    Sys::Hwloc::Topology::get_depth = 1
    Sys::Hwloc::Topology::depth     = 2
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_topology_get_depth(topo);
  OUTPUT:
    RETVAL


int
hwloc_get_type_depth(topo,type)
  hwloc_topology_t topo
  hwloc_obj_type_t type
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Topology::get_type_depth = 1
    Sys::Hwloc::Topology::type_depth     = 2
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_get_type_depth(topo,type);
  OUTPUT:
    RETVAL


int
hwloc_get_depth_type(topo,depth)
  hwloc_topology_t topo
  unsigned         depth
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Topology::get_depth_type = 1
    Sys::Hwloc::Topology::depth_type     = 2
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_get_depth_type(topo,depth);
  OUTPUT:
    RETVAL


unsigned
hwloc_get_nbobjs_by_depth(topo,depth)
  hwloc_topology_t topo
  unsigned         depth
  PROTOTYPE: $$
  ALIAS:

Hwloc.xs  view on Meta::CPAN

  ALIAS:
    Sys::Hwloc::Topology::get_common_ancestor_obj = 1
    Sys::Hwloc::Topology::common_ancestor_obj     = 2
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_get_common_ancestor_obj(NULL,obj1,obj2);
  OUTPUT:
    RETVAL


int
hwloc_obj_is_in_subtree(topo,obj1,obj2)
  hwloc_topology_t topo
  hwloc_obj_t      obj1
  hwloc_obj_t      obj2
  PROTOTYPE: $$$
  ALIAS:
    Sys::Hwloc::Topology::obj_is_in_subtree = 1
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_obj_is_in_subtree(NULL,obj1,obj2);
  OUTPUT:
    RETVAL


int
hwloc_compare_objects(topo,obj1,obj2)
  hwloc_topology_t  topo
  SV               *obj1
  SV               *obj2
  PROTOTYPE: $$$
  ALIAS:
    Sys::Hwloc::Topology::compare_objects = 1
  PREINIT:
    hwloc_obj_t o1 = NULL;
    hwloc_obj_t o2 = NULL;
  CODE:
    PERL_UNUSED_VAR(ix);
    o1 = SV2hwlocObj(obj1, "Sys::Hwloc::hwloc_compare_objects", 1, 1);
    o2 = SV2hwlocObj(obj2, "Sys::Hwloc::hwloc_compare_objects", 2, 1);
    RETVAL = (o1 == o2) ? 1 : 0;
  OUTPUT:
    RETVAL


 # -------------------------------------------------------------------
 # Advanced traversal helpers
 # -------------------------------------------------------------------

void
hwloc_get_closest_objs(topo,obj)
  hwloc_topology_t topo
  hwloc_obj_t      obj
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Topology::get_closest_objs = 1
  PREINIT:
    int rc;
    int i;
    hwloc_obj_t *objs = NULL;
  PPCODE:
    PERL_UNUSED_VAR(ix);
    if((objs = (hwloc_obj_t *)malloc(1024 * sizeof(hwloc_obj_t *))) == NULL)
      croak("Failed to allocate memory");
    rc = hwloc_get_closest_objs(topo,obj,objs,1024);
    if(rc < 0)
      rc = 0;
    EXTEND(SP, rc);
    for(i = 0; i < rc; i++)
      PUSHs(sv_2mortal(hwlocObj2SV(objs[i])));
    free(objs);
    XSRETURN(rc);


#if HWLOC_XSAPI_VERSION
hwloc_obj_t
hwloc_get_obj_below_by_type(topo,type1,idx1,type2,idx2)
  hwloc_topology_t topo
  int              type1
  unsigned         idx1
  int              type2
  unsigned         idx2
  PROTOTYPE: $$$$$
  ALIAS:
    Sys::Hwloc::Topology::get_obj_below_by_type = 1
  CODE:
    PERL_UNUSED_VAR(ix);
    RETVAL = hwloc_get_obj_below_by_type(topo,type1,idx1,type2,idx2);
  OUTPUT:
    RETVAL

#endif


 # -------------------------------------------------------------------
 # Cpuset/Bitmap API
 # -------------------------------------------------------------------

#if HWLOC_XSAPI_VERSION <= 0x00010000
INCLUDE: hwloc_cpuset.xsh

#else
INCLUDE: hwloc_bitmap.xsh

#endif
    

 # ===================================================================
 # PACKAGE Sys::Hwloc::Topology, OO interface of hwloc_topology_t
 # ===================================================================

MODULE = Sys::Hwloc                  PACKAGE = Sys::Hwloc::Topology

 # -------------------------------------------------------------------
 # Constructor only, other methods are aliased from package Sys::Hwloc
 # -------------------------------------------------------------------

hwloc_topology_t
init(void)
  PROTOTYPE:
  ALIAS:

Hwloc.xs  view on Meta::CPAN

#else
hwloc_obj_t
parent(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->parent;
  OUTPUT:
    RETVAL

#endif


unsigned
sibling_rank(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->sibling_rank;
  OUTPUT:
    RETVAL


hwloc_obj_t
next_sibling(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->next_sibling;
  OUTPUT:
    RETVAL


hwloc_obj_t
prev_sibling(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->prev_sibling;
  OUTPUT:
    RETVAL


unsigned
arity(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->arity;
  OUTPUT:
    RETVAL


void
children(o)
  hwloc_obj_t o
  PROTOTYPE: $
  PREINIT:
    int i;
  PPCODE:
    EXTEND(SP, o->arity);
    for(i = 0; i < o->arity; i++)
      PUSHs(sv_2mortal(hwlocObj2SV(o->children[i])));
    XSRETURN(o->arity);


hwloc_obj_t
first_child(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->first_child;
  OUTPUT:
    RETVAL


hwloc_obj_t
last_child(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->last_child;
  OUTPUT:
    RETVAL


#if HWLOC_XSAPI_VERSION < 0x00010100
hwloc_cpuset_t
cpuset(o)
  hwloc_obj_t o
  PROTOTYPE: $
  CODE:
    RETVAL = o->cpuset;
  OUTPUT:
    RETVAL

#if HWLOC_XSAPI_VERSION
hwloc_cpuset_t
complete_cpuset(o)
  hwloc_obj_t o
  PROTOTYPE: $
  ALIAS:
    Sys::Hwloc::Obj::online_cpuset   = 1
    Sys::Hwloc::Obj::allowed_cpuset  = 2
  CODE:
    if(ix == 0)
      RETVAL = o->complete_cpuset;
    else if(ix == 1)
      RETVAL = o->online_cpuset;
    else if(ix == 2)
      RETVAL = o->allowed_cpuset;
    else
      croak("Should not come here in Sys::Hwloc::Obj->complete_cpuset, alias = %d", (int)ix);
  OUTPUT:
    RETVAL

#endif

#else
hwloc_bitmap_t

Hwloc.xs  view on Meta::CPAN

    RETVAL = hwloc_get_common_ancestor_obj(NULL,o1,o2);
  OUTPUT:
    RETVAL


int
is_in_subtree(o1,o2)
  hwloc_obj_t o1
  hwloc_obj_t o2
  PROTOTYPE: $$
  CODE:
    RETVAL = hwloc_obj_is_in_subtree(NULL,o1,o2);
  OUTPUT:
    RETVAL


int
is_same_obj(o1,o2)
  hwloc_obj_t   o1
  SV           *o2
  PROTOTYPE: $$
  PREINIT:
    hwloc_obj_t o = NULL;
  CODE:
    o = SV2hwlocObj(o2, "Sys::Hwloc::Obj->is_same_obj()", 1, 1);
    RETVAL = (o1 == o) ? 1 : 0;
  OUTPUT:
    RETVAL


#if HWLOC_XSAPI_VERSION <= 0x00010000

 # ===================================================================
 # PACKAGE Sys::Hwloc::Cpuset, OO interface of hwloc_cpuset_t
 # ===================================================================

MODULE = Sys::Hwloc                  PACKAGE = Sys::Hwloc::Cpuset

hwloc_cpuset_t
alloc(void)
  PROTOTYPE:
  ALIAS:
    new = 1
  PREINIT:
    hwloc_cpuset_t s = NULL;
  CODE:
    PERL_UNUSED_VAR(ix);
    if((s = hwloc_cpuset_alloc()) == NULL)
      XSRETURN_UNDEF;
    else
      RETVAL = s;
  OUTPUT:
      RETVAL


void
copy(set,dst)
  hwloc_cpuset_t set
  hwloc_cpuset_t dst
  PROTOTYPE: $$
  PPCODE:
    hwloc_cpuset_copy(dst,set);


#if HWLOC_XSAPI_VERSION
void
and(set,seta)
  hwloc_cpuset_t set
  hwloc_cpuset_t seta
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Cpuset::andnot = 1
    Sys::Hwloc::Cpuset::or     = 2
    Sys::Hwloc::Cpuset::xor    = 3
  PREINIT:
    hwloc_cpuset_t res = NULL;
  PPCODE:
    if((res = hwloc_cpuset_alloc()) == NULL)
      croak("Failed to create temporary cpuset in Sys::Hwloc::Cpuset->and alias %d", (int)ix);
    if(ix == 0)
      hwloc_cpuset_and(res,set,seta);
    else if(ix == 1)
      hwloc_cpuset_andnot(res,set,seta);
    else if(ix == 2)
      hwloc_cpuset_or(res,set,seta);
    else if(ix == 3)
      hwloc_cpuset_xor(res,set,seta);
    else
      croak("Should not come here in Sys::Hwloc::Cpuset->and, alias = %d", (int)ix);
    hwloc_cpuset_free(set);
    sv_setref_pv(ST(0), "Sys::Hwloc::Cpuset", (void *)res);


void
not(set)
  hwloc_cpuset_t set
  PROTOTYPE: $
  PREINIT:
    hwloc_cpuset_t res = NULL;
  PPCODE:
    if((res = hwloc_cpuset_alloc()) == NULL)
      croak("Failed to create temporary cpuset in Sys::Hwloc::Cpuset->not");
    hwloc_cpuset_not(res,set);
    hwloc_cpuset_free(set);
    sv_setref_pv(ST(0), "Sys::Hwloc::Cpuset", (void *)res);

#else
void
and(set,seta)
  hwloc_cpuset_t set
  hwloc_cpuset_t seta
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Cpuset::or     = 2
    Sys::Hwloc::Cpuset::xor    = 3
  PPCODE:
    if(ix == 0)
      hwloc_cpuset_andset(set,seta);
    else if(ix == 2)
      hwloc_cpuset_orset(set,seta);
    else if(ix == 3)
      hwloc_cpuset_xorset(set,seta);
    else
      croak("Should not come here in Sys::Hwloc::Cpuset->and, alias = %d", (int)ix);

#endif
#endif


#if HWLOC_XSAPI_VERSION >= 0x00010100

 # ===================================================================
 # PACKAGE Sys::Hwloc::Bitmap, OO interface of hwloc_bitmap_t
 # ===================================================================

MODULE = Sys::Hwloc                  PACKAGE = Sys::Hwloc::Bitmap

hwloc_bitmap_t
alloc(void)
  PROTOTYPE:
  ALIAS:
    new = 1
  PREINIT:
    hwloc_bitmap_t s = NULL;
  CODE:
    PERL_UNUSED_VAR(ix);
    if((s = hwloc_bitmap_alloc()) == NULL)
      XSRETURN_UNDEF;
    else
      RETVAL = s;
  OUTPUT:
      RETVAL


hwloc_bitmap_t
alloc_full(void)
  PROTOTYPE:
  PREINIT:
    hwloc_bitmap_t s = NULL;
  CODE:
    if((s = hwloc_bitmap_alloc_full()) == NULL)
      XSRETURN_UNDEF;
    else
      RETVAL = s;
  OUTPUT:
      RETVAL


void
copy(map,dst)
  hwloc_bitmap_t map
  hwloc_bitmap_t dst
  PROTOTYPE: $$
  PPCODE:
    hwloc_bitmap_copy(dst,map);


void
and(map,mapa)
  hwloc_bitmap_t map
  hwloc_bitmap_t mapa
  PROTOTYPE: $$
  ALIAS:
    Sys::Hwloc::Bitmap::andnot = 1
    Sys::Hwloc::Bitmap::or     = 2
    Sys::Hwloc::Bitmap::xor    = 3
  PREINIT:
    hwloc_bitmap_t res = NULL;
  PPCODE:
    if((res = hwloc_bitmap_alloc()) == NULL)
      croak("Failed to create temporary bitmap in Sys::Hwloc::Bitmap->and alias %d", (int)ix);
    if(ix == 0)
      hwloc_bitmap_and(res,map,mapa);
    else if(ix == 1)
      hwloc_bitmap_andnot(res,map,mapa);
    else if(ix == 2)
      hwloc_bitmap_or(res,map,mapa);
    else if(ix == 3)
      hwloc_bitmap_xor(res,map,mapa);
    else
      croak("Should not come here in Sys::Hwloc::Bitmap->and, alias = %d", (int)ix);
    hwloc_bitmap_free(map);
    sv_setref_pv(ST(0), "Sys::Hwloc::Bitmap", (void *)res);


void
not(map)
  hwloc_bitmap_t map
  PROTOTYPE: $
  PREINIT:
    hwloc_bitmap_t res = NULL;
  PPCODE:
    if((res = hwloc_bitmap_alloc()) == NULL)
      croak("Failed to create temporary bitmap in Sys::Hwloc::Bitmap->not");
    hwloc_bitmap_not(res,map);
    hwloc_bitmap_free(map);
    sv_setref_pv(ST(0), "Sys::Hwloc::Bitmap", (void *)res);

#endif