Open MPI logo

Portable Hardware Locality (hwloc) Documentation: v2.0.3

  |   Home   |   Support   |   FAQ   |  
helper.h
1 /*
2  * Copyright © 2009 CNRS
3  * Copyright © 2009-2018 Inria. All rights reserved.
4  * Copyright © 2009-2012 Université Bordeaux
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 
41 static __hwloc_inline hwloc_obj_t
43 {
44  hwloc_obj_t obj = hwloc_get_root_obj(topology);
45  if (!hwloc_bitmap_intersects(obj->cpuset, set))
46  return NULL;
47  while (!hwloc_bitmap_isincluded(obj->cpuset, set)) {
48  /* while the object intersects without being included, look at its children */
49  hwloc_obj_t child = obj->first_child;
50  while (child) {
51  if (hwloc_bitmap_intersects(child->cpuset, set))
52  break;
53  child = child->next_sibling;
54  }
55  if (!child)
56  /* no child intersects, return their father */
57  return obj;
58  /* found one intersecting child, look at its children */
59  obj = child;
60  }
61  /* obj is included, return it */
62  return obj;
63 }
64 
70  hwloc_obj_t * __hwloc_restrict objs, int max);
71 
84 static __hwloc_inline hwloc_obj_t
86  int depth, hwloc_obj_t prev)
87 {
88  hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev);
89  if (!next)
90  return NULL;
91  while (next && (hwloc_bitmap_iszero(next->cpuset) || !hwloc_bitmap_isincluded(next->cpuset, set)))
92  next = next->next_cousin;
93  return next;
94 }
95 
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 
126 static __hwloc_inline hwloc_obj_t
128  int depth, unsigned idx) __hwloc_attribute_pure;
129 static __hwloc_inline hwloc_obj_t
131  int depth, unsigned idx)
132 {
133  hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0);
134  unsigned count = 0;
135  if (!obj)
136  return NULL;
137  while (obj) {
138  if (!hwloc_bitmap_iszero(obj->cpuset) && hwloc_bitmap_isincluded(obj->cpuset, set)) {
139  if (count == idx)
140  return obj;
141  count++;
142  }
143  obj = obj->next_cousin;
144  }
145  return NULL;
146 }
147 
160 static __hwloc_inline hwloc_obj_t
162  hwloc_obj_type_t type, unsigned idx) __hwloc_attribute_pure;
163 static __hwloc_inline hwloc_obj_t
165  hwloc_obj_type_t type, unsigned idx)
166 {
167  int depth = hwloc_get_type_depth(topology, type);
168  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
169  return NULL;
170  return hwloc_get_obj_inside_cpuset_by_depth(topology, set, depth, idx);
171 }
172 
181 static __hwloc_inline unsigned
183  int depth) __hwloc_attribute_pure;
184 static __hwloc_inline unsigned
186  int depth)
187 {
188  hwloc_obj_t obj = hwloc_get_obj_by_depth (topology, depth, 0);
189  unsigned count = 0;
190  if (!obj)
191  return 0;
192  while (obj) {
193  if (!hwloc_bitmap_iszero(obj->cpuset) && hwloc_bitmap_isincluded(obj->cpuset, set))
194  count++;
195  obj = obj->next_cousin;
196  }
197  return count;
198 }
199 
212 static __hwloc_inline int
214  hwloc_obj_type_t type) __hwloc_attribute_pure;
215 static __hwloc_inline int
217  hwloc_obj_type_t type)
218 {
219  int depth = hwloc_get_type_depth(topology, type);
220  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
221  return 0;
222  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE)
223  return -1; /* FIXME: agregate nbobjs from different levels? */
224  return (int) hwloc_get_nbobjs_inside_cpuset_by_depth(topology, set, depth);
225 }
226 
240 static __hwloc_inline int
241 hwloc_get_obj_index_inside_cpuset (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_const_cpuset_t set,
242  hwloc_obj_t obj) __hwloc_attribute_pure;
243 static __hwloc_inline int
245  hwloc_obj_t obj)
246 {
247  int idx = 0;
248  if (!hwloc_bitmap_isincluded(obj->cpuset, set))
249  return -1;
250  /* count how many objects are inside the cpuset on the way from us to the beginning of the level */
251  while ((obj = obj->prev_cousin) != NULL)
252  if (!hwloc_bitmap_iszero(obj->cpuset) && hwloc_bitmap_isincluded(obj->cpuset, set))
253  idx++;
254  return idx;
255 }
256 
271 static __hwloc_inline hwloc_obj_t
272 hwloc_get_child_covering_cpuset (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_const_cpuset_t set,
273  hwloc_obj_t parent) __hwloc_attribute_pure;
274 static __hwloc_inline hwloc_obj_t
276  hwloc_obj_t parent)
277 {
278  hwloc_obj_t child;
279  if (hwloc_bitmap_iszero(set))
280  return NULL;
281  child = parent->first_child;
282  while (child) {
283  if (child->cpuset && hwloc_bitmap_isincluded(set, child->cpuset))
284  return child;
285  child = child->next_sibling;
286  }
287  return NULL;
288 }
289 
294 static __hwloc_inline hwloc_obj_t
295 hwloc_get_obj_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set) __hwloc_attribute_pure;
296 static __hwloc_inline hwloc_obj_t
298 {
299  struct hwloc_obj *current = hwloc_get_root_obj(topology);
300  if (hwloc_bitmap_iszero(set) || !hwloc_bitmap_isincluded(set, current->cpuset))
301  return NULL;
302  while (1) {
303  hwloc_obj_t child = hwloc_get_child_covering_cpuset(topology, set, current);
304  if (!child)
305  return current;
306  current = child;
307  }
308 }
309 
320 static __hwloc_inline hwloc_obj_t
322  int depth, hwloc_obj_t prev)
323 {
324  hwloc_obj_t next = hwloc_get_next_obj_by_depth(topology, depth, prev);
325  if (!next)
326  return NULL;
327  while (next && !hwloc_bitmap_intersects(set, next->cpuset))
328  next = next->next_cousin;
329  return next;
330 }
331 
347 static __hwloc_inline hwloc_obj_t
349  hwloc_obj_type_t type, hwloc_obj_t prev)
350 {
351  int depth = hwloc_get_type_depth(topology, type);
352  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN || depth == HWLOC_TYPE_DEPTH_MULTIPLE)
353  return NULL;
354  return hwloc_get_next_obj_covering_cpuset_by_depth(topology, set, depth, prev);
355 }
356 
377 static __hwloc_inline hwloc_obj_t
378 hwloc_get_ancestor_obj_by_depth (hwloc_topology_t topology __hwloc_attribute_unused, int depth, hwloc_obj_t obj) __hwloc_attribute_pure;
379 static __hwloc_inline hwloc_obj_t
380 hwloc_get_ancestor_obj_by_depth (hwloc_topology_t topology __hwloc_attribute_unused, int depth, hwloc_obj_t obj)
381 {
382  hwloc_obj_t ancestor = obj;
383  if (obj->depth < depth)
384  return NULL;
385  while (ancestor && ancestor->depth > depth)
386  ancestor = ancestor->parent;
387  return ancestor;
388 }
389 
397 static __hwloc_inline hwloc_obj_t
398 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;
399 static __hwloc_inline hwloc_obj_t
400 hwloc_get_ancestor_obj_by_type (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_type_t type, hwloc_obj_t obj)
401 {
402  hwloc_obj_t ancestor = obj->parent;
403  while (ancestor && ancestor->type != type)
404  ancestor = ancestor->parent;
405  return ancestor;
406 }
407 
409 static __hwloc_inline hwloc_obj_t
410 hwloc_get_common_ancestor_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj1, hwloc_obj_t obj2) __hwloc_attribute_pure;
411 static __hwloc_inline hwloc_obj_t
412 hwloc_get_common_ancestor_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj1, hwloc_obj_t obj2)
413 {
414  /* the loop isn't so easy since intermediate ancestors may have
415  * different depth, causing us to alternate between using obj1->parent
416  * and obj2->parent. Also, even if at some point we find ancestors of
417  * of the same depth, their ancestors may have different depth again.
418  */
419  while (obj1 != obj2) {
420  while (obj1->depth > obj2->depth)
421  obj1 = obj1->parent;
422  while (obj2->depth > obj1->depth)
423  obj2 = obj2->parent;
424  if (obj1 != obj2 && obj1->depth == obj2->depth) {
425  obj1 = obj1->parent;
426  obj2 = obj2->parent;
427  }
428  }
429  return obj1;
430 }
431 
437 static __hwloc_inline int
438 hwloc_obj_is_in_subtree (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj, hwloc_obj_t subtree_root) __hwloc_attribute_pure;
439 static __hwloc_inline int
440 hwloc_obj_is_in_subtree (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj, hwloc_obj_t subtree_root)
441 {
442  return obj->cpuset && subtree_root->cpuset && hwloc_bitmap_isincluded(obj->cpuset, subtree_root->cpuset);
443 }
444 
455 static __hwloc_inline hwloc_obj_t
456 hwloc_get_next_child (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t parent, hwloc_obj_t prev)
457 {
458  hwloc_obj_t obj;
459  int state = 0;
460  if (prev) {
461  if (prev->type == HWLOC_OBJ_MISC)
462  state = 3;
463  else if (prev->type == HWLOC_OBJ_BRIDGE || prev->type == HWLOC_OBJ_PCI_DEVICE || prev->type == HWLOC_OBJ_OS_DEVICE)
464  state = 2;
465  else if (prev->type == HWLOC_OBJ_NUMANODE)
466  state = 1;
467  obj = prev->next_sibling;
468  } else {
469  obj = parent->first_child;
470  }
471  if (!obj && state == 0) {
472  obj = parent->memory_first_child;
473  state = 1;
474  }
475  if (!obj && state == 1) {
476  obj = parent->io_first_child;
477  state = 2;
478  }
479  if (!obj && state == 2) {
480  obj = parent->misc_first_child;
481  state = 3;
482  }
483  return obj;
484 }
485 
512 HWLOC_DECLSPEC int
514 
523 HWLOC_DECLSPEC int
525 
534 HWLOC_DECLSPEC int
536 
541 HWLOC_DECLSPEC int
543 
548 HWLOC_DECLSPEC int
550 
555 HWLOC_DECLSPEC int
557 
587 static __hwloc_inline int
589  unsigned cachelevel, hwloc_obj_cache_type_t cachetype)
590 {
591  int depth;
592  int found = HWLOC_TYPE_DEPTH_UNKNOWN;
593  for (depth=0; ; depth++) {
594  hwloc_obj_t obj = hwloc_get_obj_by_depth(topology, depth, 0);
595  if (!obj)
596  break;
597  if (!hwloc_obj_type_is_dcache(obj->type) || obj->attr->cache.depth != cachelevel)
598  /* doesn't match, try next depth */
599  continue;
600  if (cachetype == (hwloc_obj_cache_type_t) -1) {
601  if (found != HWLOC_TYPE_DEPTH_UNKNOWN) {
602  /* second match, return MULTIPLE */
604  }
605  /* first match, mark it as found */
606  found = depth;
607  continue;
608  }
609  if (obj->attr->cache.type == cachetype || obj->attr->cache.type == HWLOC_OBJ_CACHE_UNIFIED)
610  /* exact match (either unified is alone, or we match instruction or data), return immediately */
611  return depth;
612  }
613  /* went to the bottom, return what we found */
614  return found;
615 }
616 
621 static __hwloc_inline hwloc_obj_t
622 hwloc_get_cache_covering_cpuset (hwloc_topology_t topology, hwloc_const_cpuset_t set) __hwloc_attribute_pure;
623 static __hwloc_inline hwloc_obj_t
625 {
626  hwloc_obj_t current = hwloc_get_obj_covering_cpuset(topology, set);
627  while (current) {
628  if (hwloc_obj_type_is_dcache(current->type))
629  return current;
630  current = current->parent;
631  }
632  return NULL;
633 }
634 
639 static __hwloc_inline hwloc_obj_t
640 hwloc_get_shared_cache_covering_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj) __hwloc_attribute_pure;
641 static __hwloc_inline hwloc_obj_t
642 hwloc_get_shared_cache_covering_obj (hwloc_topology_t topology __hwloc_attribute_unused, hwloc_obj_t obj)
643 {
644  hwloc_obj_t current = obj->parent;
645  if (!obj->cpuset)
646  return NULL;
647  while (current) {
648  if (!hwloc_bitmap_isequal(current->cpuset, obj->cpuset)
649  && hwloc_obj_type_is_dcache(current->type))
650  return current;
651  current = current->parent;
652  }
653  return NULL;
654 }
655 
678 static __hwloc_inline hwloc_obj_t
679 hwloc_get_pu_obj_by_os_index(hwloc_topology_t topology, unsigned os_index) __hwloc_attribute_pure;
680 static __hwloc_inline hwloc_obj_t
681 hwloc_get_pu_obj_by_os_index(hwloc_topology_t topology, unsigned os_index)
682 {
683  hwloc_obj_t obj = NULL;
684  while ((obj = hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_PU, obj)) != NULL)
685  if (obj->os_index == os_index)
686  return obj;
687  return NULL;
688 }
689 
699 static __hwloc_inline hwloc_obj_t
700 hwloc_get_numanode_obj_by_os_index(hwloc_topology_t topology, unsigned os_index) __hwloc_attribute_pure;
701 static __hwloc_inline hwloc_obj_t
703 {
704  hwloc_obj_t obj = NULL;
705  while ((obj = hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_NUMANODE, obj)) != NULL)
706  if (obj->os_index == os_index)
707  return obj;
708  return NULL;
709 }
710 
722 /* TODO: rather provide an iterator? Provide a way to know how much should be allocated? By returning the total number of objects instead? */
723 HWLOC_DECLSPEC unsigned hwloc_get_closest_objs (hwloc_topology_t topology, hwloc_obj_t src, hwloc_obj_t * __hwloc_restrict objs, unsigned max);
724 
737 static __hwloc_inline hwloc_obj_t
739  hwloc_obj_type_t type1, unsigned idx1,
740  hwloc_obj_type_t type2, unsigned idx2) __hwloc_attribute_pure;
741 static __hwloc_inline hwloc_obj_t
743  hwloc_obj_type_t type1, unsigned idx1,
744  hwloc_obj_type_t type2, unsigned idx2)
745 {
746  hwloc_obj_t obj;
747  obj = hwloc_get_obj_by_type (topology, type1, idx1);
748  if (!obj)
749  return NULL;
750  return hwloc_get_obj_inside_cpuset_by_type(topology, obj->cpuset, type2, idx2);
751 }
752 
771 static __hwloc_inline hwloc_obj_t
772 hwloc_get_obj_below_array_by_type (hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv) __hwloc_attribute_pure;
773 static __hwloc_inline hwloc_obj_t
774 hwloc_get_obj_below_array_by_type (hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv)
775 {
776  hwloc_obj_t obj = hwloc_get_root_obj(topology);
777  int i;
778  for(i=0; i<nr; i++) {
779  if (!obj)
780  return NULL;
781  obj = hwloc_get_obj_inside_cpuset_by_type(topology, obj->cpuset, typev[i], idxv[i]);
782  }
783  return obj;
784 }
785 
801 };
802 
826 static __hwloc_inline int
828  hwloc_obj_t *roots, unsigned n_roots,
829  hwloc_cpuset_t *set,
830  unsigned n,
831  int until, unsigned long flags)
832 {
833  unsigned i;
834  unsigned tot_weight;
835  unsigned given, givenweight;
836  hwloc_cpuset_t *cpusetp = set;
837 
838  if (flags & ~HWLOC_DISTRIB_FLAG_REVERSE) {
839  errno = EINVAL;
840  return -1;
841  }
842 
843  tot_weight = 0;
844  for (i = 0; i < n_roots; i++)
845  tot_weight += (unsigned) hwloc_bitmap_weight(roots[i]->cpuset);
846 
847  for (i = 0, given = 0, givenweight = 0; i < n_roots; i++) {
848  unsigned chunk, weight;
849  hwloc_obj_t root = roots[flags & HWLOC_DISTRIB_FLAG_REVERSE ? n_roots-1-i : i];
850  hwloc_cpuset_t cpuset = root->cpuset;
851  if (root->type == HWLOC_OBJ_NUMANODE)
852  /* NUMANodes have same cpuset as their parent, but we need normal objects below */
853  root = root->parent;
854  weight = (unsigned) hwloc_bitmap_weight(cpuset);
855  if (!weight)
856  continue;
857  /* Give to root a chunk proportional to its weight.
858  * If previous chunks got rounded-up, we may get a bit less. */
859  chunk = (( (givenweight+weight) * n + tot_weight-1) / tot_weight)
860  - (( givenweight * n + tot_weight-1) / tot_weight);
861  if (!root->arity || chunk <= 1 || root->depth >= until) {
862  /* We can't split any more, put everything there. */
863  if (chunk) {
864  /* Fill cpusets with ours */
865  unsigned j;
866  for (j=0; j < chunk; j++)
867  cpusetp[j] = hwloc_bitmap_dup(cpuset);
868  } else {
869  /* We got no chunk, just merge our cpuset to a previous one
870  * (the first chunk cannot be empty)
871  * so that this root doesn't get ignored.
872  */
873  assert(given);
874  hwloc_bitmap_or(cpusetp[-1], cpusetp[-1], cpuset);
875  }
876  } else {
877  /* Still more to distribute, recurse into children */
878  hwloc_distrib(topology, root->children, root->arity, cpusetp, chunk, until, flags);
879  }
880  cpusetp += chunk;
881  given += chunk;
882  givenweight += weight;
883  }
884 
885  return 0;
886 }
887 
905 HWLOC_DECLSPEC hwloc_const_cpuset_t
906 hwloc_topology_get_complete_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure;
907 
919 HWLOC_DECLSPEC hwloc_const_cpuset_t
920 hwloc_topology_get_topology_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure;
921 
938 HWLOC_DECLSPEC hwloc_const_cpuset_t
939 hwloc_topology_get_allowed_cpuset(hwloc_topology_t topology) __hwloc_attribute_pure;
940 
950 HWLOC_DECLSPEC hwloc_const_nodeset_t
951 hwloc_topology_get_complete_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure;
952 
964 HWLOC_DECLSPEC hwloc_const_nodeset_t
965 hwloc_topology_get_topology_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure;
966 
983 HWLOC_DECLSPEC hwloc_const_nodeset_t
984 hwloc_topology_get_allowed_nodeset(hwloc_topology_t topology) __hwloc_attribute_pure;
985 
1005 static __hwloc_inline int
1007 {
1008  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NUMANODE);
1009  hwloc_obj_t obj = NULL;
1010  assert(depth != HWLOC_TYPE_DEPTH_UNKNOWN);
1011  hwloc_bitmap_zero(nodeset);
1012  while ((obj = hwloc_get_next_obj_covering_cpuset_by_depth(topology, _cpuset, depth, obj)) != NULL)
1013  if (hwloc_bitmap_set(nodeset, obj->os_index) < 0)
1014  return -1;
1015  return 0;
1016 }
1017 
1026 static __hwloc_inline int
1028 {
1029  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NUMANODE);
1030  hwloc_obj_t obj = NULL;
1031  assert(depth != HWLOC_TYPE_DEPTH_UNKNOWN);
1032  hwloc_bitmap_zero(_cpuset);
1033  while ((obj = hwloc_get_next_obj_by_depth(topology, depth, obj)) != NULL) {
1034  if (hwloc_bitmap_isset(nodeset, obj->os_index))
1035  /* no need to check obj->cpuset because objects in levels always have a cpuset */
1036  if (hwloc_bitmap_or(_cpuset, _cpuset, obj->cpuset) < 0)
1037  return -1;
1038  }
1039  return 0;
1040 }
1041 
1061 static __hwloc_inline hwloc_obj_t
1062 hwloc_get_non_io_ancestor_obj(hwloc_topology_t topology __hwloc_attribute_unused,
1063  hwloc_obj_t ioobj)
1064 {
1065  hwloc_obj_t obj = ioobj;
1066  while (obj && !obj->cpuset) {
1067  obj = obj->parent;
1068  }
1069  return obj;
1070 }
1071 
1076 static __hwloc_inline hwloc_obj_t
1078 {
1079  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_PCI_DEVICE, prev);
1080 }
1081 
1085 static __hwloc_inline hwloc_obj_t
1087  unsigned domain, unsigned bus, unsigned dev, unsigned func)
1088 {
1089  hwloc_obj_t obj = NULL;
1090  while ((obj = hwloc_get_next_pcidev(topology, obj)) != NULL) {
1091  if (obj->attr->pcidev.domain == domain
1092  && obj->attr->pcidev.bus == bus
1093  && obj->attr->pcidev.dev == dev
1094  && obj->attr->pcidev.func == func)
1095  return obj;
1096  }
1097  return NULL;
1098 }
1099 
1103 static __hwloc_inline hwloc_obj_t
1105 {
1106  unsigned domain = 0; /* default */
1107  unsigned bus, dev, func;
1108 
1109  if (sscanf(busid, "%x:%x.%x", &bus, &dev, &func) != 3
1110  && sscanf(busid, "%x:%x:%x.%x", &domain, &bus, &dev, &func) != 4) {
1111  errno = EINVAL;
1112  return NULL;
1113  }
1114 
1115  return hwloc_get_pcidev_by_busid(topology, domain, bus, dev, func);
1116 }
1117 
1122 static __hwloc_inline hwloc_obj_t
1124 {
1125  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_OS_DEVICE, prev);
1126 }
1127 
1132 static __hwloc_inline hwloc_obj_t
1134 {
1135  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_BRIDGE, prev);
1136 }
1137 
1138 /* \brief Checks whether a given bridge covers a given PCI bus.
1139  */
1140 static __hwloc_inline int
1142  unsigned domain, unsigned bus)
1143 {
1144  return bridge->type == HWLOC_OBJ_BRIDGE
1146  && bridge->attr->bridge.downstream.pci.domain == domain
1147  && bridge->attr->bridge.downstream.pci.secondary_bus <= bus
1148  && bridge->attr->bridge.downstream.pci.subordinate_bus >= bus;
1149 }
1150 
1155 #ifdef __cplusplus
1156 } /* extern "C" */
1157 #endif
1158 
1159 
1160 #endif /* HWLOC_HELPER_H */
hwloc_const_cpuset_t hwloc_topology_get_complete_cpuset(hwloc_topology_t topology)
Get complete CPU set.
static hwloc_obj_t hwloc_get_next_obj_by_depth(hwloc_topology_t topology, int depth, hwloc_obj_t prev)
Returns the next object at depth depth.
static hwloc_obj_t hwloc_get_shared_cache_covering_obj(hwloc_topology_t topology, hwloc_obj_t obj)
Get the first data (or unified) cache shared between an object and somebody else. ...
Definition: helper.h:642
static hwloc_obj_t hwloc_get_obj_below_array_by_type(hwloc_topology_t topology, int nr, hwloc_obj_type_t *typev, unsigned *idxv)
Find an object below a chain of objects specified by types and indexes.
Definition: helper.h:774
static 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
static 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:1133
int hwloc_get_type_depth(hwloc_topology_t topology, hwloc_obj_type_t type)
Returns the depth of objects of type type.
static hwloc_obj_t hwloc_get_numanode_obj_by_os_index(hwloc_topology_t topology, unsigned os_index)
Returns the object of type HWLOC_OBJ_NUMANODE with os_index.
Definition: helper.h:702
static 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_obj_t hwloc_get_obj_by_type(hwloc_topology_t topology, hwloc_obj_type_t type, unsigned idx)
Returns the topology object at logical index idx with type type.
struct hwloc_obj * parent
Parent, NULL if root (Machine object)
Definition: hwloc.h:407
hwloc_const_nodeset_t hwloc_topology_get_complete_nodeset(hwloc_topology_t topology)
Get complete node set.
int hwloc_bitmap_isequal(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2)
Test whether bitmap bitmap1 is equal to bitmap bitmap2.
Processing Unit, or (Logical) Processor. An execution unit (may share a core with some other logical ...
Definition: hwloc.h:195
struct hwloc_obj_attr_u::hwloc_bridge_attr_s bridge
struct hwloc_topology * hwloc_topology_t
Topology context.
Definition: hwloc.h:636
struct hwloc_obj * misc_first_child
First Misc child. Misc objects are listed here (misc_arity and misc_first_child) instead of in the no...
Definition: hwloc.h:460
unsigned hwloc_get_closest_objs(hwloc_topology_t topology, hwloc_obj_t src, hwloc_obj_t *restrict objs, unsigned max)
Do a depth-first traversal of the topology to find and sort.
int hwloc_bitmap_isincluded(hwloc_const_bitmap_t sub_bitmap, hwloc_const_bitmap_t super_bitmap)
Test whether bitmap sub_bitmap is part of bitmap super_bitmap.
hwloc_const_bitmap_t hwloc_const_cpuset_t
A non-modifiable hwloc_cpuset_t.
Definition: hwloc.h:141
static 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:1086
struct hwloc_obj * prev_cousin
Previous object of same type and depth.
Definition: hwloc.h:404
hwloc_const_cpuset_t hwloc_topology_get_topology_cpuset(hwloc_topology_t topology)
Get topology CPU set.
static 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:1104
static 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:1123
hwloc_bitmap_t hwloc_bitmap_dup(hwloc_const_bitmap_t bitmap)
Duplicate bitmap bitmap by allocating a new bitmap and copying bitmap contents.
int hwloc_bitmap_weight(hwloc_const_bitmap_t bitmap)
Compute the "weight" of bitmap bitmap (i.e., number of indexes that are in the bitmap).
int hwloc_obj_type_is_memory(hwloc_obj_type_t type)
Check whether an object type is I/O.
hwloc_obj_bridge_type_t downstream_type
Definition: hwloc.h:605
static int hwloc_get_nbobjs_inside_cpuset_by_type(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_type_t type)
Return the number of objects of type type included in CPU set set.
Definition: helper.h:216
static hwloc_obj_t hwloc_get_next_obj_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, int depth, hwloc_obj_t prev)
Return the next object at depth depth included in CPU set set.
Definition: helper.h:85
int hwloc_obj_type_is_dcache(hwloc_obj_type_t type)
Check whether an object type is a Data or Unified Cache.
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:156
union hwloc_obj_attr_u::hwloc_bridge_attr_s::@1 downstream
int 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.
int hwloc_obj_type_is_io(hwloc_obj_type_t type)
Check whether an object type is Memory.
static hwloc_obj_t hwloc_get_cache_covering_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set)
Get the first data (or unified) cache covering a cpuset set.
Definition: helper.h:624
int hwloc_obj_type_is_normal(hwloc_obj_type_t type)
Check whether an object type is Normal.
static hwloc_obj_t hwloc_get_obj_covering_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set)
Get the lowest object covering at least CPU set set.
Definition: helper.h:297
struct hwloc_pcidev_attr_s pci
Definition: hwloc.h:596
unsigned char bus
Definition: hwloc.h:587
static 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 level and type.
Definition: helper.h:588
hwloc_const_nodeset_t hwloc_topology_get_topology_nodeset(hwloc_topology_t topology)
Get topology node set.
int hwloc_get_largest_objs_inside_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_t *restrict objs, int max)
Get the set of largest objects covering exactly a given cpuset set.
union hwloc_obj_attr_u * attr
Object type-specific Attributes, may be NULL if no attribute value was found.
Definition: hwloc.h:376
int hwloc_obj_type_is_cache(hwloc_obj_type_t type)
Check whether an object type is a Cache (Data, Unified or Instruction).
unsigned depth
Depth of cache (e.g., L1, L2, ...etc.)
Definition: hwloc.h:571
Objects of given type exist at different depth in the topology (only for Groups). ...
Definition: hwloc.h:767
int hwloc_bitmap_set(hwloc_bitmap_t bitmap, unsigned id)
Add index id in bitmap bitmap.
static int 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:1006
Unified cache.
Definition: hwloc.h:287
static hwloc_obj_t hwloc_get_pu_obj_by_os_index(hwloc_topology_t topology, unsigned os_index)
Returns the object of type HWLOC_OBJ_PU with os_index.
Definition: helper.h:681
hwloc_obj_type_t type
Type of object.
Definition: hwloc.h:359
Bridge (filtered out by default). Any bridge that connects the host or an I/O bus, to another I/O bus. They are not added to the topology unless I/O discovery is enabled with hwloc_topology_set_flags(). I/O objects are not listed in the main children list, but rather in the dedicated io children list. I/O objects have NULL CPU and node sets.
Definition: hwloc.h:247
unsigned os_index
OS-provided physical index number. It is not guaranteed unique across the entire machine, except for PUs and NUMA nodes. Set to HWLOC_UNKNOWN_INDEX if unknown or irrelevant for this object.
Definition: hwloc.h:362
hwloc_obj_t hwloc_get_obj_by_depth(hwloc_topology_t topology, int depth, unsigned idx)
Returns the topology object at logical index idx from depth depth.
Structure of a topology object.
Definition: hwloc.h:357
void hwloc_bitmap_zero(hwloc_bitmap_t bitmap)
Empty the bitmap bitmap.
hwloc_const_cpuset_t hwloc_topology_get_allowed_cpuset(hwloc_topology_t topology)
Get allowed CPU set.
Distrib in reverse order, starting from the last objects.
Definition: helper.h:800
hwloc_obj_cache_type_t type
Cache type.
Definition: hwloc.h:575
hwloc_cpuset_t cpuset
CPUs covered by this object.
Definition: hwloc.h:467
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:139
struct hwloc_obj * first_child
First normal child.
Definition: hwloc.h:418
struct hwloc_obj * memory_first_child
First Memory child. NUMA nodes are listed here (memory_arity and memory_first_child) instead of in th...
Definition: hwloc.h:436
static 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)
Find an object below another object, both specified by types and indexes.
Definition: helper.h:742
static hwloc_obj_t hwloc_get_next_child(hwloc_topology_t topology, hwloc_obj_t parent, hwloc_obj_t prev)
Return the next child.
Definition: helper.h:456
struct hwloc_obj * next_sibling
Next object below the same parent (inside the same list of children).
Definition: hwloc.h:409
Miscellaneous objects (filtered out by default). Objects without particular meaning, that can e.g. be added by the application for its own use, or by hwloc for miscellaneous objects such as MemoryModule (DIMMs). These objects are not listed in the main children list, but rather in the dedicated misc children list. Misc objects may only have Misc objects as children, and those are in the dedicated misc children list as well. Misc objects have NULL CPU and node sets.
Definition: hwloc.h:271
int depth
Vertical index in the hierarchy.
Definition: hwloc.h:380
unsigned short domain
Definition: hwloc.h:586
hwloc_const_nodeset_t hwloc_topology_get_allowed_nodeset(hwloc_topology_t topology)
Get allowed node set.
static 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)
Return the idx -th object of type type included in CPU set set.
Definition: helper.h:164
hwloc_const_bitmap_t hwloc_const_nodeset_t
A non-modifiable hwloc_nodeset_t.
Definition: hwloc.h:159
hwloc_obj_type_t
Definition: hwloc.h:176
unsigned char func
Definition: hwloc.h:587
struct hwloc_obj * io_first_child
First I/O child. Bridges, PCI and OS devices are listed here (io_arity and io_first_child) instead of...
Definition: hwloc.h:448
static int hwloc_obj_is_in_subtree(hwloc_topology_t topology, hwloc_obj_t obj, hwloc_obj_t subtree_root)
Returns true if obj is inside the subtree beginning with ancestor object subtree_root.
Definition: helper.h:440
NUMA node. An object that contains memory that is directly and byte-accessible to the host processors...
Definition: hwloc.h:230
enum hwloc_obj_cache_type_e hwloc_obj_cache_type_t
Cache type.
static hwloc_obj_t hwloc_get_common_ancestor_obj(hwloc_topology_t topology, hwloc_obj_t obj1, hwloc_obj_t obj2)
Returns the common parent object to objects obj1 and obj2.
Definition: helper.h:412
int hwloc_bitmap_intersects(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2)
Test whether bitmaps bitmap1 and bitmap2 intersects.
No object of given type exists in the topology.
Definition: hwloc.h:766
struct hwloc_obj ** children
Normal children, children[0 .. arity -1].
Definition: hwloc.h:417
static hwloc_obj_t hwloc_get_non_io_ancestor_obj(hwloc_topology_t topology, hwloc_obj_t ioobj)
Get the first non-I/O ancestor object.
Definition: helper.h:1062
static hwloc_obj_t hwloc_get_obj_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, int depth, unsigned idx)
Return the (logically) idx -th object at depth depth included in CPU set set.
Definition: helper.h:130
static int hwloc_get_obj_index_inside_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_t obj)
Return the logical index among the objects included in CPU set set.
Definition: helper.h:244
static hwloc_obj_t hwloc_get_next_obj_covering_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, int depth, hwloc_obj_t prev)
Iterate through same-depth objects covering at least CPU set set.
Definition: helper.h:321
static int hwloc_distrib(hwloc_topology_t topology, hwloc_obj_t *roots, unsigned n_roots, hwloc_cpuset_t *set, unsigned n, int until, unsigned long flags)
Distribute n items over the topology under roots.
Definition: helper.h:827
static int 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:1027
static 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:1077
static hwloc_obj_t hwloc_get_root_obj(hwloc_topology_t topology)
Returns the top-object of the topology-tree.
static unsigned hwloc_get_nbobjs_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, int depth)
Return the number of objects at depth depth included in CPU set set.
Definition: helper.h:185
hwloc_distrib_flags_e
Flags to be given to hwloc_distrib().
Definition: helper.h:796
int hwloc_obj_type_is_icache(hwloc_obj_type_t type)
Check whether an object type is a Instruction Cache,.
static hwloc_obj_t hwloc_get_child_covering_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set, hwloc_obj_t parent)
Get the child covering at least CPU set set.
Definition: helper.h:275
PCI-side of a bridge.
Definition: hwloc.h:295
unsigned char dev
Definition: hwloc.h:587
static hwloc_obj_t hwloc_get_ancestor_obj_by_depth(hwloc_topology_t topology, int depth, hwloc_obj_t obj)
Returns the ancestor object of obj at depth depth.
Definition: helper.h:380
Operating system device (filtered out by default). They are not added to the topology unless I/O disc...
Definition: hwloc.h:263
PCI device (filtered out by default). They are not added to the topology unless I/O discovery is enab...
Definition: hwloc.h:256
struct hwloc_obj_attr_u::hwloc_cache_attr_s cache
static int hwloc_bridge_covers_pcibus(hwloc_obj_t bridge, unsigned domain, unsigned bus)
Definition: helper.h:1141
static 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:42
static hwloc_obj_t hwloc_get_ancestor_obj_by_type(hwloc_topology_t topology, hwloc_obj_type_t type, hwloc_obj_t obj)
Returns the ancestor object of obj with type type.
Definition: helper.h:400
static 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:348
struct hwloc_obj * next_cousin
Next object of same type and depth.
Definition: hwloc.h:403
unsigned arity
Number of normal children. Memory, Misc and I/O children are not listed here but rather in their dedi...
Definition: hwloc.h:413
int hwloc_bitmap_isset(hwloc_const_bitmap_t bitmap, unsigned id)
Test whether index id is part of bitmap bitmap.
struct hwloc_obj_attr_u::hwloc_pcidev_attr_s pcidev
int hwloc_bitmap_iszero(hwloc_const_bitmap_t bitmap)
Test whether bitmap bitmap is empty.
hwloc_nodeset_t nodeset
NUMA nodes covered by this object or containing this object.
Definition: hwloc.h:495