Open MPI logo

Portable Hardware Locality (hwloc) Documentation: v1.8

  |   Home   |   Support   |   FAQ   |  
linux-libnuma.h
1 /*
2  * Copyright © 2009 CNRS
3  * Copyright © 2009-2013 Inria. All rights reserved.
4  * Copyright © 2009-2010, 2012 Université Bordeaux 1
5  * See COPYING in top-level directory.
6  */
7 
15 #ifndef HWLOC_LINUX_LIBNUMA_H
16 #define HWLOC_LINUX_LIBNUMA_H
17 
18 #include <hwloc.h>
19 #include <numa.h>
20 
21 
22 #ifdef __cplusplus
23 extern "C" {
24 #endif
25 
26 
57 static __hwloc_inline int
59  unsigned long *mask, unsigned long *maxnode)
60 {
61  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
62  unsigned long outmaxnode = -1;
63 
64  /* round-up to the next ulong and clear all bytes */
65  *maxnode = (*maxnode + 8*sizeof(*mask) - 1) & ~(8*sizeof(*mask) - 1);
66  memset(mask, 0, *maxnode/8);
67 
68  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
69  hwloc_obj_t node = NULL;
70  while ((node = hwloc_get_next_obj_covering_cpuset_by_depth(topology, cpuset, depth, node)) != NULL) {
71  if (node->os_index >= *maxnode)
72  continue;
73  mask[node->os_index/sizeof(*mask)/8] |= 1UL << (node->os_index % (sizeof(*mask)*8));
74  if (outmaxnode == (unsigned long) -1 || outmaxnode < node->os_index)
75  outmaxnode = node->os_index;
76  }
77 
78  } else {
79  /* if no numa, libnuma assumes we have a single node */
80  if (!hwloc_bitmap_iszero(cpuset)) {
81  mask[0] = 1;
82  outmaxnode = 0;
83  }
84  }
85 
86  *maxnode = outmaxnode+1;
87  return 0;
88 }
89 
100 static __hwloc_inline int
102  unsigned long *mask, unsigned long *maxnode)
103 {
104  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
105  unsigned long outmaxnode = -1;
106 
107  /* round-up to the next ulong and clear all bytes */
108  *maxnode = (*maxnode + 8*sizeof(*mask) - 1) & ~(8*sizeof(*mask) - 1);
109  memset(mask, 0, *maxnode/8);
110 
111  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
112  hwloc_obj_t node = NULL;
113  while ((node = hwloc_get_next_obj_by_depth(topology, depth, node)) != NULL) {
114  if (node->os_index >= *maxnode)
115  continue;
116  if (!hwloc_bitmap_isset(nodeset, node->os_index))
117  continue;
118  mask[node->os_index/sizeof(*mask)/8] |= 1UL << (node->os_index % (sizeof(*mask)*8));
119  if (outmaxnode == (unsigned long) -1 || outmaxnode < node->os_index)
120  outmaxnode = node->os_index;
121  }
122 
123  } else {
124  /* if no numa, libnuma assumes we have a single node */
125  if (!hwloc_bitmap_iszero(nodeset)) {
126  mask[0] = 1;
127  outmaxnode = 0;
128  }
129  }
130 
131  *maxnode = outmaxnode+1;
132  return 0;
133 }
134 
144 static __hwloc_inline int
146  const unsigned long *mask, unsigned long maxnode)
147 {
148  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
149 
150  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
151  hwloc_obj_t node = NULL;
152  hwloc_bitmap_zero(cpuset);
153  while ((node = hwloc_get_next_obj_by_depth(topology, depth, node)) != NULL)
154  if (node->os_index < maxnode
155  && (mask[node->os_index/sizeof(*mask)/8] & (1UL << (node->os_index % (sizeof(*mask)*8)))))
156  hwloc_bitmap_or(cpuset, cpuset, node->cpuset);
157  } else {
158  /* if no numa, libnuma assumes we have a single node */
159  if (mask[0] & 1)
161  else
162  hwloc_bitmap_zero(cpuset);
163  }
164 
165  return 0;
166 }
167 
177 static __hwloc_inline int
179  const unsigned long *mask, unsigned long maxnode)
180 {
181  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
182 
183  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
184  hwloc_obj_t node = NULL;
185  hwloc_bitmap_zero(nodeset);
186  while ((node = hwloc_get_next_obj_by_depth(topology, depth, node)) != NULL)
187  if (node->os_index < maxnode
188  && (mask[node->os_index/sizeof(*mask)/8] & (1UL << (node->os_index % (sizeof(*mask)*8)))))
189  hwloc_bitmap_set(nodeset, node->os_index);
190  } else {
191  /* if no numa, libnuma assumes we have a single node */
192  if (mask[0] & 1)
193  hwloc_bitmap_fill(nodeset);
194  else
195  hwloc_bitmap_zero(nodeset);
196  }
197 
198  return 0;
199 }
200 
234 static __hwloc_inline struct bitmask *
235 hwloc_cpuset_to_linux_libnuma_bitmask(hwloc_topology_t topology, hwloc_const_cpuset_t cpuset) __hwloc_attribute_malloc;
236 static __hwloc_inline struct bitmask *
238 {
239  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
240  struct bitmask *bitmask = numa_allocate_cpumask();
241  if (!bitmask)
242  return NULL;
243 
244  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
245  hwloc_obj_t node = NULL;
246  while ((node = hwloc_get_next_obj_covering_cpuset_by_depth(topology, cpuset, depth, node)) != NULL)
247  if (node->memory.local_memory)
248  numa_bitmask_setbit(bitmask, node->os_index);
249  } else {
250  /* if no numa, libnuma assumes we have a single node */
251  if (!hwloc_bitmap_iszero(cpuset))
252  numa_bitmask_setbit(bitmask, 0);
253  }
254 
255  return bitmask;
256 }
257 
267 static __hwloc_inline struct bitmask *
268 hwloc_nodeset_to_linux_libnuma_bitmask(hwloc_topology_t topology, hwloc_const_nodeset_t nodeset) __hwloc_attribute_malloc;
269 static __hwloc_inline struct bitmask *
271 {
272  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
273  struct bitmask *bitmask = numa_allocate_cpumask();
274  if (!bitmask)
275  return NULL;
276 
277  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
278  hwloc_obj_t node = NULL;
279  while ((node = hwloc_get_next_obj_by_depth(topology, depth, node)) != NULL)
280  if (hwloc_bitmap_isset(nodeset, node->os_index) && node->memory.local_memory)
281  numa_bitmask_setbit(bitmask, node->os_index);
282  } else {
283  /* if no numa, libnuma assumes we have a single node */
284  if (!hwloc_bitmap_iszero(nodeset))
285  numa_bitmask_setbit(bitmask, 0);
286  }
287 
288  return bitmask;
289 }
290 
296 static __hwloc_inline int
298  const struct bitmask *bitmask)
299 {
300  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
301 
302  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
303  hwloc_obj_t node = NULL;
304  hwloc_bitmap_zero(cpuset);
305  while ((node = hwloc_get_next_obj_by_depth(topology, depth, node)) != NULL)
306  if (numa_bitmask_isbitset(bitmask, node->os_index))
307  hwloc_bitmap_or(cpuset, cpuset, node->cpuset);
308  } else {
309  /* if no numa, libnuma assumes we have a single node */
310  if (numa_bitmask_isbitset(bitmask, 0))
312  else
313  hwloc_bitmap_zero(cpuset);
314  }
315 
316  return 0;
317 }
318 
324 static __hwloc_inline int
326  const struct bitmask *bitmask)
327 {
328  int depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NODE);
329 
330  if (depth != HWLOC_TYPE_DEPTH_UNKNOWN) {
331  hwloc_obj_t node = NULL;
332  hwloc_bitmap_zero(nodeset);
333  while ((node = hwloc_get_next_obj_by_depth(topology, depth, node)) != NULL)
334  if (numa_bitmask_isbitset(bitmask, node->os_index))
335  hwloc_bitmap_set(nodeset, node->os_index);
336  } else {
337  /* if no numa, libnuma assumes we have a single node */
338  if (numa_bitmask_isbitset(bitmask, 0))
339  hwloc_bitmap_fill(nodeset);
340  else
341  hwloc_bitmap_zero(nodeset);
342  }
343 
344  return 0;
345 }
346 
350 #ifdef __cplusplus
351 } /* extern "C" */
352 #endif
353 
354 
355 #endif /* HWLOC_LINUX_NUMA_H */
static __hwloc_inline int hwloc_cpuset_from_linux_libnuma_ulongs(hwloc_topology_t topology, hwloc_cpuset_t cpuset, const unsigned long *mask, unsigned long maxnode)
Convert the array of unsigned long mask into hwloc CPU set.
Definition: linux-libnuma.h:145
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.
static __hwloc_inline int hwloc_cpuset_to_linux_libnuma_ulongs(hwloc_topology_t topology, hwloc_const_cpuset_t cpuset, unsigned long *mask, unsigned long *maxnode)
Convert hwloc CPU set cpuset into the array of unsigned long mask.
Definition: linux-libnuma.h:58
unsigned os_index
OS-provided physical index number.
Definition: hwloc.h:334
HWLOC_DECLSPEC void hwloc_bitmap_set(hwloc_bitmap_t bitmap, unsigned id)
Add index id in bitmap bitmap.
struct hwloc_obj_memory_s memory
Memory attributes.
Definition: hwloc.h:337
Structure of a topology object.
Definition: hwloc.h:331
static __hwloc_inline struct bitmask * hwloc_nodeset_to_linux_libnuma_bitmask(hwloc_topology_t topology, hwloc_const_nodeset_t nodeset) __hwloc_attribute_malloc
Convert hwloc NUMA node set nodeset into the returned libnuma bitmask.
Definition: linux-libnuma.h:270
HWLOC_DECLSPEC int hwloc_get_type_depth(hwloc_topology_t topology, hwloc_obj_type_t type)
Returns the depth of objects of type type.
HWLOC_DECLSPEC void hwloc_bitmap_copy(hwloc_bitmap_t dst, hwloc_const_bitmap_t src)
Copy the contents of bitmap src into the already allocated bitmap dst.
static __hwloc_inline int hwloc_cpuset_from_linux_libnuma_bitmask(hwloc_topology_t topology, hwloc_cpuset_t cpuset, const struct bitmask *bitmask)
Convert libnuma bitmask bitmask into hwloc CPU set cpuset.
Definition: linux-libnuma.h:297
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
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_uint64_t local_memory
Local memory (in bytes)
Definition: hwloc.h:312
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 struct bitmask * hwloc_cpuset_to_linux_libnuma_bitmask(hwloc_topology_t topology, hwloc_const_cpuset_t cpuset) __hwloc_attribute_malloc
Convert hwloc CPU set cpuset into the returned libnuma bitmask.
Definition: linux-libnuma.h:237
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
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.
hwloc_cpuset_t cpuset
CPUs covered by this object.
Definition: hwloc.h:375
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
No object of given type exists in the topology.
Definition: hwloc.h:1079
hwloc_const_bitmap_t hwloc_const_nodeset_t
A non-modifiable hwloc_nodeset_t.
Definition: hwloc.h:136
static __hwloc_inline int hwloc_nodeset_from_linux_libnuma_bitmask(hwloc_topology_t topology, hwloc_nodeset_t nodeset, const struct bitmask *bitmask)
Convert libnuma bitmask bitmask into hwloc NUMA node set nodeset.
Definition: linux-libnuma.h:325
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...
static __hwloc_inline int hwloc_nodeset_to_linux_libnuma_ulongs(hwloc_topology_t topology, hwloc_const_nodeset_t nodeset, unsigned long *mask, unsigned long *maxnode)
Convert hwloc NUMA node set nodeset into the array of unsigned long mask.
Definition: linux-libnuma.h:101
static __hwloc_inline int hwloc_nodeset_from_linux_libnuma_ulongs(hwloc_topology_t topology, hwloc_nodeset_t nodeset, const unsigned long *mask, unsigned long maxnode)
Convert the array of unsigned long mask into hwloc NUMA node set.
Definition: linux-libnuma.h:178
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.