Portable Hardware Locality (hwloc) Documentation: v0.9.3
	|   Home   |   Support   |   FAQ   |
About   Presentations   Open MPI Team   FAQ   Videos   Performance  Open MPI Software   Download   Documentation   Source Code Access   Bug Tracking   Regression Testing   Version Information  Sub-Projects   Hardware Locality     Download v2.10 (new)     Download v2.9 (stable)     Download v2.8 (old)     Download ancient     Documentation     Tutorials     Best of lstopo     XML topology database     License     Mailing lists     Bug tracking     Git access     Nightly snapshots   Network Locality   MPI Testing Tool   Open Tool for Parameter Optimization  Community   Mailing Lists   Getting Help/Support   Contribute   Contact   License	helper.h Go to the documentation of this file. /* * Copyright © 2009 CNRS, INRIA, Université Bordeaux 1 * Copyright © 2009 Cisco Systems, Inc. All rights reserved. * See COPYING in top-level directory. */ #ifndef HWLOC_HELPER_H #define HWLOC_HELPER_H #ifndef HWLOC_H #error Please include the main hwloc.h instead #endif #include <stdlib.h> #include <errno.h> static inline unsigned hwloc_get_type_or_below_depth (hwloc_topology_t topology, hwloc_obj_type_t type) { int depth = hwloc_get_type_depth(topology, type); if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) return depth; /* find the highest existing level with type order >= */ for(depth = hwloc_get_type_depth(topology, HWLOC_OBJ_PROC); ; depth--) if (hwloc_compare_types(hwloc_get_depth_type(topology, depth), type) < 0) return depth+1; /* Shouldn't ever happen, as there is always a SYSTEM level with lower order and known depth. */ abort(); } static inline unsigned hwloc_get_type_or_above_depth (hwloc_topology_t topology, hwloc_obj_type_t type) { int depth = hwloc_get_type_depth(topology, type); if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) return depth; /* find the lowest existing level with type order <= */ for(depth = 0; ; depth++) if (hwloc_compare_types(hwloc_get_depth_type(topology, depth), type) > 0) return depth-1; /* Shouldn't ever happen, as there is always a PROC level with higher order and known depth. */ abort(); } static inline hwloc_obj_t hwloc_get_system_obj (hwloc_topology_t topology) { return hwloc_get_obj_by_depth (topology, 0, 0); } static inline hwloc_obj_t hwloc_get_next_obj_by_depth (hwloc_topology_t topology, unsigned depth, hwloc_obj_t prev) { if (!prev) return hwloc_get_obj_by_depth (topology, depth, 0); if (prev->depth != depth) return NULL; return prev->next_cousin; } static inline hwloc_obj_t hwloc_get_next_obj_by_type (hwloc_topology_t topology, hwloc_obj_type_t type, hwloc_obj_t prev) { int depth = hwloc_get_type_depth(topology, type); if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE) return NULL; return hwloc_get_next_obj_by_depth (topology, depth, prev); } static inline hwloc_obj_t hwloc_get_next_child (hwloc_topology_t topology, hwloc_obj_t father, hwloc_obj_t prev) { if (!prev) return father->first_child; if (prev->father != father) return NULL; return prev->next_sibling; } static inline hwloc_obj_t hwloc_get_common_ancestor_obj (hwloc_topology_t topology, hwloc_obj_t obj1, hwloc_obj_t obj2) { while (obj1->depth > obj2->depth) obj1 = obj1->father; while (obj2->depth > obj1->depth) obj2 = obj2->father; while (obj1 != obj2) { obj1 = obj1->father; obj2 = obj2->father; } return obj1; } static inline int hwloc_obj_is_in_subtree (hwloc_topology_t topology, hwloc_obj_t obj, hwloc_obj_t subtree_root) { return hwloc_cpuset_isincluded(obj->cpuset, subtree_root->cpuset); } extern int hwloc_get_largest_objs_inside_cpuset (hwloc_topology_t topology, hwloc_cpuset_t set, hwloc_obj_t * restrict objs, int max); static inline hwloc_obj_t hwloc_get_next_obj_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_cpuset_t set, unsigned depth, hwloc_obj_t prev) { hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev); while (next && !hwloc_cpuset_isincluded(next->cpuset, set)) next = next->next_cousin; return next; } static inline hwloc_obj_t hwloc_get_next_obj_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_cpuset_t set, hwloc_obj_type_t type, hwloc_obj_t prev) { int depth = hwloc_get_type_depth(topology, type); if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE) return NULL; return hwloc_get_next_obj_inside_cpuset_by_depth(topology, set, depth, prev); } static inline hwloc_obj_t hwloc_get_obj_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_cpuset_t set, unsigned depth, unsigned idx) { int count = 0; hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0); while (obj) { if (hwloc_cpuset_isincluded(obj->cpuset, set)) { if (count == idx) return obj; count++; } obj = obj->next_cousin; } return NULL; } static inline hwloc_obj_t hwloc_get_obj_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_cpuset_t set, hwloc_obj_type_t type, unsigned idx) { int depth = hwloc_get_type_depth(topology, type); if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE) return NULL; return hwloc_get_obj_inside_cpuset_by_depth(topology, set, depth, idx); } static inline unsigned hwloc_get_nbobjs_inside_cpuset_by_depth (hwloc_topology_t topology, hwloc_cpuset_t set, unsigned depth) { hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0); int count = 0; while (obj) { if (hwloc_cpuset_isincluded(obj->cpuset, set)) count++; obj = obj->next_cousin; } return count; } static inline int hwloc_get_nbobjs_inside_cpuset_by_type (hwloc_topology_t topology, hwloc_cpuset_t set, 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_inside_cpuset_by_depth(topology, set, depth); } static inline hwloc_obj_t hwloc_get_child_covering_cpuset (hwloc_topology_t topology, hwloc_cpuset_t set, hwloc_obj_t father) { hwloc_obj_t child = father->first_child; while (child) { if (hwloc_cpuset_isincluded(set, child->cpuset)) return child; child = child->next_sibling; } return NULL; } static inline hwloc_obj_t hwloc_get_obj_covering_cpuset (hwloc_topology_t topology, hwloc_cpuset_t set) { struct hwloc_obj *current = hwloc_get_system_obj(topology); if (!hwloc_cpuset_isincluded(set, current->cpuset)) return NULL; while (1) { hwloc_obj_t child = hwloc_get_child_covering_cpuset(topology, set, current); if (!child) return current; current = child; } } static inline hwloc_obj_t hwloc_get_next_obj_covering_cpuset_by_depth(hwloc_topology_t topology, hwloc_cpuset_t set, unsigned depth, hwloc_obj_t prev) { hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev); while (next && !hwloc_cpuset_intersects(set, next->cpuset)) next = next->next_cousin; return next; } static inline hwloc_obj_t hwloc_get_next_obj_covering_cpuset_by_type(hwloc_topology_t topology, hwloc_cpuset_t set, hwloc_obj_type_t type, hwloc_obj_t prev) { int depth = hwloc_get_type_depth(topology, type); if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE) return NULL; return hwloc_get_next_obj_covering_cpuset_by_depth(topology, set, depth, prev); } static inline hwloc_obj_t hwloc_get_cache_covering_cpuset (hwloc_topology_t topology, hwloc_cpuset_t set) { hwloc_obj_t current = hwloc_get_obj_covering_cpuset(topology, set); while (current) { if (current->type == HWLOC_OBJ_CACHE) return current; current = current->father; } return NULL; } static inline hwloc_obj_t hwloc_get_shared_cache_covering_obj (hwloc_topology_t topology, hwloc_obj_t obj) { hwloc_obj_t current = obj->father; while (current) { if (!hwloc_cpuset_isequal(current->cpuset, obj->cpuset) && current->type == HWLOC_OBJ_CACHE) return current; current = current->father; } return NULL; } /* TODO: rather provide an iterator? Provide a way to know how much should be allocated? By returning the total number of objects instead? */ extern int hwloc_get_closest_objs (hwloc_topology_t topology, hwloc_obj_t src, hwloc_obj_t * restrict objs, int max); static inline void hwloc_distribute(hwloc_topology_t topology, hwloc_obj_t root, hwloc_cpuset_t *cpuset, int n) { int i; int chunk_size, complete_chunks; hwloc_cpuset_t *cpusetp; if (!root->arity || n == 1) { /* Got to the bottom, we can't split any more, put everything there. */ for (i=0; i<n; i++) cpuset[i] = hwloc_cpuset_dup(root->cpuset); return; } /* Divide n in root->arity chunks. */ chunk_size = (n + root->arity - 1) / root->arity; complete_chunks = n % root->arity; if (!complete_chunks) complete_chunks = root->arity; /* Allocate complete chunks first. */ for (cpusetp = cpuset, i = 0; i < complete_chunks; i ++, cpusetp += chunk_size) hwloc_distribute(topology, root->children[i], cpusetp, chunk_size); /* Now allocate not-so-complete chunks. */ for ( ; i < root->arity; i++, cpusetp += chunk_size-1) hwloc_distribute(topology, root->children[i], cpusetp, chunk_size-1); } #endif /* HWLOC_HELPER_H */
Open MPI is an Associated Project of the Software in the Public Interest non-profit organization Page last modified: 11-Nov-2020 ©2004-2024 The Open MPI Project