---
name: "Slurm::Bitstr"
section: "3pm"
platform: "linux"
package: "libslurm-perl"
version: "24.11.5-4"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Slurm::Bitstr"
---

# Slurm::Bitstr(3pm)

Bitstring functions in libslurm

## NAME

Slurm::Bitstr - Bitstring functions in libslurm

## SYNOPSIS

```
 use Slurm;
 $bitmap = Slurm::Bitstr::alloc(32);
 if ($bitmap->test(10)) {
        print "bit 10 is set\n";
 }
```

## DESCRIPTION

The Slurm::Bitstr class is a wrapper of the bit string functions in libslurm. This package is loaded and bootstrapped with package Slurm.

## METHODS

*$bitmap = Slurm::Bitstr::alloc($nbits);*

Allocate a bitstring object with `$nbits` bits. An opaque bitstr object is returned. This is a **CLASS METHOD**.

*$bitmap-\>realloc($nbits);*

Reallocate a bitstring(expand or contract size). `$nbits` is the number of bits in the new bitstring.

*$len = $bitmap-\>****size()****;*

Return the number of possible bits in a bitstring.

*$cond = $bitmap-\>test($n);*

Check if bit `$n` of `$bitmap` is set.

*$bitmap-\>set($n);*

Set bit `$n` of `$bitmap`.

*$bitmap-\>clear($n);*

Clear bit `$n` of `$bitmap`.

*$bitmap-\>nset($start, $stop);*

Set bits `$start` .. `$stop` in `$bitmap`.

*$bitmap-\>nclear($start, $stop);*

Clear bits `$start` .. `$stop` in `$bitmap`.

*$pos = $bitmap-\>****ffc()****;*

Find first bit clear in `$bitmap`.

*$pos = $bitmap-\>nffc($n)*

Find the first `$n` contiguous bits clear in `$bitmap`.

*$pos = $bitmap-\>noc($n, $seed);*

Find `$n` contiguous bits clear in `$bitmap` starting at offset `$seed`.

*$pos = $bitmap-\>nffs($n);*

Find the first `$n` contiguous bits set in `$bitmap`.

*$pos = $bitmap-\>****ffs()****;*

Find first bit set in `$bitmap`;

*$pos = $bitmap-\>****fls()****;*

Find last bit set in `$bitmap`;

*$bitmap-\>****fill\_gaps()****;*

Set all bits of `$bitmap` between the first and last bits set(i.e. fill in the gaps to make set bits contiguous).

*$cond = $bitmap1-\>super\_set($bitmap2);*

Return 1 if all bits set in `$bitmap1` are also set in `$bitmap2`, 0 otherwise.

*$cond = $bitmap1-\>equal($bitmap2);*

Return 1 if `$bitmap1` and `$bitmap2` are identical, 0 otherwise.

*$bitmap1-\>and($bitmap2);*

`$bitmap1` &= `$bitmap2`.

*$bitmap-\>****not()****;*

`$bitmap` = ~$bitmap.

*$bitmap1-\>or($bitmap2);*

`$bitmap1` \|= `$bitmap2`.

*$new = $bitmap-\>****copy()****;*

Return a copy of the supplied bitmap.

*$dest\_bitmap-\>copybits($src\_bitmap);*

Copy all bits of `$src_bitmap` to `$dest_bitmap`.

*$n = $bitmap-\>****set\_count()****;*

Count the number of bits set in bitstring.

*$n = $bitmap1-\>overlap($bitmap2);*

Return number of bits set in `$bitmap1` that are also set in `$bitmap2`, 0 if no overlap.

*$n = $bitmap-\>****clear\_count()****;*

Count the number of bits clear in bitstring.

*$n = $bitmap-\>****nset\_max\_count()****;*

Return the count of the largest number of contiguous bits set in `$bitmap`.

*$sum = $bitmap-\>inst\_and\_set\_count($int\_array);*

And `$int_array` and `$bitmap` and sum the elements corresponding to set entries in `$bitmap`.

*$new = $bitmap-\>rotate\_copy($n, $nbits);*

Return a copy of `$bitmap` rotated by `$n` bits. Number of bit in the new bitmap is `$nbits`.

*$bitmap-\>rotate($n);*

Rotate `$bitmap` by `$n` bits.

*$new = $bitmap-\>pick\_cnt($nbits);*

Build a bitmap containing the first `$nbits` of `$bitmap` which are set.

*$str = $bitmap-\>****fmt()****;*

Convert `$bitmap` to range string format, e.g. 0-5,42

*$rc = $bitmap-\>unfmt($str);*

Convert range string format to bitmap.

*$array = Slurm::Bitstr::bitfmt2int($str);*

Convert `$str` describing bitmap (output from **fmt()**, e.g. "0-30,45,50-60") into an array of integer (start/edn) pairs terminated by -1 (e.g. "0, 30, 45, 45, 50, 60, -1").

*$str = $bitmap-\>****fmt\_hexmask()****;*

Given a bit string, allocate and return a string in the form of:\
     "0x0123ABC\\0"\
        ^     ^\
        \|     \|\
       MSB   LSB

*$rc = $bitmap-\>unfmt\_hexmask($str);*

Give a hex mask string "0x0123ABC\\0", convert to a bit string.\
                           ^     ^\
                           \|     \|\
                          MSB   LSB

*$str = $bitmap-\>****fmt\_binmask()****;*

Given a bit string, allocate and return a binary string in the form of:\
                             "0001010\\0"\
                              ^     ^\
                              \|     \|\
                             MSB   LSB

*$rc = $bitmap-\>unfmt\_binmask($str);*

Give a bin mask string "0001010\\0", convert to a bit string.\
                         ^     ^\
                         \|     \|\
                        MSB   LSB

*$pos = $bitmap-\>get\_bit\_num($n);*

Find position of the `$n`-th set bit(0 based, i.e., the first set bit is the 0-th) in `$bitmap`. Returns -1 if there are less than `$n` bits set.

*$n = $bitmap-\>get\_pos\_num($pos);*

Find the number of bits set minus one in `$bitmap` between bit position \[0 .. `$pos`\]. Returns -1 if no bits are set between \[0 .. `$pos`\].

## SEE ALSO

Slurm

## AUTHOR

This library is created by Hongjia Cao, \<hjcao(AT)nudt.edu.cn\> and Danny Auble, \<da(AT)llnl.gov\>. It is distributed with Slurm.

## COPYRIGHT AND LICENSE

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.8.4 or, at your option, any later version of Perl 5 you may have available.