Open MPI logo

Portable Hardware Locality (hwloc) Documentation: v1.8

  |   Home   |   Support   |   FAQ   |  
helper.h
1 /*
2  * Copyright © 2009 CNRS
3  * Copyright © 2009-2013 Inria. All rights reserved.
4  * Copyright © 2009-2012 Université Bordeaux 1
5  * Copyright © 2009-2010 Cisco Systems, Inc. All rights reserved.
6  * See COPYING in top-level directory.
7  */
8 
13 #ifndef HWLOC_HELPER_H
14 #define HWLOC_HELPER_H
15 
16 #ifndef HWLOC_H
17 #error Please include the main hwloc.h instead
18 #endif
19 
20 #include <stdlib.h>
21 #include <errno.h>
22 
23 
24 #ifdef __cplusplus
25 extern "C" {
26 #endif
27 
28 
44 static __hwloc_inline hwloc_obj_t
46 {
47  hwloc_obj_t obj = hwloc_get_root_obj(topology);
48  if (!obj->cpuset || !hwloc_bitmap_intersects(obj->cpuset, set))
49  return NULL;
50  while (!hwloc_bitmap_isincluded(obj->cpuset, set)) {
51  /* while the object intersects without being included, look at its children */
52  hwloc_obj_t child = obj->first_child;
53  while (child) {
54  if (child->cpuset && hwloc_bitmap_intersects(child->cpuset, set))
55  break;
56  child = child->next_sibling;
57  }
58  if (!child)
59  /* no child intersects, return their father */
60  return obj;
61  /* found one intersecting child, look at its children */
62  obj = child;
63  }
64  /* obj is included, return it */
65  return obj;
66 }
67 
76  hwloc_obj_t * __hwloc_restrict objs, int max);
77 
87 static __hwloc_inline hwloc_obj_t
89  unsigned depth, hwloc_obj_t prev)
90 {
91  hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev);
92  if (!next || !next->cpuset)
93  return NULL;
94  while (next && !hwloc_bitmap_isincluded(next->cpuset, set))
95  next = next->next_cousin;
96  return next;
97 }
98 
108 static __hwloc_inline hwloc_obj_t
110  hwloc_obj_type_t type, hwloc_obj_t prev)
111 {
112  int depth = hwloc_get_type_depth(topology, type);
113  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
114  return NULL;
115  return hwloc_get_next_obj_inside_cpuset_by_depth(topology, set, depth, prev);
116 }
117 
123 static __hwloc_inline hwloc_obj_t
125  unsigned depth, unsigned idx) __hwloc_attribute_pure;
126 static __hwloc_inline hwloc_obj_t
128  unsigned depth, unsigned idx)
129 {
130  hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0);
131  unsigned count = 0;
132  if (!obj || !obj->cpuset)
133  return NULL;
134  while (obj) {
135  if (hwloc_bitmap_isincluded(obj->cpuset, set)) {
136  if (count == idx)
137  return obj;
138  count++;
139  }
140  obj = obj->next_cousin;
141  }
142  return NULL;
143 }
144 
154 static __hwloc_inline hwloc_obj_t
156  hwloc_obj_type_t type, unsigned idx) __hwloc_attribute_pure;
157 static __hwloc_inline hwloc_obj_t
159  hwloc_obj_type_t type, unsigned idx)
160 {
161  int depth = hwloc_get_type_depth(topology, type);
162  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
163  return NULL;
164  return hwloc_get_obj_inside_cpuset_by_depth(topology, set, depth, idx);
165 }
166 
172 static __hwloc_inline unsigned
174  unsigned depth) __hwloc_attribute_pure;
175 static __hwloc_inline unsigned
177  unsigned depth)
178 {
179  hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0);
180  unsigned count = 0;
181  if (!obj || !obj->cpuset)
182  return 0;
183  while (obj) {
184  if (hwloc_bitmap_isincluded(obj->cpuset, set))
185  count++;
186  obj = obj->next_cousin;
187  }
188  return count;
189 }
190 
200 static __hwloc_inline int
202  hwloc_obj_type_t type) __hwloc_attribute_pure;
203 static __hwloc_inline int
205  hwloc_obj_type_t type)
206 {
207  int depth = hwloc_get_type_depth(topology, type);
208  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
209  return 0;
210  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE)
211  return -1; /* FIXME: agregate nbobjs from different levels? */
212  return hwloc_get_nbobjs_inside_cpuset_by_depth(topology, set, depth);
213 }
214 
223 static __hwloc_inline int
224 hwloc_get_obj_index_inside_cpuset (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_const_cpuset_t set,
225  hwloc_obj_t obj) __hwloc_attribute_pure;
226 static __hwloc_inline int
228  hwloc_obj_t obj)
229 {
230  int idx = 0;
231  if (!hwloc_bitmap_isincluded(obj->cpuset, set))
232  return -1;
233  /* count how many objects are inside the cpuset on the way from us to the beginning of the level */
234  while ((obj = obj->prev_cousin) != NULL)
235  if (hwloc_bitmap_isincluded(obj->cpuset, set))
236  idx++;
237  return idx;
238 }
239 
254 static __hwloc_inline hwloc_obj_t
255 hwloc_get_child_covering_cpuset (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_const_cpuset_t set,
256  hwloc_obj_t parent) __hwloc_attribute_pure;
257 static __hwloc_inline hwloc_obj_t
259  hwloc_obj_t parent)
260 {
261  hwloc_obj_t child;
262  if (!parent->cpuset || hwloc_bitmap_iszero(set))
263  return NULL;
264  child = parent->first_child;
265  while (child) {
266  if (child->cpuset && hwloc_bitmap_isincluded(set, child->cpuset))
267  return child;
268  child = child->next_sibling;
269  }
270  return NULL;
271 }
272 
280 static __hwloc_inline hwloc_obj_t
281 hwloc_get_obj_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set) __hwloc_attribute_pure;
282 static __hwloc_inline hwloc_obj_t
284 {
285  struct hwloc_obj *current = hwloc_get_root_obj(topology);
286  if (hwloc_bitmap_iszero(set) || !current->cpuset || !hwloc_bitmap_isincluded(set, current->cpuset))
287  return NULL;
288  while (1) {
289  hwloc_obj_t child = hwloc_get_child_covering_cpuset(topology, set, current);
290  if (!child)
291  return current;
292  current = child;
293  }
294 }
295 
306 static __hwloc_inline hwloc_obj_t
308  unsigned depth, hwloc_obj_t prev)
309 {
310  hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev);
311  if (!next || !next->cpuset)
312  return NULL;
313  while (next && !hwloc_bitmap_intersects(set, next->cpuset))
314  next = next->next_cousin;
315  return next;
316 }
317 
333 static __hwloc_inline hwloc_obj_t
336 {
337  int depth = hwloc_get_type_depth(topology, type);
338  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
339  return NULL;
340  return hwloc_get_next_obj_covering_cpuset_by_depth(topology, set, depth, prev);
341 }
342 
357 static __hwloc_inline hwloc_obj_t
358 hwloc_get_ancestor_obj_by_depth (hwloc_topology_t topology __hwloc_attribute_unused, unsigned depth, hwloc_obj_t obj) __hwloc_attribute_pure;
359 static __hwloc_inline hwloc_obj_t
360 hwloc_get_ancestor_obj_by_depth (hwloc_topology_t topology __hwloc_attribute_unused, unsigned depth, hwloc_obj_t obj)
361 {
362  hwloc_obj_t ancestor = obj;
363  if (obj->depth < depth)
364  return NULL;
365  while (ancestor && ancestor->depth > depth)
366  ancestor = ancestor->parent;
367  return ancestor;
368 }
369 
371 static __hwloc_inline hwloc_obj_t
372 hwloc_get_ancestor_obj_by_type (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_type_t type, hwloc_obj_t obj) __hwloc_attribute_pure;
373 static __hwloc_inline hwloc_obj_t
375 {
376  hwloc_obj_t ancestor = obj->parent;
377  while (ancestor && ancestor->type != type)
378  ancestor = ancestor->parent;
379  return ancestor;
380 }
381 
383 static __hwloc_inline hwloc_obj_t
384 hwloc_get_common_ancestor_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj1, hwloc_obj_t obj2) __hwloc_attribute_pure;
385 static __hwloc_inline hwloc_obj_t
386 hwloc_get_common_ancestor_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj1, hwloc_obj_t obj2)
387 {
388  /* the loop isn't so easy since intermediate ancestors may have
389  * different depth, causing us to alternate between using obj1->parent
390  * and obj2->parent. Also, even if at some point we find ancestors of
391  * of the same depth, their ancestors may have different depth again.
392  */
393  while (obj1 != obj2) {
394  while (obj1->depth > obj2->depth)
395  obj1 = obj1->parent;
396  while (obj2->depth > obj1->depth)
397  obj2 = obj2->parent;
398  if (obj1 != obj2 && obj1->depth == obj2->depth) {
399  obj1 = obj1->parent;
400  obj2 = obj2->parent;
401  }
402  }
403  return obj1;
404 }
405 
410 static __hwloc_inline int
411 hwloc_obj_is_in_subtree (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj, hwloc_obj_t subtree_root) __hwloc_attribute_pure;
412 static __hwloc_inline int
413 hwloc_obj_is_in_subtree (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj, hwloc_obj_t subtree_root)
414 {
415  return hwloc_bitmap_isincluded(obj->cpuset, subtree_root->cpuset);
416 }
417 
422 static __hwloc_inline hwloc_obj_t
423 hwloc_get_next_child (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t parent, hwloc_obj_t prev)
424 {
425  if (!prev)
426  return parent->first_child;
427  if (prev->parent != parent)
428  return NULL;
429  return prev->next_sibling;
430 }
431 
459 static __hwloc_inline int
461  unsigned cachelevel, hwloc_obj_cache_type_t cachetype)
462 {
463  int depth;
464  int found = HWLOC_TYPE_DEPTH_UNKNOWN;
465  for (depth=0; ; depth++) {
466  hwloc_obj_t obj = hwloc_get_obj_by_depth(topology, depth, 0);
467  if (!obj)
468  break;
469  if (obj->type != HWLOC_OBJ_CACHE || obj->attr->cache.depth != cachelevel)
470  /* doesn't match, try next depth */
471  continue;
472  if (cachetype == (hwloc_obj_cache_type_t) -1) {
473  if (found != HWLOC_TYPE_DEPTH_UNKNOWN) {
474  /* second match, return MULTIPLE */
476  }
477  /* first match, mark it as found */
478  found = depth;
479  continue;
480  }
481  if (obj->attr->cache.type == cachetype || obj->attr->cache.type == HWLOC_OBJ_CACHE_UNIFIED)
482  /* exact match (either unified is alone, or we match instruction or data), return immediately */
483  return depth;
484  }
485  /* went to the bottom, return what we found */
486  return found;
487 }
488 
496 static __hwloc_inline hwloc_obj_t
497 hwloc_get_cache_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set) __hwloc_attribute_pure;
498 static __hwloc_inline hwloc_obj_t
500 {
501  hwloc_obj_t current = hwloc_get_obj_covering_cpuset(topology, set);
502  while (current) {
503  if (current->type == HWLOC_OBJ_CACHE)
504  return current;
505  current = current->parent;
506  }
507  return NULL;
508 }
509 
514 static __hwloc_inline hwloc_obj_t
515 hwloc_get_shared_cache_covering_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj) __hwloc_attribute_pure;
516 static __hwloc_inline hwloc_obj_t
517 hwloc_get_shared_cache_covering_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj)
518 {
519  hwloc_obj_t current = obj->parent;
520  if (!obj->cpuset)
521  return NULL;
522  while (current && current->cpuset) {
523  if (!hwloc_bitmap_isequal(current->cpuset, obj->cpuset)
524  && current->type == HWLOC_OBJ_CACHE)
525  return current;
526  current = current->parent;
527  }
528  return NULL;
529 }
530 
552 static __hwloc_inline hwloc_obj_t
553 hwloc_get_pu_obj_by_os_index(hwloc_topology_t topology, unsigned os_index) __hwloc_attribute_pure;
554 static __hwloc_inline hwloc_obj_t
556 {
557  hwloc_obj_t obj = NULL;
558  while ((obj = hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_PU, obj)) != NULL)
559  if (obj->os_index == os_index)
560  return obj;
561  return NULL;
562 }
563 
575 /* TODO: rather provide an iterator? Provide a way to know how much should be allocated? By returning the total number of objects instead? */
576 HWLOC_DECLSPEC unsigned hwloc_get_closest_objs (hwloc_topology_t topology, hwloc_obj_t src, hwloc_obj_t * __hwloc_restrict objs, unsigned max);
577 
590 static __hwloc_inline hwloc_obj_t
592  hwloc_obj_type_t type1, unsigned idx1,
593  hwloc_obj_type_t type2, unsigned idx2) __hwloc_attribute_pure;
594 static __hwloc_inline hwloc_obj_t
596  hwloc_obj_type_t type1, unsigned idx1,
597  hwloc_obj_type_t type2, unsigned idx2)
598 {
599  hwloc_obj_t obj;
600  obj = hwloc_get_obj_by_type (topology, type1, idx1);
601  if (!obj || !obj->cpuset)
602  return NULL;
603  return hwloc_get_obj_inside_cpuset_by_type(topology, obj->cpuset, type2, idx2);
604 }
605 
624 static __hwloc_inline hwloc_obj_t
625 hwloc_get_obj_below_array_by_type (hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv) __hwloc_attribute_pure;
626 static __hwloc_inline hwloc_obj_t
627 hwloc_get_obj_below_array_by_type (hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv)
628 {
629  hwloc_obj_t obj = hwloc_get_root_obj(topology);
630  int i;
631  for(i=0; i<nr; i++) {
632  if (!obj || !obj->cpuset)
633  return NULL;
634  obj = hwloc_get_obj_inside_cpuset_by_type(topology, obj->cpuset, typev[i], idxv[i]);
635  }
636  return obj;
637 }
638 
662 static __hwloc_inline void
663 hwloc_distributev(hwloc_topology_t topology, hwloc_obj_t *root, unsigned n_roots, hwloc_cpuset_t *cpuset, unsigned n, unsigned until);
664 static __hwloc_inline void
665 hwloc_distribute(hwloc_topology_t topology, hwloc_obj_t root, hwloc_cpuset_t *set, unsigned n, unsigned until)
666 {
667  unsigned i;
668  if (!root->arity || n == 1 || root->depth >= until) {
669  /* Got to the bottom, we can't split any more, put everything there. */
670  for (i=0; i<n; i++)
671  set[i] = hwloc_bitmap_dup(root->cpuset);
672  return;
673  }
674  hwloc_distributev(topology, root->children, root->arity, set, n, until);
675 }
676 
684 static __hwloc_inline void
685 hwloc_distributev(hwloc_topology_t topology, hwloc_obj_t *roots, unsigned n_roots, hwloc_cpuset_t *set, unsigned n, unsigned until)
686 {
687  unsigned i;
688  unsigned tot_weight;
689  hwloc_cpuset_t *cpusetp = set;
690 
691  tot_weight = 0;
692  for (i = 0; i < n_roots; i++)
693  if (roots[i]->cpuset)
694  tot_weight += hwloc_bitmap_weight(roots[i]->cpuset);
695 
696  for (i = 0; i < n_roots && tot_weight; i++) {
697  /* Give to roots[i] a portion proportional to its weight */
698  unsigned weight = roots[i]->cpuset ? hwloc_bitmap_weight(roots[i]->cpuset) : 0;
699  unsigned chunk = (n * weight + tot_weight-1) / tot_weight;
700  hwloc_distribute(topology, roots[i], cpusetp, chunk, until);
701  cpusetp += chunk;
702  tot_weight -= weight;
703  n -= chunk;
704  }
705 }
706 
723 static __hwloc_inline hwloc_const_cpuset_t
724 hwloc_topology_get_complete_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure;
725 static __hwloc_inline hwloc_const_cpuset_t
727 {
728  return hwloc_get_root_obj(topology)->complete_cpuset;
729 }
730 
741 static __hwloc_inline hwloc_const_cpuset_t
742 hwloc_topology_get_topology_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure;
743 static __hwloc_inline hwloc_const_cpuset_t
745 {
746  return hwloc_get_root_obj(topology)->cpuset;
747 }
748 
758 static __hwloc_inline hwloc_const_cpuset_t
759 hwloc_topology_get_online_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure;
760 static __hwloc_inline hwloc_const_cpuset_t
762 {
763  return hwloc_get_root_obj(topology)->online_cpuset;
764 }
765 
775 static __hwloc_inline hwloc_const_cpuset_t
776 hwloc_topology_get_allowed_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure;
777 static __hwloc_inline hwloc_const_cpuset_t
779 {
780  return hwloc_get_root_obj(topology)->allowed_cpuset;
781 }
782 
792 static __hwloc_inline hwloc_const_nodeset_t
793 hwloc_topology_get_complete_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure;
794 static __hwloc_inline hwloc_const_nodeset_t
796 {
797  return hwloc_get_root_obj(topology)->complete_nodeset;
798 }
799 
810 static __hwloc_inline hwloc_const_nodeset_t
811 hwloc_topology_get_topology_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure;
812 static __hwloc_inline hwloc_const_nodeset_t
814 {
815  return hwloc_get_root_obj(topology)->nodeset;
816 }
817 
827 static __hwloc_inline hwloc_const_nodeset_t
828 hwloc_topology_get_allowed_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure;
829 static __hwloc_inline hwloc_const_nodeset_t
831 {
832  return hwloc_get_root_obj(topology)->allowed_nodeset;
833 }
834 
865 static __hwloc_inline void
867 {
868  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
869  hwloc_obj_t obj;
870 
871  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN) {
872  if (hwloc_bitmap_iszero(_cpuset))
873  hwloc_bitmap_zero(nodeset);
874  else
875  /* Assume the whole system */
876  hwloc_bitmap_fill(nodeset);
877  return;
878  }
879 
880  hwloc_bitmap_zero(nodeset);
881  obj = NULL;
882  while ((obj = hwloc_get_next_obj_covering_cpuset_by_depth(topology, _cpuset, depth, obj)) != NULL)
883  hwloc_bitmap_set(nodeset, obj->os_index);
884 }
885 
893 static __hwloc_inline void
895 {
896  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
897  hwloc_obj_t obj;
898  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN )
899  return;
900  hwloc_bitmap_zero(nodeset);
901  obj = NULL;
902  while ((obj = hwloc_get_next_obj_covering_cpuset_by_depth(topology, _cpuset, depth, obj)) != NULL)
903  hwloc_bitmap_set(nodeset, obj->os_index);
904 }
905 
914 static __hwloc_inline void
916 {
917  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
918  hwloc_obj_t obj;
919 
920  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN ) {
921  if (hwloc_bitmap_iszero(nodeset))
922  hwloc_bitmap_zero(_cpuset);
923  else
924  /* Assume the whole system */
925  hwloc_bitmap_fill(_cpuset);
926  return;
927  }
928 
929  hwloc_bitmap_zero(_cpuset);
930  obj = NULL;
931  while ((obj = hwloc_get_next_obj_by_depth(topology, depth, obj)) != NULL) {
932  if (hwloc_bitmap_isset(nodeset, obj->os_index))
933  /* no need to check obj->cpuset because objects in levels always have a cpuset */
934  hwloc_bitmap_or(_cpuset, _cpuset, obj->cpuset);
935  }
936 }
937 
945 static __hwloc_inline void
947 {
948  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
949  hwloc_obj_t obj;
950  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN )
951  return;
952  hwloc_bitmap_zero(_cpuset);
953  obj = NULL;
954  while ((obj = hwloc_get_next_obj_by_depth(topology, depth, obj)) != NULL)
955  if (hwloc_bitmap_isset(nodeset, obj->os_index))
956  /* no need to check obj->cpuset because objects in levels always have a cpuset */
957  hwloc_bitmap_or(_cpuset, _cpuset, obj->cpuset);
958 }
959 
987 static __hwloc_inline const struct hwloc_distances_s *
989 {
990  hwloc_obj_t root = hwloc_get_root_obj(topology);
991  unsigned i;
992  for(i=0; i<root->distances_count; i++)
993  if (root->distances[i]->relative_depth == depth)
994  return root->distances[i];
995  return NULL;
996 }
997 
1017 static __hwloc_inline const struct hwloc_distances_s *
1019 {
1020  int depth = hwloc_get_type_depth(topology, type);
1021  if (depth < 0)
1022  return NULL;
1023  return hwloc_get_whole_distance_matrix_by_depth(topology, depth);
1024 }
1025 
1039 static __hwloc_inline const struct hwloc_distances_s *
1041  hwloc_obj_t obj, unsigned depth,
1042  unsigned *firstp)
1043 {
1044  while (obj && obj->cpuset) {
1045  unsigned i;
1046  for(i=0; i<obj->distances_count; i++)
1047  if (obj->distances[i]->relative_depth == depth - obj->depth) {
1048  if (!obj->distances[i]->nbobjs)
1049  continue;
1050  *firstp = hwloc_get_next_obj_inside_cpuset_by_depth(topology, obj->cpuset, depth, NULL)->logical_index;
1051  return obj->distances[i];
1052  }
1053  obj = obj->parent;
1054  }
1055  return NULL;
1056 }
1057 
1069 static __hwloc_inline int
1071  hwloc_obj_t obj1, hwloc_obj_t obj2,
1072  float *latency, float *reverse_latency)
1073 {
1074  hwloc_obj_t ancestor;
1075  const struct hwloc_distances_s * distances;
1076  unsigned first_logical ;
1077 
1078  if (obj1->depth != obj2->depth) {
1079  errno = EINVAL;
1080  return -1;
1081  }
1082 
1083  ancestor = hwloc_get_common_ancestor_obj(topology, obj1, obj2);
1084  distances = hwloc_get_distance_matrix_covering_obj_by_depth(topology, ancestor, obj1->depth, &first_logical);
1085  if (distances && distances->latency) {
1086  const float * latency_matrix = distances->latency;
1087  unsigned nbobjs = distances->nbobjs;
1088  unsigned l1 = obj1->logical_index - first_logical;
1089  unsigned l2 = obj2->logical_index - first_logical;
1090  *latency = latency_matrix[l1*nbobjs+l2];
1091  *reverse_latency = latency_matrix[l2*nbobjs+l1];
1092  return 0;
1093  }
1094 
1095  errno = ENOSYS;
1096  return -1;
1097 }
1098 
1113 static __hwloc_inline hwloc_obj_t
1114 hwloc_get_non_io_ancestor_obj(hwloc_topology_t topology __hwloc_attribute_unused,
1115  hwloc_obj_t ioobj)
1116 {
1117  hwloc_obj_t obj = ioobj;
1118  while (obj && !obj->cpuset) {
1119  obj = obj->parent;
1120  }
1121  return obj;
1122 }
1123 
1128 static __hwloc_inline hwloc_obj_t
1130 {
1131  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_PCI_DEVICE, prev);
1132 }
1133 
1137 static __hwloc_inline hwloc_obj_t
1139  unsigned domain, unsigned bus, unsigned dev, unsigned func)
1140 {
1141  hwloc_obj_t obj = NULL;
1142  while ((obj = hwloc_get_next_pcidev(topology, obj)) != NULL) {
1143  if (obj->attr->pcidev.domain == domain
1144  && obj->attr->pcidev.bus == bus
1145  && obj->attr->pcidev.dev == dev
1146  && obj->attr->pcidev.func == func)
1147  return obj;
1148  }
1149  return NULL;
1150 }
1151 
1155 static __hwloc_inline hwloc_obj_t
1157 {
1158  unsigned domain = 0; /* default */
1159  unsigned bus, dev, func;
1160 
1161  if (sscanf(busid, "%x:%x.%x", &bus, &dev, &func) != 3
1162  && sscanf(busid, "%x:%x:%x.%x", &domain, &bus, &dev, &func) != 4) {
1163  errno = EINVAL;
1164  return NULL;
1165  }
1166 
1167  return hwloc_get_pcidev_by_busid(topology, domain, bus, dev, func);
1168 }
1169 
1174 static __hwloc_inline hwloc_obj_t
1176 {
1177  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_OS_DEVICE, prev);
1178 }
1179 
1184 static __hwloc_inline hwloc_obj_t
1186 {
1187  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_BRIDGE, prev);
1188 }
1189 
1190 /* \brief Checks whether a given bridge covers a given PCI bus.
1191  */
1192 static __hwloc_inline int
1194  unsigned domain, unsigned bus)
1195 {
1196  return bridge->type == HWLOC_OBJ_BRIDGE
1198  && bridge->attr->bridge.downstream.pci.domain == domain
1199  && bridge->attr->bridge.downstream.pci.secondary_bus <= bus
1200  && bridge->attr->bridge.downstream.pci.subordinate_bus >= bus;
1201 }
1202 
1208 static __hwloc_inline hwloc_obj_t
1210  unsigned domain, unsigned bus)
1211 {
1212  hwloc_obj_t obj = NULL;
1213  while ((obj = hwloc_get_next_bridge(topology, obj)) != NULL) {
1214  if (hwloc_bridge_covers_pcibus(obj, domain, bus)) {
1215  /* found bridge covering this pcibus, make sure it's a hostbridge */
1217  assert(obj->parent->type != HWLOC_OBJ_BRIDGE);
1218  assert(obj->parent->cpuset);
1219  return obj;
1220  }
1221  }
1222  return NULL;
1223 }
1224 
1229 #ifdef __cplusplus
1230 } /* extern "C" */
1231 #endif
1232 
1233 
1234 #endif /* HWLOC_HELPER_H */
static __hwloc_inline hwloc_obj_t hwloc_get_ancestor_obj_by_type(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_type_t type, hwloc_obj_t obj) __hwloc_attribute_pure
Returns the ancestor object of obj with type type.
Definition: helper.h:374
struct hwloc_obj_attr_u::hwloc_bridge_attr_s bridge
static __hwloc_inline struct hwloc_distances_s * hwloc_get_distance_matrix_covering_obj_by_depth(hwloc_topology_t topology, hwloc_obj_t obj, unsigned depth, unsigned *firstp)
Get distances for the given depth and covering some objects.
Definition: helper.h:1040
static __hwloc_inline hwloc_const_cpuset_t hwloc_topology_get_online_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure
Get online CPU set.
Definition: helper.h:761
HWLOC_DECLSPEC void hwloc_bitmap_or(hwloc_bitmap_t res, hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2)
Or bitmaps bitmap1 and bitmap2 and store the result in bitmap res.
Processing Unit, or (Logical) Processor. An execution unit (may share a core with some other logical ...
Definition: hwloc.h:187
static __hwloc_inline hwloc_obj_t hwloc_get_pu_obj_by_os_index(hwloc_topology_t topology, unsigned os_index) __hwloc_attribute_pure
Returns the object of type HWLOC_OBJ_PU with os_index.
Definition: helper.h:555
hwloc_obj_type_t
Type of topology object.
Definition: hwloc.h:152
static __hwloc_inline int hwloc_get_nbobjs_inside_cpuset_by_type(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_type_t type) __hwloc_attribute_pure
Return the number of objects of type type included in CPU set set.
Definition: helper.h:204
static __hwloc_inline hwloc_obj_t hwloc_get_pcidev_by_busidstring(hwloc_topology_t topology, const char *busid)
Find the PCI device object matching the PCI bus id given as a string xxxx:yy:zz.t or yy:zz...
Definition: helper.h:1156
static __hwloc_inline hwloc_obj_t hwloc_get_next_obj_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, unsigned depth, hwloc_obj_t prev)
Return the next object at depth depth included in CPU set set.
Definition: helper.h:88
static __hwloc_inline hwloc_obj_t hwloc_get_next_obj_covering_cpuset_by_type(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_type_t type, hwloc_obj_t prev)
Iterate through same-type objects covering at least CPU set set.
Definition: helper.h:334
HWLOC_DECLSPEC int hwloc_bitmap_isincluded(hwloc_const_bitmap_t sub_bitmap, hwloc_const_bitmap_t super_bitmap) __hwloc_attribute_pure
Test whether bitmap sub_bitmap is part of bitmap super_bitmap.
static __hwloc_inline struct hwloc_distances_s * hwloc_get_whole_distance_matrix_by_type(hwloc_topology_t topology, hwloc_obj_type_t type)
Get the distances between all objects of a given type.
Definition: helper.h:1018
struct hwloc_obj * prev_cousin
Previous object of same type and depth.
Definition: hwloc.h:354
unsigned distances_count
Definition: hwloc.h:463
Operating system device. These objects have neither CPU sets nor node sets. They are not added to the...
Definition: hwloc.h:225
HWLOC_DECLSPEC int hwloc_bitmap_isequal(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2) __hwloc_attribute_pure
Test whether bitmap bitmap1 is equal to bitmap bitmap2.
struct hwloc_obj_attr_u::hwloc_cache_attr_s cache
unsigned os_index
OS-provided physical index number.
Definition: hwloc.h:334
static __hwloc_inline hwloc_const_nodeset_t hwloc_topology_get_complete_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure
Get complete node set.
Definition: helper.h:795
static __hwloc_inline hwloc_obj_t hwloc_get_ancestor_obj_by_depth(hwloc_topology_t topology __hwloc_attribute_unused, unsigned depth, hwloc_obj_t obj) __hwloc_attribute_pure
Returns the ancestor object of obj at depth depth.
Definition: helper.h:360
static __hwloc_inline hwloc_obj_t hwloc_get_next_child(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t parent, hwloc_obj_t prev)
Return the next child.
Definition: helper.h:423
unsigned logical_index
Horizontal index in the whole list of similar objects, could be a &quot;cousin_rank&quot; since it&#39;s the rank...
Definition: hwloc.h:348
unsigned nbobjs
Number of objects considered in the matrix. It is the number of descendant objects at relative_depth ...
Definition: hwloc.h:541
unsigned depth
Vertical index in the hierarchy. If the topology is symmetric, this is equal to the parent depth plus...
Definition: hwloc.h:343
HWLOC_DECLSPEC void hwloc_bitmap_set(hwloc_bitmap_t bitmap, unsigned id)
Add index id in bitmap bitmap.
static __hwloc_inline hwloc_obj_t hwloc_get_child_covering_cpuset(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_const_cpuset_t set, hwloc_obj_t parent) __hwloc_attribute_pure
Get the child covering at least CPU set set.
Definition: helper.h:258
struct hwloc_obj * parent
Parent, NULL if root (system object)
Definition: hwloc.h:357
PCI-side of a bridge.
Definition: hwloc.h:254
hwloc_nodeset_t allowed_nodeset
The set of allowed NUMA memory nodes.
Definition: hwloc.h:449
static __hwloc_inline void hwloc_cpuset_from_nodeset(hwloc_topology_t topology, hwloc_cpuset_t _cpuset, hwloc_const_nodeset_t nodeset)
Convert a NUMA node set into a CPU set and handle non-NUMA cases.
Definition: helper.h:915
Structure of a topology object.
Definition: hwloc.h:331
float * latency
Matrix of latencies between objects, stored as a one-dimension array. May be NULL if the distances co...
Definition: hwloc.h:546
static __hwloc_inline unsigned hwloc_get_nbobjs_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, unsigned depth) __hwloc_attribute_pure
Return the number of objects at depth depth included in CPU set set.
Definition: helper.h:176
HWLOC_DECLSPEC int hwloc_bitmap_intersects(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2) __hwloc_attribute_pure
Test whether bitmaps bitmap1 and bitmap2 intersects.
static __hwloc_inline int hwloc_get_obj_index_inside_cpuset(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_const_cpuset_t set, hwloc_obj_t obj) __hwloc_attribute_pure
Return the logical index among the objects included in CPU set set.
Definition: helper.h:227
static __hwloc_inline void hwloc_cpuset_to_nodeset(hwloc_topology_t topology, hwloc_const_cpuset_t _cpuset, hwloc_nodeset_t nodeset)
Convert a CPU set into a NUMA node set and handle non-NUMA cases.
Definition: helper.h:866
HWLOC_DECLSPEC int hwloc_get_type_depth(hwloc_topology_t topology, hwloc_obj_type_t type)
Returns the depth of objects of type type.
static __hwloc_inline int hwloc_get_latency(hwloc_topology_t topology, hwloc_obj_t obj1, hwloc_obj_t obj2, float *latency, float *reverse_latency)
Get the latency in both directions between two objects.
Definition: helper.h:1070
struct hwloc_distances_s ** distances
Distances between all objects at same depth below this object.
Definition: hwloc.h:462
static __hwloc_inline hwloc_obj_t hwloc_get_hostbridge_by_pcibus(hwloc_topology_t topology, unsigned domain, unsigned bus)
Find the hostbridge that covers the given PCI bus.
Definition: helper.h:1209
Objects of given type exist at different depth in the topology.
Definition: hwloc.h:1080
unsigned relative_depth
Relative depth of the considered objects below the object containing this distance information...
Definition: hwloc.h:539
hwloc_obj_cache_type_t type
Cache type.
Definition: hwloc.h:488
static __hwloc_inline hwloc_obj_t hwloc_get_next_obj_covering_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, unsigned depth, hwloc_obj_t prev)
Iterate through same-depth objects covering at least CPU set set.
Definition: helper.h:307
Distances between objects.
Definition: hwloc.h:538
static __hwloc_inline hwloc_obj_t hwloc_get_next_pcidev(hwloc_topology_t topology, hwloc_obj_t prev)
Get the next PCI device in the system.
Definition: helper.h:1129
static __hwloc_inline hwloc_obj_t hwloc_get_obj_inside_cpuset_by_type(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_type_t type, unsigned idx) __hwloc_attribute_pure
Return the idx -th object of type type included in CPU set set.
Definition: helper.h:158
static __hwloc_inline hwloc_obj_t hwloc_get_common_ancestor_obj(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj1, hwloc_obj_t obj2) __hwloc_attribute_pure
Returns the common parent object to objects lvl1 and lvl2.
Definition: helper.h:386
static __hwloc_inline void hwloc_cpuset_from_nodeset_strict(struct hwloc_topology *topology, hwloc_cpuset_t _cpuset, hwloc_const_nodeset_t nodeset)
Convert a NUMA node set into a CPU set without handling non-NUMA cases.
Definition: helper.h:946
hwloc_cpuset_t complete_cpuset
The complete CPU set of logical processors of this object,.
Definition: hwloc.h:388
static __hwloc_inline hwloc_const_cpuset_t hwloc_topology_get_complete_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure
Get complete CPU set.
Definition: helper.h:726
HWLOC_DECLSPEC unsigned hwloc_get_closest_objs(hwloc_topology_t topology, hwloc_obj_t src, hwloc_obj_t *__hwloc_restrict objs, unsigned max)
Do a depth-first traversal of the topology to find and sort.
static __hwloc_inline hwloc_obj_t hwloc_get_root_obj(hwloc_topology_t topology) __hwloc_attribute_pure
Returns the top-object of the topology-tree.
HWLOC_DECLSPEC int hwloc_bitmap_weight(hwloc_const_bitmap_t bitmap) __hwloc_attribute_pure
Compute the &quot;weight&quot; of bitmap bitmap (i.e., number of indexes that are in the bitmap).
static __hwloc_inline hwloc_obj_t hwloc_get_next_obj_by_type(hwloc_topology_t topology, hwloc_obj_type_t type, hwloc_obj_t prev)
Returns the next object of type type.
static __hwloc_inline struct hwloc_distances_s * hwloc_get_whole_distance_matrix_by_depth(hwloc_topology_t topology, unsigned depth)
Get the distances between all objects at the given depth.
Definition: helper.h:988
static __hwloc_inline hwloc_obj_t hwloc_get_obj_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, unsigned depth, unsigned idx) __hwloc_attribute_pure
Return the (logically) idx -th object at depth depth included in CPU set set.
Definition: helper.h:127
struct hwloc_obj * first_child
First child.
Definition: hwloc.h:365
hwloc_obj_bridge_type_t downstream_type
Definition: hwloc.h:515
NUMA node. A set of processors around memory which the processors can directly access.
Definition: hwloc.h:172
hwloc_const_bitmap_t hwloc_const_cpuset_t
A non-modifiable hwloc_cpuset_t.
Definition: hwloc.h:118
static __hwloc_inline hwloc_obj_t hwloc_get_obj_below_by_type(hwloc_topology_t topology, hwloc_obj_type_t type1, unsigned idx1, hwloc_obj_type_t type2, unsigned idx2) __hwloc_attribute_pure
Find an object below another object, both specified by types and indexes.
Definition: helper.h:595
unsigned depth
Depth of cache (e.g., L1, L2, ...etc.)
Definition: hwloc.h:484
HWLOC_DECLSPEC hwloc_obj_t hwloc_get_obj_by_depth(hwloc_topology_t topology, unsigned depth, unsigned idx) __hwloc_attribute_pure
Returns the topology object at logical index idx from depth depth.
hwloc_obj_type_t type
Type of object.
Definition: hwloc.h:333
static __hwloc_inline void hwloc_distribute(hwloc_topology_t topology, hwloc_obj_t root, hwloc_cpuset_t *set, unsigned n, unsigned until)
Definition: helper.h:665
static __hwloc_inline hwloc_const_cpuset_t hwloc_topology_get_topology_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure
Get topology CPU set.
Definition: helper.h:744
hwloc_bitmap_t hwloc_nodeset_t
A node set is a bitmap whose bits are set according to NUMA memory node physical OS indexes...
Definition: hwloc.h:133
static __hwloc_inline hwloc_obj_t hwloc_get_next_osdev(hwloc_topology_t topology, hwloc_obj_t prev)
Get the next OS device in the system.
Definition: helper.h:1175
HWLOC_DECLSPEC int hwloc_bitmap_isset(hwloc_const_bitmap_t bitmap, unsigned id) __hwloc_attribute_pure
Test whether index id is part of bitmap bitmap.
Host-side of a bridge, only possible upstream.
Definition: hwloc.h:253
struct hwloc_obj * next_cousin
Next object of same type and depth.
Definition: hwloc.h:353
hwloc_nodeset_t complete_nodeset
The complete NUMA node set of this object,.
Definition: hwloc.h:435
static __hwloc_inline hwloc_obj_t hwloc_get_obj_covering_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set) __hwloc_attribute_pure
Get the lowest object covering at least CPU set set.
Definition: helper.h:283
hwloc_cpuset_t allowed_cpuset
The CPU set of allowed logical processors.
Definition: hwloc.h:407
hwloc_nodeset_t nodeset
NUMA nodes covered by this object or containing this object.
Definition: hwloc.h:418
unsigned short domain
Definition: hwloc.h:496
union hwloc_obj_attr_u * attr
Object type-specific Attributes, may be NULL if no attribute value was found.
Definition: hwloc.h:339
Cache. Can be L1i, L1d, L2, L3, ...
Definition: hwloc.h:180
hwloc_cpuset_t cpuset
CPUs covered by this object.
Definition: hwloc.h:375
static __hwloc_inline hwloc_obj_t hwloc_get_non_io_ancestor_obj(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t ioobj)
Get the first non-I/O ancestor object.
Definition: helper.h:1114
struct hwloc_obj * next_sibling
Next object below the same parent.
Definition: hwloc.h:359
static __hwloc_inline hwloc_const_nodeset_t hwloc_topology_get_allowed_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure
Get allowed node set.
Definition: helper.h:830
static __hwloc_inline int hwloc_obj_is_in_subtree(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj, hwloc_obj_t subtree_root) __hwloc_attribute_pure
Returns true if obj is inside the subtree beginning with ancestor object subtree_root.
Definition: helper.h:413
struct hwloc_obj_attr_u::hwloc_pcidev_attr_s pcidev
static __hwloc_inline hwloc_obj_t hwloc_get_pcidev_by_busid(hwloc_topology_t topology, unsigned domain, unsigned bus, unsigned dev, unsigned func)
Find the PCI device object matching the PCI bus id given domain, bus device and function PCI bus id...
Definition: helper.h:1138
static __hwloc_inline hwloc_obj_t hwloc_get_shared_cache_covering_obj(hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj) __hwloc_attribute_pure
Get the first cache shared between an object and somebody else.
Definition: helper.h:517
static __hwloc_inline hwloc_obj_t hwloc_get_cache_covering_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set) __hwloc_attribute_pure
Get the first cache covering a cpuset set.
Definition: helper.h:499
static __hwloc_inline hwloc_const_nodeset_t hwloc_topology_get_topology_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure
Get topology node set.
Definition: helper.h:813
HWLOC_DECLSPEC int hwloc_bitmap_iszero(hwloc_const_bitmap_t bitmap) __hwloc_attribute_pure
Test whether bitmap bitmap is empty.
struct hwloc_topology * hwloc_topology_t
Topology context.
Definition: hwloc.h:577
hwloc_cpuset_t online_cpuset
The CPU set of online logical processors.
Definition: hwloc.h:399
No object of given type exists in the topology.
Definition: hwloc.h:1079
PCI device. These objects have neither CPU sets nor node sets. They are not added to the topology unl...
Definition: hwloc.h:220
static __hwloc_inline hwloc_obj_t hwloc_get_next_bridge(hwloc_topology_t topology, hwloc_obj_t prev)
Get the next bridge in the system.
Definition: helper.h:1185
enum hwloc_obj_cache_type_e hwloc_obj_cache_type_t
Cache type.
hwloc_const_bitmap_t hwloc_const_nodeset_t
A non-modifiable hwloc_nodeset_t.
Definition: hwloc.h:136
Unified cache.
Definition: hwloc.h:245
union hwloc_obj_attr_u::hwloc_bridge_attr_s::@1 downstream
static __hwloc_inline int hwloc_bridge_covers_pcibus(hwloc_obj_t bridge, unsigned domain, unsigned bus)
Definition: helper.h:1193
struct hwloc_pcidev_attr_s pci
Definition: hwloc.h:506
static __hwloc_inline hwloc_obj_t hwloc_get_first_largest_obj_inside_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set)
Get the first largest object included in the given cpuset set.
Definition: helper.h:45
unsigned char bus
Definition: hwloc.h:497
static __hwloc_inline void hwloc_cpuset_to_nodeset_strict(struct hwloc_topology *topology, hwloc_const_cpuset_t _cpuset, hwloc_nodeset_t nodeset)
Convert a CPU set into a NUMA node set without handling non-NUMA cases.
Definition: helper.h:894
static __hwloc_inline hwloc_obj_t hwloc_get_next_obj_inside_cpuset_by_type(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_type_t type, hwloc_obj_t prev)
Return the next object of type type included in CPU set set.
Definition: helper.h:109
Bridge. Any bridge that connects the host or an I/O bus, to another I/O bus. Bridge objects have neit...
Definition: hwloc.h:213
HWLOC_DECLSPEC void hwloc_bitmap_fill(hwloc_bitmap_t bitmap)
Fill bitmap bitmap with all possible indexes (even if those objects don&#39;t exist or are otherwise unav...
unsigned arity
Number of children.
Definition: hwloc.h:363
static __hwloc_inline void hwloc_distributev(hwloc_topology_t topology, hwloc_obj_t *root, unsigned n_roots, hwloc_cpuset_t *cpuset, unsigned n, unsigned until)
Distribute n items over the topology under root.
Definition: helper.h:685
static __hwloc_inline int hwloc_get_cache_type_depth(hwloc_topology_t topology, unsigned cachelevel, hwloc_obj_cache_type_t cachetype)
Find the depth of cache objects matching cache depth and type.
Definition: helper.h:460
hwloc_obj_bridge_type_t upstream_type
Definition: hwloc.h:508
struct hwloc_obj ** children
Children, children[0 .. arity -1].
Definition: hwloc.h:364
unsigned char func
Definition: hwloc.h:497
static __hwloc_inline hwloc_obj_t hwloc_get_obj_below_array_by_type(hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv) __hwloc_attribute_pure
Find an object below a chain of objects specified by types and indexes.
Definition: helper.h:627
HWLOC_DECLSPEC hwloc_bitmap_t hwloc_bitmap_dup(hwloc_const_bitmap_t bitmap) __hwloc_attribute_malloc
Duplicate bitmap bitmap by allocating a new bitmap and copying bitmap contents.
HWLOC_DECLSPEC int hwloc_get_largest_objs_inside_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_t *__hwloc_restrict objs, int max)
Get the set of largest objects covering exactly a given cpuset set.
hwloc_bitmap_t hwloc_cpuset_t
A CPU set is a bitmap whose bits are set according to CPU physical OS indexes.
Definition: hwloc.h:116
HWLOC_DECLSPEC void hwloc_bitmap_zero(hwloc_bitmap_t bitmap)
Empty the bitmap bitmap.
static __hwloc_inline hwloc_obj_t hwloc_get_next_obj_by_depth(hwloc_topology_t topology, unsigned depth, hwloc_obj_t prev)
Returns the next object at depth depth.
static __hwloc_inline hwloc_obj_t hwloc_get_obj_by_type(hwloc_topology_t topology, hwloc_obj_type_t type, unsigned idx) __hwloc_attribute_pure
Returns the topology object at logical index idx with type type.
unsigned char dev
Definition: hwloc.h:497
static __hwloc_inline hwloc_const_cpuset_t hwloc_topology_get_allowed_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure
Get allowed CPU set.
Definition: helper.h:778