是否有任何高性能的C / C ++库支持在任意位置进行位操作？
[英]Is there any high performance C/C++ library that supports bit manipulation at arbitrary position?
问题描述
I wonder if there's a high performance C/C++ library that support bit manipulation at arbitrary position? 
我想知道是否有一个高性能的C / C ++库支持任意位置的位操作？
For example: int BitCompare(const void* src, size_t srcOffsetInBits, const void* dst, size_t dstOffsetInBits, size_t sizeInBits); 例如： int BitCompare(const void* src, size_t srcOffsetInBits, const void* dst, size_t dstOffsetInBits, size_t sizeInBits); A function that compares bits [srcOffsetInBits, srcOffsetInBits + sizeInBits - 1] in src and [dstOffsetInBits, dstOffsetInBits + sizeInBits - 1] in dst, the bits are considered as little-endian unsigned integers. 比较src中的位[srcOffsetInBits, srcOffsetInBits + sizeInBits - 1]和dst中的[dstOffsetInBits, dstOffsetInBits + sizeInBits - 1] ，这些位被视为little-endian无符号整数。 All buffers are assumed to be large enough. 假设所有缓冲区都足够大。
bool BitEqual(...);
void BitMove(...); // src and dst can overlap.
void BitCopy(...); // src and dst cannot overlap.
All operations should only modify the bits under operation, and all other bits should be preserved. 所有操作只应修改操作中的位，并且应保留所有其他位。
I made some attempt to implement BitCompare. 我做了一些尝试来实现BitCompare。
static uint8_t mask8l1[9] = {
0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF
};
static uint8_t mask8l0[9] = {
0xFF, 0xFE, 0xFC, 0xF8, 0xF0, 0xE0, 0xC0, 0x80, 0x00
};
// Offset-less compare.
int BitCompare8(const void* src, const void* dst, size_t sizeInBits)/*{{{*/
{
const uint8_t* _src = static_cast<const uint8_t*>(src);
const uint8_t* _dst = static_cast<const uint8_t*>(dst);
size_t sizeInUint8s = sizeInBits >> 3;
size_t sizeRemaining = sizeInBits & 0x07;
// MSB ---> LSB
// : bits-to-compare :
// ----------------------------------------- ---------------------
// | : sizeRemaining | | ... | |
// ----------------------------------------- ---------------------
// @_src + sizeInUint8s @_src
//
// ----------------------------------------- ---------------------
// | : sizeRemaining | | ... | |
// ----------------------------------------- ---------------------
// @_dst + sizeInUint8s @_dst
_src += sizeInUint8s;
_dst += sizeInUint8s;
// Compare the MSB sizeRemaining bits first.
if (sizeRemaining)
{
// : sizeRemaining :
// ----------------------
// | : s |
// ----------------------
// @_src
// : sizeRemaining :
// ----------------------
// | : d |
// ----------------------
// @_dst
uint8_t s = *_src & mask8l1[sizeRemaining];
uint8_t d = *_dst & mask8l1[sizeRemaining];
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
// Then compare the LSB uint8s.
while (sizeInUint8s)
{
// ----------------------
// | s |
// ----------------------
// @_src - 1
// ---------------------
// | d |
// ---------------------
// @_dst - 1
uint8_t s = *--_src;
uint8_t d = *--_dst;
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
--sizeInUint8s;
}
return 0;
}/*}}}*/
// Source-side offset compare.
int BitCompare8(const void* src, size_t offsetInBits, /*{{{*/
const void* dst, size_t sizeInBits)
{
const uint8_t* _src = static_cast<const uint8_t*>(src);
const uint8_t* _dst = static_cast<const uint8_t*>(dst);
_src += offsetInBits >> 3;
offsetInBits &= 0x07;
if (!offsetInBits)
{
return BitCompare8(_src, _dst, sizeInBits);
}
size_t sizeInUint8s = sizeInBits >> 3;
size_t sizeRemaining = sizeInBits & 0x07;
// MSB ---> LSB
// : bits-to-compare :
// : sizeRemaining : :
// ----------------------------------------- ---------------------
// | | : offsetInBits | ... | : offsetInBits |
// ----------------------------------------- ---------------------
// @_src + sizeInUint8s @_src
//
// ----------------------------------------- ---------------------
// | : sizeRemaining | | ... | |
// ----------------------------------------- ---------------------
// @_dst + sizeInUint8s @_dst
_src += sizeInUint8s;
_dst += sizeInUint8s;
// Move the MSB sizeRemaining bits first.
if (sizeRemaining)
{
if (sizeRemaining + offsetInBits <= 8)
{
// : sizeRemaining :
// ----------------------------------
// | : s : offsetInBits |
// ----------------------------------
// @_src
// : sizeRemaining :
// ----------------------------------
// | : d |
// ----------------------------------
// @_dst
uint8_t s = (*_src >> offsetInBits) & mask8l1[sizeRemaining];
uint8_t d = *_dst & mask8l1[sizeRemaining];
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
else // if (sizeRemaining + offsetInBits > 8)
{
// : sizeRemaining :
// -------------------------------------------------------------------
// | : a | b : offsetInBits |
// -------------------------------------------------------------------
// @_src + 1 @_src
//
// : sizeRemaining :
// ----------------------------------
// | : a : b |
// ----------------------------------
// : : @_dst
// : offsetInBits :
//
// a = sizeRemaining - (8 - offsetInBits)
// b = 8 - offsetInBits
//
// Note: offsetInBits > 8 - sizeRemaining > 0
// a < 8
uint8_t a = (*(_src + 1) << (8 - offsetInBits))
& mask8l1[sizeRemaining];
uint8_t b = *_src >> offsetInBits;
uint8_t s = a | b;
uint8_t d = *_dst & mask8l1[sizeRemaining];
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
}
// Then move the LSB uint8s.
while (sizeInUint8s)
{
// : offsetInBits :
// -----------------------------------------
// | : a | b : offsetInBits |
// -----------------------------------------
// @_src @_src - 1
// : offsetInBits :
// ---------------------
// | a : b |
// ---------------------
// @_dst - 1
//
uint8_t a = *_src << (8 - offsetInBits);
uint8_t b = *--_src >> offsetInBits;
uint8_t s = a | b;
uint8_t d = *--_dst;
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
--sizeInUint8s;
}
return 0;
}/*}}}*/
// Destination-side offset compare.
int BitCompare8(const void* src, /*{{{*/
const void* dst, size_t offsetInBits,
size_t sizeInBits)
{
return -BitCompare8(dst, offsetInBits, src, sizeInBits);
}/*}}}*/
// Generic compare.
int BitCompare8(const void* src, size_t srcOffsetInBits, /*{{{*/
const void* dst, size_t dstOffsetInBits,
size_t sizeInBits)
{
const uint8_t* _src = static_cast<const uint8_t*>(src);
const uint8_t* _dst = static_cast<const uint8_t*>(dst);
_src += srcOffsetInBits >> 3;
srcOffsetInBits &= 0x07;
if (!srcOffsetInBits)
{
return -BitCompare8(_dst, dstOffsetInBits, _src, sizeInBits);
}
_dst += dstOffsetInBits >> 3;
dstOffsetInBits &= 0x07;
if (!dstOffsetInBits)
{
return BitCompare8(_src, srcOffsetInBits, _dst, sizeInBits);
}
size_t sizeInUint8s = sizeInBits >> 3;
size_t sizeRemaining = sizeInBits & 0x07;
// MSB ---> LSB
// : bits-to-compare :
// : sizeRemaining : :
// ----------------------------------------------- ------------------------
// | | : srcOffsetInBits | ... | : srcOffsetInBits |
// ----------------------------------------------- ------------------------
// @_src + sizeInUint8s @_src
//
// : sizeRemaining :
// ----------------------------------------------- ------------------------
// | | : dstOffsetInBits | ... | : dstOffsetInBits |
// ----------------------------------------------- ------------------------
// @_dst + sizeInUint8s @_dst
if (srcOffsetInBits <= dstOffsetInBits)
{
// : sizeRemaining :
// -----------------------------------------------
// | | : srcOffsetInBits |
// -----------------------------------------------
// @_src
//
// : sizeRemaining :
// -----------------------------------------------
// | | : dstOffsetInBits |
// -----------------------------------------------
// @_dst
if (!sizeInUint8s)
{
if (sizeRemaining + dstOffsetInBits <= 8)
{
// : sizeRemaining :
// -----------------------------------------------
// | : s : srcOffsetInBits |
// -----------------------------------------------
// @_src
//
// : sizeRemaining :
// -----------------------------------------------
// | : d : dstOffsetInBits |
// -----------------------------------------------
// @_dst
// There're only sizeRemaining bits to compare.
uint8_t s = (*_src >> srcOffsetInBits)
& mask8l1[sizeRemaining];
uint8_t d = (*_dst >> dstOffsetInBits)
& mask8l1[sizeRemaining];
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
else // if (sizeRemaining + dstOffsetInBits > 8)
{
// : sizeRemaining :
// -------------------------------------------------
// | : a | b : srcOffsetInBits |
// -------------------------------------------------
// @_src
//
// : sizeRemaining :
// -------------------------------------------------
// | : a | b : dstOffsetInBits |
// -------------------------------------------------
// @_dst + 1 @_dst
uint8_t a = *_src++ >> srcOffsetInBits;
uint8_t b = (*_src << (8 - srcOffsetInBits))
& mask8l1[sizeRemaining];
uint8_t s = a | b;
a = *_dst++ >> dstOffsetInBits;
b = (*_dst << (8 - dstOffsetInBits))
& mask8l1[sizeRemaining];
uint8_t d = a | b;
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
return 0;
}
// There're more than (8 - dstOffsetInBits) bits to compare.
// Compare MSB bits first.
// <- MSB bits to compare ->:
// :---:>(8 - dstOffsetInBits)
// : sizeRemaining :
// -------------------------------------------------
// | : | : s : srcOffsetInBits |
// -------------------------------------------------
// @_src
//
// <- MSB bits to compare ->:
// : sizeRemaining :
// -------------------------------------------------
// | : | d : dstOffsetInBits |
// -------------------------------------------------
// @_dst + 1 @_dst
int result = BitCompare8(
_src, srcOffsetInBits + (8 - dstOffsetInBits),
_dst + 1, sizeInBits - (8 - dstOffsetInBits));
if (result)
{
return result;
}
// Then compare LSB (8 - dstOffsetInBits) bits.
uint8_t s = (*_src >> srcOffsetInBits) & mask8m0[dstOffsetInBits];
uint8_t d = *_dst++ >> dstOffsetInBits;
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
else // if (dstOffsetInBits < srcOffsetInBits)
{
// : sizeRemaining :
// -----------------------------------------------
// | | : srcOffsetInBits |
// -----------------------------------------------
// @_src
//
// : sizeRemaining :
// -----------------------------------------------
// | | : dstOffsetInBits |
// -----------------------------------------------
// @_dst
if (!sizeInUint8s)
{
if (sizeRemaining + srcOffsetInBits <= 8)
{
// : sizeRemaining :
// -----------------------------------------------
// | : s : srcOffsetInBits |
// -----------------------------------------------
// @_src
//
// : sizeRemaining :
// -----------------------------------------------
// | : d : dstOffsetInBits |
// -----------------------------------------------
// @_dst
// There're only sizeRemaining bits to compare.
uint8_t s = (*_src >> srcOffsetInBits)
& mask8l1[sizeRemaining];
uint8_t d = (*_dst >> dstOffsetInBits)
& mask8l1[sizeRemaining];
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
else // if (sizeRemaining + srcOffsetInBits > 8)
{
// : sizeRemaining :
// -------------------------------------------------
// | : a | b : srcOffsetInBits |
// -------------------------------------------------
// @_src + 1 @_src
//
// : sizeRemaining :
// -------------------------------------------------
// | : a | b : dstOffsetInBits |
// -------------------------------------------------
// @_dst + 1 @_dst
uint8_t a = *_src++ >> srcOffsetInBits;
uint8_t b = (*_src << (8 - srcOffsetInBits))
& mask8l1[sizeRemaining];
uint8_t s = a | b;
a = *_dst++ >> dstOffsetInBits;
b = (*_dst << (8 - dstOffsetInBits))
& mask8l1[sizeRemaining];
uint8_t d = a | b;
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
return 0;
}
// There're more than (8 - srcOffsetInBits) bits to compare.
// Compare MSB bits first.
//
// <- MSB bits to compare ->:
// : sizeRemaining :
// -------------------------------------------------
// | : | s : srcOffsetInBits |
// -------------------------------------------------
// @_src + 1 @_src
//
// <- MSB bits to compare ->:
// :---:>(8 - srcOffsetInBits)
// : sizeRemaining :
// -------------------------------------------------
// | : | : d : dstOffsetInBits |
// -------------------------------------------------
// @_dst + 1 @_dst
int result = BitCompare8(
_dst, dstOffsetInBits + (8 - srcOffsetInBits),
_src + 1, sizeInBits - (8 - srcOffsetInBits));
if (result)
{
return result;
}
// Then compare LSB (8 - srcOffsetInBits) bits.
uint8_t s = *_src++ >> srcOffsetInBits;
uint8_t d = (*_dst >> dstOffsetInBits) & mask8m0[srcOffsetInBits];
if (s < d)
{
return -1;
}
else if (d < s)
{
return 1;
}
}
return 0;
}/*}}}*/
2 个解决方案
解决方案1
4 2013-09-01 07:51:42
GNU Multiprecision Arithmetic库支持任意长整数的按位运算，并提供C ++接口。
解决方案2
1 2013-09-01 07:42:25
Looks like you could use boost::dynamic_bitset . 看起来你可以使用boost::dynamic_bitset 。 There's an equality operator you can use. 你可以使用一个相等运算符 。 With creative use of << and .resize() you should be able to compare what you want pretty easily. 通过创造性地使用<<和.resize（），你应该能够很容易地比较你想要的东西。
声明:本站的技术帖子网页，遵循CC BY-SA 4.0协议，如果您需要转载，请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.
相关问题
C++ 位操作 - C++ bit manipulation
JavaScript位操作到C ++位操作 - JavaScript Bit Manipulation to C++ Bit Manipulation
位操作十六进制C ++ - Bit manipulation Hexadecimal C++
C ++中是否有任何开源的，高性能的，类似于IPC的味精总线库？ - Is there any opensource high-performance IPC-like msg bus library in c++?
ACE（C ++库）仍然用于高性能计算吗？ - Is ACE (C++ library) still used for high performance computing?
需要一个免费的线程安全矩阵数学库，该库支持16位整数（C ++） - Need a free thread-safe matrix math library that supports 16-bit integers (c++)
支持时间算术的C ++标准库 - C++ Standard library that supports time arithmetic
支持加密的C ++ zip库 - C++ zip library that supports encryption
用于C ++中基本图像处理的库 - Library for basic image manipulation in C++
好的C ++字符串操作库 - Good C++ string manipulation library
相关标签