位域与位运算¶

位域（Bitfield） 是一种特殊的 struct 成员，它允许我们精确地定义一个变量占用的二进制位数。其在HFT中的核心价值在于：

内存压缩： 将多个标志（flags）或小整数打包到单个字节或字中，减少内存占用。
缓存效率： 更紧凑的数据结构意味着在CPU缓存中可以存放更多信息，减少缓存未命中。
高效操作： 与位掩码（Bitmask）结合使用，可以实现极快的状态读写。

关键权衡： 访问位域成员的CPU开销略高于普通成员（需要进行位移和掩码计算），因此它是一种用少量计算资源换取宝贵内存和缓存性能的优化手段。所以尽量避免非8/16/32/64位的位域（效率低）

使用场景示例：订单状态压缩、市场数据更新标记、风险控制条件编码、交易指令优先级标记、硬件加速与寄存器映射

1. 批量位操作

// 低效：逐个赋值（编译器生成3次位操作）
struct Naive {
  uint8_t a : 4;
  uint8_t b : 2;
  uint8_t c : 2;
};
Naive x;
x.a = A;
x.b = B;
x.c = C;  // 3次独立内存访问

// 高效：位运算组合（单次内存写入）
union Optimized {
  struct {
    uint8_t a : 4, b : 2, c : 2;
  };
  uint8_t raw;
};
Optimized y;
y.raw = (A & 0x0F) | ((B & 0x03) << 4) | ((C & 0x03) << 6);  // 单次写入

2. 溢出保护模式

// 安全赋值模板（自动处理掩码）
template <size_t OFFSET, size_t BITS>
inline void set_bits(uint8_t& target, uint8_t value) {
  constexpr uint8_t MASK = (1 << BITS) - 1;
  target = (target & ~(MASK << OFFSET)) | ((value & MASK) << OFFSET);
}

// 使用示例
set_bits<0, 4>(y.raw, A);  // 设置a
set_bits<4, 2>(y.raw, B);  // 设置b
set_bits<6, 2>(y.raw, C);  // 设置c

3. 读取优化（避免部分读-修改-写）

// 低效：多次读取同一字节
uint8_t get_a(const Optimized& obj) {
  return obj.a;  // 每次触发位提取
}

// 高效：单次加载+掩码
inline uint8_t fast_get_a(uint8_t raw) {
  return raw & 0x0F;  // 无内存访问
}

4. 跨平台陷阱与解决方案

// 跨平台安全模式
#pragma pack(push, 1)
struct PortableFlags {
  uint8_t flags;  // 手动管理位域

  bool get_feature_x() const { return flags & 0x01; }
  void set_feature_x(bool v) { flags = (flags & ~0x01) | (v ? 0x01 : 0); }
};
#pragma pack(pop)

static_assert(sizeof(PortableFlags) == 1, "Packing failed");

5. 现代C++替代方案

// C++20 推荐：bit_cast + 枚举类
enum class Flags : uint8_t {
  FeatureA = 1 << 0,
  FeatureB = 1 << 1,
  FeatureC = 1 << 2
};

// 安全操作
Flags operator|(Flags a, Flags b) {
  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
}

// 使用
Flags config = Flags::FeatureA | Flags::FeatureC;
bool hasA =
    (static_cast<uint8_t>(config) & static_cast<uint8_t>(Flags::FeatureA)) != 0;

位域仅用于内存/存储关键路径，且推荐：

通过批量位运算初始化/更新
用static_assert验证内存布局
优先考虑C++20的std::bit_cast和枚举位掩码
永远不要在网络协议/文件格式中直接使用编译器生成的位域布局

位运算的核心应用是“用单个整数存储多个布尔状态”（位标志）或“表示集合关系”（位集），二者在低延迟场景（如HFT订单状态、AI推理开关）中可显著减少内存占用与执行延迟。

1. 位标志（Bit Flags）：单整数存储多状态

一个32位unsigned int可存储32个独立布尔状态（1位表示1个状态），通过位运算实现“检查、设置、清除、切换”状态，效率远高于std::vector<bool>或多个bool变量。

