ESP32多GPIO读写的整数位重排优化方案咨询

本人使用ESP32微控制器，需直接读写部分GPIO：将4位值的位映射到uint32输出寄存器的指定4个位置，以及反向从uint32输入寄存器的指定4个位置读取并打包为4位值。希望采用不依赖特定引脚或顺序的通用优化方案，目前已有如下实现代码，现咨询：

• 写入时使用查找表是否更快？
• 是否有复用中间值等其他方法？
• 读取时能否通过魔术常数（如乘法等）实现位迁移？
• 还有哪些减少指令数的优化建议？

定义代码 #

#define BIT(x) (1U << (x)) // from some builtin header

const gpio_num_t dig_in[4] = {GPIO_NUM_34, GPIO_NUM_35, GPIO_NUM_36, GPIO_NUM_39}; // same as {34, 35, 36, 39}
const gpio_num_t dig_out[4] = {GPIO_NUM_4, GPIO_NUM_25, GPIO_NUM_26, GPIO_NUM_27}; // same as { 4, 25, 26, 27}

现有写入引脚代码 #

void write_pins(uint8_t out)
{
    static const uint32_t masks[4] = {BIT(dig_out[0]), BIT(dig_out[1]), BIT(dig_out[2]), BIT(dig_out[3])};

    uint32_t set   = ((out & 0b0001) ? masks[0] : 0) | ((out & 0b0010) ? masks[1] : 0) | ((out & 0b0100) ? masks[2] : 0) | ((out & 0b1000) ? masks[3] : 0);
    uint32_t reset = (!(out & 0b0001) ? masks[0] : 0) | (!(out & 0b0010) ? masks[1] : 0) | (!(out & 0b0100) ? masks[2] : 0) | (!(out & 0b1000) ? masks[3] : 0);

    REG_WRITE(GPIO_OUT_W1TS_REG, set);
    REG_WRITE(GPIO_OUT_W1TC_REG, reset);
}

现有读取引脚代码 #

uint8_t read_pins()
{
    static const uint32_t masks[4] = {BIT(dig_in[0] - 32), BIT(dig_in[1] - 32), BIT(dig_in[2] - 32), BIT(dig_in[3] - 32)};

    uint32_t pins = REG_READ(GPIO_IN1_REG);

    return (!!(pins & masks[0]) << 0) | (!!(pins & masks[1]) << 1) | (!!(pins & masks[2]) << 2) | (!!(pins & masks[3]) << 3);
}

一、写入操作优化 #

1. 查找表方案：确实更快 #

4位输入仅对应16种组合，可预先生成所有情况的set和reset寄存器值，运行时直接查表即可，彻底避免实时位运算与条件判断，在ESP32的Xtensa架构下执行效率提升明显。

实现示例：

// 预生成查找表（程序启动时初始化一次）
static uint32_t write_set_lut[16];
static uint32_t write_reset_lut[16];

void init_write_lut() {
    const uint32_t masks[4] = {BIT(dig_out[0]), BIT(dig_out[1]), BIT(dig_out[2]), BIT(dig_out[3])};
    for (int i = 0; i < 16; i++) {
        write_set_lut[i] = 0;
        write_reset_lut[i] = 0;
        for (int bit = 0; bit < 4; bit++) {
            if (i & (1 << bit)) {
                write_set_lut[i] |= masks[bit];
            } else {
                write_reset_lut[i] |= masks[bit];
            }
        }
    }
}

// 优化后的写入函数
void write_pins(uint8_t out) {
    uint8_t idx = out & 0x0F; // 仅保留低4位有效数据
    REG_WRITE(GPIO_OUT_W1TS_REG, write_set_lut[idx]);
    REG_WRITE(GPIO_OUT_W1TC_REG, write_reset_lut[idx]);
}

2. 复用中间值的无查表优化 #

若不想引入查找表，可通过复用总掩码减少重复计算：

void write_pins(uint8_t out) {
    static const uint32_t masks[4] = {BIT(dig_out[0]), BIT(dig_out[1]), BIT(dig_out[2]), BIT(dig_out[3])};
    static const uint32_t total_mask = masks[0] | masks[1] | masks[2] | masks[3]; // 编译期计算完成
    
    uint32_t set = 0;
    for (int bit = 0; bit < 4; bit++) {
        if (out & (1 << bit)) {
            set |= masks[bit];
        }
    }
    uint32_t reset = total_mask ^ set; // 用总掩码异或set直接得到reset，避免重复判断
    
    REG_WRITE(GPIO_OUT_W1TS_REG, set);
    REG_WRITE(GPIO_OUT_W1TC_REG, reset);
}

该方案将原代码中重复4次的条件判断减半，指令数更少。

二、读取操作优化 #

1. 魔术常数实现位迁移 #

针对4位打包需求，可通过乘法魔术常数将分散的位快速集中到低4位，避免多次条件判断：

uint8_t read_pins() {
    // 输入引脚在GPIO_IN1_REG中的位位置（编译期计算）
    static const uint8_t in_bits[4] = {dig_in[0]-32, dig_in[1]-32, dig_in[2]-32, dig_in[3]-32};
    // 魔术常数：将每个输入位映射到32位的高4位区域
    static const uint32_t magic = 
        (1U << (31 - in_bits[0])) | 
        (1U << (30 - in_bits[1])) | 
        (1U << (29 - in_bits[2])) | 
        (1U << (28 - in_bits[3]));
    static const uint32_t mask = BIT(in_bits[0]) | BIT(in_bits[1]) | BIT(in_bits[2]) | BIT(in_bits[3]);
    
    uint32_t pins = REG_READ(GPIO_IN1_REG) & mask;
    // 乘法将分散位移到高4位，右移后提取低4位
    return (uint8_t)((pins * magic) >> 28);
}

原理是利用乘法的位扩展特性，将每个目标位精准映射到32位的高4位，再通过一次移位完成打包，指令数远少于原代码。

2. 简化位提取逻辑 #

原代码中的!!可直接替换为条件表达式，编译器会自动优化为等价指令，同时减少冗余操作：

uint8_t read_pins() {
    static const uint32_t masks[4] = {BIT(dig_in[0]-32), BIT(dig_in[1]-32), BIT(dig_in[2]-32), BIT(dig_in[3]-32)};
    uint32_t pins = REG_READ(GPIO_IN1_REG);
    
    return ((pins & masks[0] ? 1 : 0)) |
           ((pins & masks[1] ? 1 : 0) << 1) |
           ((pins & masks[2] ? 1 : 0) << 2) |
           ((pins & masks[3] ? 1 : 0) << 3);
}

三、通用减少指令数的建议 #

• 编译期预计算常量：将masks、total_mask、magic等声明为static const，让编译器在编译期完成计算，避免运行时移位操作。
• 利用Xtensa架构特性：Xtensa支持__builtin_xtensa_extui等内置位操作函数，可直接提取指定位，减少指令数：

  // 提取pins中第n位，返回0或1
  #define EXTRACT_BIT(pins, n) ((uint8_t)__builtin_xtensa_extui((pins), (n), 1))
  

• 内联高频函数：若write_pins和read_pins被频繁调用，可声明为static inline，让编译器内联展开，消除函数跳转开销。
• 避免冗余寄存器操作：尽量复用已计算的中间值，比如写入时用total_mask ^ set替代重复计算reset。

内容的提问来源于stack exchange，提问作者herhor67