bitmap_fold(9) [suse man page]

BITMAP_FOLD(9)						  Basic Kernel Library Functions					    BITMAP_FOLD(9)

NAME

       bitmap_fold - fold larger bitmap into smaller, modulo specified size

SYNOPSIS

       void bitmap_fold(unsigned long * dst, const unsigned long * orig, int sz, int bits);

ARGUMENTS

       dst
	   resulting smaller bitmap

       orig
	   original larger bitmap

       sz
	   specified size

       bits
	   number of bits in each of these bitmaps

DESCRIPTION

       For each bit oldbit in orig, set bit oldbit mod sz in dst. Clear all other bits in dst. See further the comment and Example [2] for
       bitmap_onto for why and how to use this.

COPYRIGHT

Kernel Hackers Manual 2.6.					     July 2010							    BITMAP_FOLD(9)

Slurm::Bitstr(3pm)					User Contributed Perl Documentation					Slurm::Bitstr(3pm)

NAME

       Slurm::Bitstr - Bitstring functions in libslurm

SYNOPSIS

	use Slurm;

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

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"
	      ^     ^
	      |     |
	     MSB   LSB

       $rc = $bitmap->unfmt_hexmask($str);

       Give a hex mask string "0x0123ABC", 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"
				    ^	  ^
				    |	  |
				   MSB	 LSB

       $rc = $bitmap->unfmt_binmask($str);

       Give a bin mask string "0001010", 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 postion [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.

perl v5.14.2							    2012-03-16							Slurm::Bitstr(3pm)