基础逻辑门 — 专家经验

// 慢：可能产生分支
if (ptr != NULL && ptr->value > 0) { ... }

// 快：无分支，但需要确保 ptr 不为 NULL
if (ptr != NULL) {
  if (ptr->value > 0) { ... }
}

// 更快：使用位运算（如果两个条件都安全计算）
int result = (ptr != NULL) & (ptr->value > 0);
if (result) { ... }

¬(A ∧ B) = ¬A ∨ ¬B
¬(A ∨ B) = ¬A ∧ ¬B

// 原始代码：复杂
if (!(a > 0 && b > 0 && c > 0)) {
  // 处理错误
}

// 德摩根变换后：清晰
if (a <= 0 || b <= 0 || c <= 0) {
  // 处理错误
}

// 原始：使用 AND 门（6 个晶体管）
assign y = a & b;

// 优化：使用 NAND + NOT（4 + 2 = 6 个晶体管，但 NAND 更简单）
assign y = ~(~(a & b));  // 等价于 a & b
// 或
assign temp = ~(a & b);  // NAND 门
assign y = ~temp;         // NOT 门

// 使用 XOR 交换两个变量（不需要临时变量）
a = a ^ b;
b = a ^ b;
a = a ^ b;

// 原理：
// 第一步：a = a0 ^ b0
// 第二步：b = (a0 ^ b0) ^ b0 = a0
// 第三步：a = (a0 ^ b0) ^ a0 = b0

// 但现代编译器会优化为 MOV 指令，性能相同
// 实际应用中，使用临时变量更清晰
int temp = a;
a = b;
b = temp;

// 计算一个字节中 1 的个数（奇偶性）
uint8_t parity(uint8_t x) {
  x ^= x >> 4;
  x ^= x >> 2;
  x ^= x >> 1;
  return x & 1;
}

// XOR 加密（可逆）
void xor_encrypt(uint8_t* data, size_t len, uint8_t key) {
  for (size_t i = 0; i < len; i++) {
    data[i] ^= key;
  }
}

void xor_decrypt(uint8_t* data, size_t len, uint8_t key) {
  xor_encrypt(data, len, key);  // 加密和解密是同一个操作
}

// 慢：数组遍历（缓存未命中）
for (int i = 0; i < n; i++) {
  sum += array[i];  // 如果 array 很大，会频繁缓存未命中
}

// 快：使用 SIMD 指令（一次处理多个数据）
// 编译器会自动向量化
for (int i = 0; i < n; i++) {
  sum += array[i];
}
// 编译时加上 -O3 -march=native 标志

// 更快：手动分块，提高缓存命中率
for (int i = 0; i < n; i += BLOCK_SIZE) {
  for (int j = i; j < min(i + BLOCK_SIZE, n); j++) {
    sum += array[j];
  }
}

// Verilog: 4 位加法器
module adder_4bit (
  input [3:0] a, b,
  input cin,
  output [3:0] sum,
  output cout
);
  assign {cout, sum} = a + b + cin;
endmodule

// 实例化
adder_4bit adder (
  .a(4'b1010),
  .b(4'b0101),
  .cin(1'b0),
  .sum(),
  .cout()
);

// CUDA: 向量加法
__global__ void vectorAdd(float* A, float* B, float* C, int n) {
  int i = blockIdx.x * blockDim.x + threadIdx.x;
  if (i < n) {
    C[i] = A[i] + B[i];  // 每个线程执行一次加法
  }
}

// 启动 1024 个线程
vectorAdd<<<(n + 1023) / 1024, 1024>>>(A, B, C, n);

// 源代码
int x = 2 + 3;

// 编译器优化
int x = 5;  // 在编译时计算，不需要运行时执行 ADD 指令

// 源代码
for (int i = 0; i < 4; i++) {
  sum += array[i];
}

// 编译器优化（循环展开）
sum += array[0];
sum += array[1];
sum += array[2];
sum += array[3];
// 减少循环控制开销（比较、跳转指令）

// 源代码
int add(int a, int b) { return a + b; }
int x = add(1, 2);

// 编译器优化（函数内联）
int x = 1 + 2;  // 消除函数调用开销（CALL、RET 指令）

// 源代码
for (int i = 0; i < 100; i++) {
  c[i] = a[i] + b[i];
}

// 编译器优化（使用 SIMD 指令）
// 一条指令同时处理 4 个或 8 个数据
// AVX2: 256 位寄存器，一次处理 8 个 32 位整数
// AVX-512: 512 位寄存器，一次处理 16 个 32 位整数

// 不安全的代码（时序攻击漏洞）
int check_password(char* input, char* password) {
  for (int i = 0; i < strlen(password); i++) {
    if (input[i] != password[i]) {
      return 0;  // 提前返回，执行时间取决于匹配长度
    }
  }
  return 1;
}

// 安全的代码（恒定时间执行）
int check_password_secure(char* input, char* password) {
  int result = 0;
  for (int i = 0; i < strlen(password); i++) {
    result |= input[i] ^ password[i];  // 始终执行所有比较
  }
  return result == 0;
}