通用位标志宏（适配32位unsigned）：

// 检查某一位是否设置（x：存储变量，b：位掩码，如1u<<3表示第3位）
#define AUSSIE_ONE_BIT_SET(x, b) (((unsigned)(x) & (unsigned)(b)) != 0)

// 检查任意指定位是否设置（b可含多个位，如0b1010）
#define AUSSIE_ANY_BITS_SET(x, b) (((unsigned)(x) & (unsigned)(b)) != 0)

// 检查所有指定位是否设置
#define AUSSIE_ALL_BITS_SET(x, b) \
  (((unsigned)(x) & (unsigned)(b)) == (unsigned)(b))

// 设置指定位（将b中的1位在x中置1）
#define AUSSIE_SET_BITS(x, b) ((unsigned)(x) | (unsigned)(b))

// 清除指定位（将b中的1位在x中置0）
#define AUSSIE_CLEAR_BITS(x, b) ((unsigned)(x) & ~(unsigned)(b))

// 切换指定位（b中的1位在x中反转）
#define AUSSIE_TOGGLE_BITS(x, b) ((unsigned)(x) ^ (unsigned)(b))

应用示例：订单状态管理

// 定义订单状态位掩码（1位对应1个状态）
const unsigned ORDER_NEW = 1u << 0;        // 第0位：新订单
const unsigned ORDER_FILLED = 1u << 1;     // 第1位：已成交
const unsigned ORDER_CANCELLED = 1u << 2;  // 第2位：已取消

int main() {
  unsigned order_status = 0;
  // 设置“新订单”状态
  order_status = AUSSIE_SET_BITS(order_status, ORDER_NEW);

  // 检查是否为新订单
  if (AUSSIE_ONE_BIT_SET(order_status, ORDER_NEW)) {
    std::cout << "New order created" << std::endl;
  }

  // 标记为“已成交”，清除“新订单”
  order_status = AUSSIE_SET_BITS(order_status, ORDER_FILLED);
  order_status = AUSSIE_CLEAR_BITS(order_status, ORDER_NEW);

  return 0;
}

2. 位集（Bit Sets）：用整数表示集合关系

将unsigned整数视为 “元素为 0_{31 的集合”（1 表示元素在集合中，0 表示不在），通过位运算高效实现集合操作，比}std::set<int>快 12 个数量级：

集合操作	位运算实现（u1、u2为集合）	示例（u1=0b1010→{1,3}，u2=0b0110→{1,2}）
交集（元素在u1且在u2）	`u1 & u2`	0b0010→{1}
并集（元素在u1或在u2）	`u1 \| u2`
补集（元素不在u1）	`~u1`（需截断为32位）	0b...11110101→所有不在{1,3}的元素
差集（元素在u1不在u2）	`u1 & ~u2`	0b1000→{3}
空集	`0`	无元素
全集（32位）	`0xFFFFFFFFu`	{0,1,...,31}

关键操作：统计集合元素个数（Popcount）

“Popcount”指统计整数中1的个数（即集合元素个数），有三种实现方式，效率依次提升：

基础循环法（慢，适合理解原理）：

int aussie_popcount_basic(unsigned int x) {
  int ct = 0;
  for (int i = 0; i < 32; i++) {  // 遍历32位
    if (AUSSIE_ONE_BIT_SET(x, 1u << i)) ct++;
  }
  return ct;
}

Kernighan算法（快，循环次数=1的个数）：

int aussie_popcount_kernighan(unsigned int x) {
  int ct = 0;
  while (x != 0) {
    x = x & (x - 1);  // 清除最右侧的1（核心技巧）
    ct++;
  }
  return ct;
}

编译器内建函数（最快，硬件指令级）：

// GCC/Clang：__builtin_popcount
int aussie_popcount_gcc(unsigned int x) { return __builtin_popcount(x); }
// MSVS：__popcnt（需包含<intrin.h>）
int aussie_popcount_msvs(unsigned int x) { return __popcnt(x); }

- **硬件支持**：x86架构提供`POPCNT`指令，内建函数直接映射该指令，单周期完成32位统计。