Hardware Locality (hwloc)  1.8
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 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 * restrict objs, int max);
77 
87 static 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 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 inline hwloc_obj_t
125  unsigned depth, unsigned idx) ;
126 static 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 inline hwloc_obj_t
156  hwloc_obj_type_t type, unsigned idx) ;
157 static 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 inline unsigned
174  unsigned depth) ;
175 static 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 inline int
202  hwloc_obj_type_t type) ;
203 static 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 inline int
225  hwloc_obj_t obj) ;
226 static 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 inline hwloc_obj_t
256  hwloc_obj_t parent) ;
257 static 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 inline hwloc_obj_t
282 static 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 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 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 inline hwloc_obj_t
359 static inline hwloc_obj_t
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 inline hwloc_obj_t
373 static 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 inline hwloc_obj_t
385 static inline hwloc_obj_t
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 inline int
411 hwloc_obj_is_in_subtree (hwloc_topology_t topology , hwloc_obj_t obj, hwloc_obj_t subtree_root) ;
412 static inline int
414 {
415  return hwloc_bitmap_isincluded(obj->cpuset, subtree_root->cpuset);
416 }
417 
422 static inline hwloc_obj_t
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 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 inline hwloc_obj_t
498 static 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 inline hwloc_obj_t
516 static inline hwloc_obj_t
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 inline hwloc_obj_t
554 static 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  unsigned hwloc_get_closest_objs (hwloc_topology_t topology, hwloc_obj_t src, hwloc_obj_t * restrict objs, unsigned max);
577 
590 static inline hwloc_obj_t
592  hwloc_obj_type_t type1, unsigned idx1,
593  hwloc_obj_type_t type2, unsigned idx2) ;
594 static 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 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) ;
626 static 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 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 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 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 inline hwloc_const_cpuset_t
725 static inline hwloc_const_cpuset_t
727 {
728  return hwloc_get_root_obj(topology)->complete_cpuset;
729 }
730 
741 static inline hwloc_const_cpuset_t
743 static inline hwloc_const_cpuset_t
745 {
746  return hwloc_get_root_obj(topology)->cpuset;
747 }
748 
758 static inline hwloc_const_cpuset_t
760 static inline hwloc_const_cpuset_t
762 {
763  return hwloc_get_root_obj(topology)->online_cpuset;
764 }
765 
775 static inline hwloc_const_cpuset_t
777 static inline hwloc_const_cpuset_t
779 {
780  return hwloc_get_root_obj(topology)->allowed_cpuset;
781 }
782 
792 static inline hwloc_const_nodeset_t
794 static inline hwloc_const_nodeset_t
796 {
797  return hwloc_get_root_obj(topology)->complete_nodeset;
798 }
799 
810 static inline hwloc_const_nodeset_t
812 static inline hwloc_const_nodeset_t
814 {
815  return hwloc_get_root_obj(topology)->nodeset;
816 }
817 
827 static inline hwloc_const_nodeset_t
829 static inline hwloc_const_nodeset_t
831 {
832  return hwloc_get_root_obj(topology)->allowed_nodeset;
833 }
834 
865 static 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 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 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 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 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 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 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 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 inline hwloc_obj_t
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 inline hwloc_obj_t
1130 {
1131  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_PCI_DEVICE, prev);
1132 }
1133 
1137 static 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 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 inline hwloc_obj_t
1176 {
1177  return hwloc_get_next_obj_by_type(topology, HWLOC_OBJ_OS_DEVICE, prev);
1178 }
1179 
1184 static 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 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 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 */
struct hwloc_obj * parent
Parent, NULL if root (system object)
Definition: hwloc.h:358
hwloc_obj_type_t
Type of topology object.
Definition: hwloc.h:153
static 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 inline hwloc_const_cpuset_t hwloc_topology_get_complete_cpuset(hwloc_topology_t topology)
Get complete CPU set.
Definition: helper.h:726
static 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)
Find an object below another object, both specified by types and indexes.
Definition: helper.h:595
static inline const 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
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:134
static 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
unsigned arity
Number of children.
Definition: hwloc.h:364
static 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
void hwloc_bitmap_fill(hwloc_bitmap_t bitmap)
Fill bitmap bitmap with all possible indexes (even if those objects don't exist or are otherwise unav...
struct hwloc_distances_s ** distances
Distances between all objects at same depth below this object.
Definition: hwloc.h:463
static inline 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:555
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.
void hwloc_bitmap_zero(hwloc_bitmap_t bitmap)
Empty the bitmap bitmap.
static 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
static inline hwloc_const_nodeset_t hwloc_topology_get_topology_nodeset(hwloc_topology_t topology)
Get topology node set.
Definition: helper.h:813
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_isset(hwloc_const_bitmap_t bitmap, unsigned id)
Test whether index id is part of bitmap bitmap.
unsigned depth
Vertical index in the hierarchy. If the topology is symmetric, this is equal to the parent depth plus...
Definition: hwloc.h:344
hwloc_obj_cache_type_t type
Cache type.
Definition: hwloc.h:489
unsigned depth
Depth of cache (e.g., L1, L2, ...etc.)
Definition: hwloc.h:485
hwloc_obj_bridge_type_t downstream_type
Definition: hwloc.h:516
static inline hwloc_const_nodeset_t hwloc_topology_get_allowed_nodeset(hwloc_topology_t topology)
Get allowed node set.
Definition: helper.h:830
struct hwloc_obj_attr_u::hwloc_pcidev_attr_s pcidev
static inline 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:258
unsigned char bus
Definition: hwloc.h:498
static inline hwloc_const_nodeset_t hwloc_topology_get_complete_nodeset(hwloc_topology_t topology)
Get complete node set.
Definition: helper.h:795
unsigned relative_depth
Relative depth of the considered objects below the object containing this distance information...
Definition: hwloc.h:540
int hwloc_bitmap_isequal(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2)
Test whether bitmap bitmap1 is equal to bitmap bitmap2.
struct hwloc_obj_attr_u::hwloc_bridge_attr_s bridge
PCI-side of a bridge.
Definition: hwloc.h:255
static inline 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:204
static 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.
int hwloc_get_type_depth(hwloc_topology_t topology, hwloc_obj_type_t type)
Returns the depth of objects of type type.
hwloc_nodeset_t allowed_nodeset
The set of allowed NUMA memory nodes.
Definition: hwloc.h:450
static inline hwloc_const_cpuset_t hwloc_topology_get_online_cpuset(hwloc_topology_t topology)
Get online CPU set.
Definition: helper.h:761
unsigned char func
Definition: hwloc.h:498
static 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
hwloc_obj_t hwloc_get_obj_by_depth(hwloc_topology_t topology, unsigned depth, unsigned idx)
Returns the topology object at logical index idx from depth depth.
static 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
unsigned nbobjs
Number of objects considered in the matrix. It is the number of descendant objects at relative_depth ...
Definition: hwloc.h:542
static inline const 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
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.
static 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
union hwloc_obj_attr_u * attr
Object type-specific Attributes, may be NULL if no attribute value was found.
Definition: hwloc.h:340
struct hwloc_obj * first_child
First child.
Definition: hwloc.h:366
hwloc_cpuset_t cpuset
CPUs covered by this object.
Definition: hwloc.h:376
hwloc_obj_bridge_type_t upstream_type
Definition: hwloc.h:509
unsigned char dev
Definition: hwloc.h:498
static 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
NUMA node. A set of processors around memory which the processors can directly access.
Definition: hwloc.h:173
float * latency
Matrix of latencies between objects, stored as a one-dimension array. May be NULL if the distances co...
Definition: hwloc.h:547
unsigned short domain
Definition: hwloc.h:497
PCI device. These objects have neither CPU sets nor node sets. They are not added to the topology unl...
Definition: hwloc.h:221
static 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
Processing Unit, or (Logical) Processor. An execution unit (may share a core with some other logical ...
Definition: hwloc.h:188
static 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
void hwloc_bitmap_set(hwloc_bitmap_t bitmap, unsigned id)
Add index id in bitmap bitmap.
hwloc_cpuset_t allowed_cpuset
The CPU set of allowed logical processors.
Definition: hwloc.h:408
union hwloc_obj_attr_u::hwloc_bridge_attr_s::@1 downstream
static inline 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:423
Distances between objects.
Definition: hwloc.h:539
static 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)
Return the idx -th object of type type included in CPU set set.
Definition: helper.h:158
static 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
Objects of given type exist at different depth in the topology.
Definition: hwloc.h:1081
static inline 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:374
static inline 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 lvl1 and lvl2.
Definition: helper.h:386
Unified cache.
Definition: hwloc.h:246
unsigned logical_index
Horizontal index in the whole list of similar objects, could be a "cousin_rank" since it's the rank w...
Definition: hwloc.h:349
static inline unsigned hwloc_get_nbobjs_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, unsigned depth)
Return the number of objects at depth depth included in CPU set set.
Definition: helper.h:176
int hwloc_bitmap_intersects(hwloc_const_bitmap_t bitmap1, hwloc_const_bitmap_t bitmap2)
Test whether bitmaps bitmap1 and bitmap2 intersects.
enum hwloc_obj_cache_type_e hwloc_obj_cache_type_t
Cache type.
hwloc_nodeset_t nodeset
NUMA nodes covered by this object or containing this object.
Definition: hwloc.h:419
static 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
static inline 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.
Operating system device. These objects have neither CPU sets nor node sets. They are not added to the...
Definition: hwloc.h:226
struct hwloc_obj ** children
Children, children[0 .. arity -1].
Definition: hwloc.h:365
static inline 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:1114
static 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
Bridge. Any bridge that connects the host or an I/O bus, to another I/O bus. Bridge objects have neit...
Definition: hwloc.h:214
static inline hwloc_obj_t hwloc_get_root_obj(hwloc_topology_t topology)
Returns the top-object of the topology-tree.
static inline hwloc_obj_t hwloc_get_cache_covering_cpuset(hwloc_topology_t topology, hwloc_const_cpuset_t set)
Get the first cache covering a cpuset set.
Definition: helper.h:499
static inline hwloc_const_cpuset_t hwloc_topology_get_allowed_cpuset(hwloc_topology_t topology)
Get allowed CPU set.
Definition: helper.h:778
static inline 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:627
Host-side of a bridge, only possible upstream.
Definition: hwloc.h:254
struct hwloc_obj * next_sibling
Next object below the same parent.
Definition: hwloc.h:360
hwloc_const_bitmap_t hwloc_const_cpuset_t
A non-modifiable hwloc_cpuset_t.
Definition: hwloc.h:119
static inline 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:413
struct hwloc_obj * next_cousin
Next object of same type and depth.
Definition: hwloc.h:354
static 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
int hwloc_bitmap_iszero(hwloc_const_bitmap_t bitmap)
Test whether bitmap bitmap is empty.
static inline hwloc_const_cpuset_t hwloc_topology_get_topology_cpuset(hwloc_topology_t topology)
Get topology CPU set.
Definition: helper.h:744
hwloc_cpuset_t complete_cpuset
The complete CPU set of logical processors of this object,.
Definition: hwloc.h:389
static inline hwloc_obj_t hwloc_get_obj_inside_cpuset_by_depth(hwloc_topology_t topology, hwloc_const_cpuset_t set, unsigned depth, unsigned idx)
Return the (logically) idx -th object at depth depth included in CPU set set.
Definition: helper.h:127
hwloc_const_bitmap_t hwloc_const_nodeset_t
A non-modifiable hwloc_nodeset_t.
Definition: hwloc.h:137
struct hwloc_obj_attr_u::hwloc_cache_attr_s cache
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).
static 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 online_cpuset
The CPU set of online logical processors.
Definition: hwloc.h:400
static inline hwloc_obj_t hwloc_get_ancestor_obj_by_depth(hwloc_topology_t topology , unsigned depth, hwloc_obj_t obj)
Returns the ancestor object of obj at depth depth.
Definition: helper.h:360
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.
struct hwloc_pcidev_attr_s pci
Definition: hwloc.h:507
unsigned distances_count
Definition: hwloc.h:464
No object of given type exists in the topology.
Definition: hwloc.h:1080
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.
static 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
static inline void hwloc_distribute(hwloc_topology_t topology, hwloc_obj_t root, hwloc_cpuset_t *set, unsigned n, unsigned until)
Definition: helper.h:665
Cache. Can be L1i, L1d, L2, L3, ...
Definition: hwloc.h:181
unsigned os_index
OS-provided physical index number.
Definition: hwloc.h:335
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:117
static inline 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:227
struct hwloc_obj * prev_cousin
Previous object of same type and depth.
Definition: hwloc.h:355
hwloc_nodeset_t complete_nodeset
The complete NUMA node set of this object,.
Definition: hwloc.h:436
static inline int hwloc_bridge_covers_pcibus(hwloc_obj_t bridge, unsigned domain, unsigned bus)
Definition: helper.h:1193
static inline const 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 inline 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:283
struct hwloc_topology * hwloc_topology_t
Topology context.
Definition: hwloc.h:578
static inline hwloc_obj_t hwloc_get_shared_cache_covering_obj(hwloc_topology_t topology , hwloc_obj_t obj)
Get the first cache shared between an object and somebody else.
Definition: helper.h:517
static 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 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.
hwloc_obj_type_t type
Type of object.
Definition: hwloc.h:334
Structure of a topology object.
Definition: hwloc.h:332
static 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