inthwloc_bitmap_allbut(hwloc_bitmap_tbitmap,unsignedid)
Fill the bitmap and clear the index id.
hwloc_bitmap_thwloc_bitmap_alloc(void)
Allocate a new empty bitmap.
Returns
A valid bitmap or NULL.
The bitmap should be freed by a corresponding call to hwloc_bitmap_free().
hwloc_bitmap_thwloc_bitmap_alloc_full(void)
Allocate a new full bitmap.
Returns
A valid bitmap or NULL.
The bitmap should be freed by a corresponding call to hwloc_bitmap_free().
inthwloc_bitmap_and(hwloc_bitmap_tres,hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
And bitmaps bitmap1 and bitmap2 and store the result in bitmap res. res can be the same as bitmap1 or
bitmap2
inthwloc_bitmap_andnot(hwloc_bitmap_tres,hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
And bitmap bitmap1 and the negation of bitmap2 and store the result in bitmap res. res can be the same as
bitmap1 or bitmap2
inthwloc_bitmap_asprintf(char**strp,hwloc_const_bitmap_tbitmap)
Stringify a bitmap into a newly allocated string in the default hwloc format. NotethatifthebitmapisaCPUornodeset,itcontainsphysicalindexes.
Print the bits set inside a bitmap as a comma-separated list of hexadecimal 32-bit blocks. A bitmap
containing bits 1, 33, 34, and all from 64 to 95 is printed as '0xffffffff,0x00000006,0x00000002'.
Returns
the number of characters that were written (not including the ending \0).
-1 on error, for instance with errno set to ENOMEM on failure to allocate the output string.
inthwloc_bitmap_clr(hwloc_bitmap_tbitmap,unsignedid)
Remove index id from bitmap bitmap.
inthwloc_bitmap_clr_range(hwloc_bitmap_tbitmap,unsignedbegin,intend)
Remove indexes from begin to end in bitmap bitmap. If end is -1, the range is infinite.
inthwloc_bitmap_compare(hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
Compare bitmaps bitmap1 and bitmap2 in lexicographic order. Lexicographic comparison of bitmaps, starting
for their highest indexes. Compare last indexes first, then second, etc. The empty bitmap is considered
lower than anything.
Returns
-1 if bitmap1 is considered smaller than bitmap2.
1 if bitmap1 is considered larger than bitmap2.
0 if bitmaps are equal (contrary to hwloc_bitmap_compare_first()).
For instance comparing binary bitmaps 0011 and 0110 returns -1 (hence 0011 is considered smaller than
0110). Comparing 00101 and 01010 returns -1 too.
Note
This is different from the non-existing hwloc_bitmap_compare_last() which would only compare the
highest index of each bitmap.
inthwloc_bitmap_compare_first(hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
Compare bitmaps bitmap1 and bitmap2 using their lowest index. A bitmap is considered smaller if its least
significant bit is smaller. The empty bitmap is considered higher than anything (because its least
significant bit does not exist).
Returns
-1 if bitmap1 is considered smaller than bitmap2.
1 if bitmap1 is considered larger than bitmap2.
For instance comparing binary bitmaps 0011 and 0110 returns -1 (hence 0011 is considered smaller than
0110) because least significant bit of 0011 (0001) is smaller than least significant bit of 0110 (0010).
Comparing 01001 and 00110 would also return -1 for the same reason.
Returns
0 if bitmaps are considered equal, even if they are not strictly equal. They just need to have the
same least significant bit. For instance, comparing binary bitmaps 0010 and 0110 returns 0 because
they have the same least significant bit.
inthwloc_bitmap_copy(hwloc_bitmap_tdst,hwloc_const_bitmap_tsrc)
Copy the contents of bitmap src into the already allocated bitmap dst.
hwloc_bitmap_thwloc_bitmap_dup(hwloc_const_bitmap_tbitmap)
Duplicate bitmap bitmap by allocating a new bitmap and copying bitmap contents. If bitmap is NULL, NULL
is returned.
voidhwloc_bitmap_fill(hwloc_bitmap_tbitmap)
Fill bitmap bitmap with all possible indexes (even if those objects don't exist or are otherwise
unavailable)
inthwloc_bitmap_first(hwloc_const_bitmap_tbitmap)
Compute the first index (least significant bit) in bitmap bitmap.
Returns
the first index set in bitmap.
-1 if bitmap is empty.
inthwloc_bitmap_first_unset(hwloc_const_bitmap_tbitmap)
Compute the first unset index (least significant bit) in bitmap bitmap.
Returns
the first unset index in bitmap.
-1 if bitmap is full.
voidhwloc_bitmap_free(hwloc_bitmap_tbitmap)
Free bitmap bitmap. If bitmap is NULL, no operation is performed.
inthwloc_bitmap_from_ith_ulong(hwloc_bitmap_tbitmap,unsignedi,unsignedlongmask)
Setup bitmap bitmap from unsigned long mask used as i -th subset.
inthwloc_bitmap_from_ulong(hwloc_bitmap_tbitmap,unsignedlongmask)
Setup bitmap bitmap from unsigned long mask.
inthwloc_bitmap_from_ulongs(hwloc_bitmap_tbitmap,unsignednr,constunsignedlong*masks)
Setup bitmap bitmap from unsigned longs masks used as first nr subsets.
inthwloc_bitmap_intersects(hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
Test whether bitmaps bitmap1 and bitmap2 intersects.
Returns
1 if bitmaps intersect, 0 otherwise.
Note
The empty bitmap does not intersect any other bitmap.
inthwloc_bitmap_isequal(hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
Test whether bitmap bitmap1 is equal to bitmap bitmap2.
Returns
1 if bitmaps are equal, 0 otherwise.
inthwloc_bitmap_isfull(hwloc_const_bitmap_tbitmap)
Test whether bitmap bitmap is completely full.
Returns
1 if bitmap is full, 0 otherwise.
Note
A full bitmap is always infinitely set.
inthwloc_bitmap_isincluded(hwloc_const_bitmap_tsub_bitmap,hwloc_const_bitmap_tsuper_bitmap)
Test whether bitmap sub_bitmap is part of bitmap super_bitmap.
Returns
1 if sub_bitmap is included in super_bitmap, 0 otherwise.
Note
The empty bitmap is considered included in any other bitmap.
inthwloc_bitmap_isset(hwloc_const_bitmap_tbitmap,unsignedid)
Test whether index id is part of bitmap bitmap.
Returns
1 if the bit at index id is set in bitmap bitmap, 0 otherwise.
inthwloc_bitmap_iszero(hwloc_const_bitmap_tbitmap)
Test whether bitmap bitmap is empty.
Returns
1 if bitmap is empty, 0 otherwise.
inthwloc_bitmap_last(hwloc_const_bitmap_tbitmap)
Compute the last index (most significant bit) in bitmap bitmap.
Returns
the last index set in bitmap.
-1 if bitmap is empty, or if bitmap is infinitely set.
inthwloc_bitmap_last_unset(hwloc_const_bitmap_tbitmap)
Compute the last unset index (most significant bit) in bitmap bitmap.
Returns
the last index unset in bitmap.
-1 if bitmap is full, or if bitmap is not infinitely set.
inthwloc_bitmap_list_asprintf(char**strp,hwloc_const_bitmap_tbitmap)
Stringify a bitmap into a newly allocated list string. NotethatifthebitmapisaCPUornodeset,itcontainsphysicalindexes.
Lists are comma-separated indexes or ranges. Ranges are dash separated indexes. A bitmap containing bits
1, 33, 34, and all from 64 to 95 is printed as '1,33-34,64-95'. The last range may not have an ending
index if the bitmap is infinitely set.
Returns
the number of characters that were written (not including the ending \0).
-1 on error, for instance with errno set to ENOMEM on failure to allocate the output string.
inthwloc_bitmap_list_snprintf(char*restrictbuf,size_tbuflen,hwloc_const_bitmap_tbitmap)
Stringify a bitmap in the list format. NotethatifthebitmapisaCPUornodeset,itcontainsphysicalindexes.
Lists are comma-separated indexes or ranges. Ranges are dash separated indexes. A bitmap containing bits
1, 33, 34, and all from 64 to 95 is printed as '1,33-34,64-95'. The last range may not have an ending
index if the bitmap is infinitely set.
Up to buflen characters may be written in buffer buf.
If buflen is 0, buf may safely be NULL.
Returns
the number of characters that were actually written if not truncating, or that would have been
written (not including the ending \0).
-1 on error.
inthwloc_bitmap_list_sscanf(hwloc_bitmap_tbitmap,constchar*restrictstring)
Parse a list string and stores it in bitmap bitmap. NotethatifthebitmapisaCPUornodeset,theinputstringmustcontainphysicalindexes.
Lists are comma-separated indexes or ranges. Ranges are dash separated indexes. String '1,33-34,64-95' is
parsed as a bitmap containing bits 1, 33, 34, and all from 64 to 95. The last range may not have an
ending index if the bitmap is infinitely set.
Returns
0 on success, -1 on error.
inthwloc_bitmap_next(hwloc_const_bitmap_tbitmap,intprev)
Compute the next index in bitmap bitmap which is after index prev.
Returns
the first index set in bitmap if prev is -1.
the next index set in bitmap if prev is not -1.
-1 if no index with higher index is set in bitmap.
inthwloc_bitmap_next_unset(hwloc_const_bitmap_tbitmap,intprev)
Compute the next unset index in bitmap bitmap which is after index prev.
Returns
the first index unset in bitmap if prev is -1.
the next index unset in bitmap if prev is not -1.
-1 if no index with higher index is unset in bitmap.
inthwloc_bitmap_not(hwloc_bitmap_tres,hwloc_const_bitmap_tbitmap)
Negate bitmap bitmap and store the result in bitmap res. res can be the same as bitmap
inthwloc_bitmap_nr_ulongs(hwloc_const_bitmap_tbitmap)
Return the number of unsigned longs required for storing bitmap bitmap entirely. This is the number of
contiguous unsigned longs from the very first bit of the bitmap (even if unset) up to the last set bit.
This is useful for knowing the nr parameter to pass to hwloc_bitmap_to_ulongs() (or which calls to
hwloc_bitmap_to_ith_ulong() are needed) to entirely convert a bitmap into multiple unsigned longs.
When called on the output of hwloc_topology_get_topology_cpuset(), the returned number is large enough
for all cpusets of the topology.
Returns
the number of unsigned longs required.
-1 if bitmap is infinite.
inthwloc_bitmap_only(hwloc_bitmap_tbitmap,unsignedid)
Empty the bitmap bitmap and add bit id.
inthwloc_bitmap_or(hwloc_bitmap_tres,hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
Or bitmaps bitmap1 and bitmap2 and store the result in bitmap res. res can be the same as bitmap1 or
bitmap2
inthwloc_bitmap_set(hwloc_bitmap_tbitmap,unsignedid)
Add index id in bitmap bitmap.
inthwloc_bitmap_set_ith_ulong(hwloc_bitmap_tbitmap,unsignedi,unsignedlongmask)
Replace i -th subset of bitmap bitmap with unsigned long mask.
inthwloc_bitmap_set_range(hwloc_bitmap_tbitmap,unsignedbegin,intend)
Add indexes from begin to end in bitmap bitmap. If end is -1, the range is infinite.
inthwloc_bitmap_singlify(hwloc_bitmap_tbitmap)
Keep a single index among those set in bitmap bitmap. May be useful before binding so that the process
does not have a chance of migrating between multiple processors in the original mask. Instead of running
the task on any PU inside the given CPU set, the operating system scheduler will be forced to run it on a
single of these PUs. It avoids a migration overhead and cache-line ping-pongs between PUs.
Note
This function is NOT meant to distribute multiple processes within a single CPU set. It always return
the same single bit when called multiple times on the same input set. hwloc_distrib() may be used for
generating CPU sets to distribute multiple tasks below a single multi-PU object.
This function cannot be applied to an object set directly. It should be applied to a copy (which may
be obtained with hwloc_bitmap_dup()).
inthwloc_bitmap_snprintf(char*restrictbuf,size_tbuflen,hwloc_const_bitmap_tbitmap)
Stringify a bitmap in the default hwloc format. NotethatifthebitmapisaCPUornodeset,itcontainsphysicalindexes.
Print the bits set inside a bitmap as a comma-separated list of hexadecimal 32-bit blocks. A bitmap
containing bits 1, 33, 34, and all from 64 to 95 is printed as '0xffffffff,0x00000006,0x00000002'.
Up to buflen characters may be written in buffer buf.
If buflen is 0, buf may safely be NULL.
Returns
the number of characters that were actually written if not truncating, or that would have been
written (not including the ending \0).
-1 on error.
inthwloc_bitmap_sscanf(hwloc_bitmap_tbitmap,constchar*restrictstring)
Parse a bitmap string as the default hwloc format and stores it in bitmap bitmap. NotethatifthebitmapisaCPUornodeset,theinputstringmustcontainphysicalindexes.
The input string should be a comma-separared list of hexadecimal 32-bit blocks. String
'0xffffffff,0x6,0x2' is parsed as a bitmap containing all bits between 64 and 95, and bits 33, 34 and 1.
Returns
0 on success, -1 on error.
inthwloc_bitmap_taskset_asprintf(char**strp,hwloc_const_bitmap_tbitmap)
Stringify a bitmap into a newly allocated taskset-specific string. NotethatifthebitmapisaCPUornodeset,itcontainsphysicalindexes.
The taskset program manipulates bitmap strings that contain a single (possible very long) hexadecimal
number starting with 0x. A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as
'0xffffffff0000000600000002'.
Returns
the number of characters that were written (not including the ending \0).
-1 on error, for instance with errno set to ENOMEM on failure to allocate the output string.
inthwloc_bitmap_taskset_snprintf(char*restrictbuf,size_tbuflen,hwloc_const_bitmap_tbitmap)
Stringify a bitmap in the taskset-specific format. NotethatifthebitmapisaCPUornodeset,itcontainsphysicalindexes.
The taskset program manipulates bitmap strings that contain a single (possible very long) hexadecimal
number starting with 0x. A bitmap containing bits 1, 33, 34, and all from 64 to 95 is printed as
'0xffffffff0000000600000002'.
Up to buflen characters may be written in buffer buf.
If buflen is 0, buf may safely be NULL.
Returns
the number of characters that were actually written if not truncating, or that would have been
written (not including the ending \0).
-1 on error.
inthwloc_bitmap_taskset_sscanf(hwloc_bitmap_tbitmap,constchar*restrictstring)
Parse a taskset-specific bitmap string and stores it in bitmap bitmap. NotethatifthebitmapisaCPUornodeset,theinputstringmustcontainphysicalindexes.
The taskset program manipulates bitmap strings that contain a single (possible very long) hexadecimal
number starting with 0x. String '0xffffffff0000000600000002' is parsed as a bitmap containing all bits
between 64 and 95, and bits 33, 34 and 1.
Returns
0 on success, -1 on error.
unsignedlonghwloc_bitmap_to_ith_ulong(hwloc_const_bitmap_tbitmap,unsignedi)
Convert the i -th subset of bitmap bitmap into unsigned long mask.
unsignedlonghwloc_bitmap_to_ulong(hwloc_const_bitmap_tbitmap)
Convert the beginning part of bitmap bitmap into unsigned long mask.
inthwloc_bitmap_to_ulongs(hwloc_const_bitmap_tbitmap,unsignednr,unsignedlong*masks)
Convert the first nr subsets of bitmap bitmap into the array of nr unsigned long masks. nr may be
determined earlier with hwloc_bitmap_nr_ulongs().
Returns
0
inthwloc_bitmap_weight(hwloc_const_bitmap_tbitmap)
Compute the 'weight' of bitmap bitmap (i.e., number of indexes that are in the bitmap).
Returns
the number of indexes that are in the bitmap.
-1 if bitmap is infinitely set.
inthwloc_bitmap_xor(hwloc_bitmap_tres,hwloc_const_bitmap_tbitmap1,hwloc_const_bitmap_tbitmap2)
Xor bitmaps bitmap1 and bitmap2 and store the result in bitmap res. res can be the same as bitmap1 or
bitmap2
voidhwloc_bitmap_zero(hwloc_bitmap_tbitmap)
Empty the bitmap bitmap.
Install Now
