c - 在 Xilinx Microblaze 中使用 C 语言内联汇编

Question

我有一个用 C 语言编写的应用程序，带有 Xilinx Microblaze 内核的内联汇编。我的内联汇编有一个延迟任务。函数“_delay_loop_X_x”正好延迟处理器每个循环的 4 个周期。输入信号决定要进行的循环次数。函数“_NOPx”是为了达到更高的精度。该函数工作正常，但在信号结束时它会产生两倍的额外延迟。恐怕我错误地使用了寄存器。有人可以检查我的汇编代码吗？

对于 Microblaze，我使用此文档:https://www.xilinx.com/support/documentation/sw_manuals/mb_ref_guide.pdf

汇编代码:

    static __inline__ void _delay_loop_1_x( uint8_t) __attribute__((always_inline));

    static __inline__ void _NOP1 (void) {__asm__ volatile ("nop                  \n\t"            ); } //1 cycle
    static __inline__ void _NOP2 (void) {__asm__ volatile ("beqi r12, 1f \n\t""1:\n\t" ::: "r12", "cc" ); } //2 cycle
    static __inline__ void _NOP3 (void) {__asm__ volatile ("brk r12, r0          \n\t" ::: "r12", "cc" ); } //3 cycle

    static __inline__ void      /* exactly 4 cycles */
    _delay_loop_1_x( uint8_t __n )
    {                                        /* cycles per loop */
        __asm__ volatile (                        
           "   addik r11, r0, 1             \n\t"  /*    1   */
           "1: rsub %[input], r11, %[input] \n\t"  /*    1   */
           "   beqi %[input], 2f            \n\t"  /*    1   */
           "2: bnei %[input], 1b            \n\t"  /*    1   */
           :                                       /*  ----- */
           : [input]"r" (__n)                      /*  ----- */
           : "r11", "cc"                           /*    4   */
       );
    }

    static __inline__ void      /* exactly 4 cycles/loop */
    _delay_loop_2_x( uint16_t __n )
    {                                               /* cycles per loop      */
        __asm__ volatile (                            /* __n..one */
               "   addik r11, r0, 1             \n\t" /*    1   */
               "1: rsub %[loops], r11, %[loops] \n\t" /*    1   */
               "   beqi %[loops], 2f            \n\t" /*    1   */
               "2: bnei %[loops], 1b            \n\t" /*    1   */
               :                                      /*  ----- */
               : [loops]"r" (__n)                     /*  ----- */
               : "r11", "cc"                          /*    4   */
           );
    }

    static __inline__ void
    _delay_cycles(const double __ticks_d)
    {
        uint32_t __ticks = (uint32_t)(__ticks_d);
        uint32_t __padding;
        uint32_t __loops;

        if( __ticks <= 3 )  {       
            __padding = __ticks;

        } else if( __ticks <= 0x400 )  {
            __ticks -= 1;                
            __loops = __ticks / 4;
            __padding = __ticks % 4;
            if( __loops != 0 )
                _delay_loop_1_x( (uint8_t)__loops );

        } else if( __ticks <= 0x40001 )  {
            __ticks -= 2;                  
            __loops = __ticks / 4;
            __padding = __ticks % 4;
            if( __loops != 0 )
                _delay_loop_2_x( (uint16_t)__loops );
        } 

       if( __padding ==  1 )  _NOP1();
       if( __padding ==  2 )  _NOP2();
       if( __padding ==  3 )  _NOP3();
    }

C 代码:

    #define _delay_ns(__ns)     _delay_cycles( (double)(F_CPU)*((double)__ns)/1.0e9 + 0.5 )
    #define _delay_us(__us)     _delay_cycles( (double)(F_CPU)*((double)__us)/1.0e6 + 0.5 )
    #define _delay_ms(__ms)     _delay_cycles( (double)(F_CPU)*((double)__ms)/1.0e3 + 0.5 )

    #define BIT_DELAY_1        _delay_ns(2070) 
    #define BIT_DELAY_5        _delay_us(19) 
    #define BIT_DELAY_7        _delay_us(26)
    #define RX_TX_DELAY        _delay_us(78) 
    #define SHA204_SWI_FLAG_TX      ((uint8_t) 0x88)

    XGpio GpioPIN;

    uint8_t swi_send_bytes(uint8_t count, uint8_t *buffer);
    uint8_t swi_send_byte(uint8_t value);

    int main()
    {
        init_platform();
        XGpio_Initialize(&GpioPIN, GPIO_PIN_DEVICE_ID);
        XGpio_SetDataDirection(&GpioPIN, PIN_CHANNEL, ~PIN);

        (void) swi_send_byte(SHA204_SWI_FLAG_TX);
        cleanup_platform();
        return 0;
    }

    uint8_t swi_send_byte(uint8_t value)
    {
        return swi_send_bytes(1, &value);
    }

    uint8_t swi_send_bytes(uint8_t count, uint8_t *buffer)
    {
        uint8_t i, bit_mask;

        RX_TX_DELAY;

        for (i = 0; i < count; i++) {
            for (bit_mask = 1; bit_mask > 0; bit_mask <<= 1) {
                if (bit_mask & buffer[i]) {
                    XGpio_DiscreteClear(&GpioPIN, PIN_CHANNEL, PIN);
                    BIT_DELAY_1;
                    XGpio_DiscreteWrite(&GpioPIN, PIN_CHANNEL, PIN);
                    BIT_DELAY_7;
                }
                else {
                    XGpio_DiscreteClear(&GpioPIN, PIN_CHANNEL, PIN);
                    BIT_DELAY_1;
                    XGpio_DiscreteWrite(&GpioPIN, PIN_CHANNEL, PIN);
                    BIT_DELAY_1;
                    XGpio_DiscreteClear(&GpioPIN, PIN_CHANNEL, PIN);
                    BIT_DELAY_1;
                    XGpio_DiscreteWrite(&GpioPIN, PIN_CHANNEL, PIN);
                    BIT_DELAY_5;
                }
            }
        }
        return 0;
    }

我的结果: https://imgur.com/a/beBgn

Answer 1

再想一想，我真的不明白这些循环应该是 Nx4 个周期。

static __inline__ void      /* exactly 4 cycles */
_delay_loop_1_x( uint8_t __n )
{                                        /* cycles per loop */
    __asm__ volatile (                        
       "   addik r11, r0, 1             \n\t"  /*    1   */
       "1: rsub %[input], r11, %[input] \n\t"  /*    1   */
       "   beqi %[input], 2f            \n\t"  /*    1   */
       "2: bnei %[input], 1b            \n\t"  /*    1   */
       :                                       /*  ----- */
       : [input]"r" (__n)                      /*  ----- */
       : "r11", "cc"                           /*    4   */
   );
}

一旦 C 部分结束(函数序言)，代码将开始执行 ASM 部分，我看到:

对于 n = 1 (假设编译器将使用 r1 来表示 input ):

执行的指令(一步一步)我猜是这样的:

addik r11, r0, 1             ; r11 = 1 (r0 == fixed zero, right?)
rsub r1, r11, r1             ; r1 = r1 - r11 (i.e. r1 = 0 in this example)
beqi r1, 2f                  ; r1 is zero, so branch to "2" will be taken
bnei r1, 1b                  ; r1 == 0, branch not taken

然后来自 C 的任何剩余指令将随之而来(函数的尾声)。

如果每条指令都是 1 个周期(有很多依赖性，所以在高频现代 CPU 上这是不太可能的，但如果 microblaze 是低频简单 RISC 架构，没有多级管道，那么它可能会像这样工作) ，那么你有 4 个周期。

对于 n = 2

addik r11, r0, 1             ; r11 = 1
rsub r1, r11, r1             ; r1 = 1
beqi r1, 2f                  ; r1 != 0, branch not taken
bnei r1, 1b                  ; r1 != 0, branch taken
rsub r1, r11, r1             ; r1 = 0
beqi r1, 2f                  ; r1 == 0, branch taken to bnei
bnei r1, 1b                  ; r1 == 0, branch not taken

这是 7 条指令，而不是 8 条。对于 8 条指令，您需要 bnei到addik重新设置r11再次访问1出于延迟目的(即使该值已在 r11 中设置)。

<小时/>无论如何，这让我想知道这个 CPU 的计时是否真的那么简单(1 条指令 = 1 个周期，即使在分支时也是如此)，为什么不将循环简化为简单的倒计时(并使用相当原生的 32b输入 input ):

1: raddik %[input], %[input], -1
   bnei   %[input], 1b

然后你就有了 2 个周期的延迟循环。

但是使用延迟的主要代码...有很多 C 代码，它们也会转换为机器代码指令，并且这些指令也需要一些时间来执行，所以不清楚您正在测量什么，以及为什么，如果您确实考虑了由这些附加指令引起的执行延迟。

<小时/>

更新

关于ticks -= 1崩溃..不知道，没有意义，所以你必须进入调试器并找出机器级别的真正原因。

但是，当您尝试拆分周期延迟参数 ticks_d 时，整个事情没有多大意义。通过 C 表达式，例如 if (padding == ...) 的 block 。这些条件测试将比实际填充值花费更多的周期，因此没有必要调用 NOPx();进一步延迟，因为您已经延迟了数十个周期。

现在我终于发现double奥拉夫提到，仅此一项(剩余数学转换为整数)当然会带来巨大的性能损失，甚至可能在数百个周期中。所以整个void delay_cycles(const double ticks_d)实际上会延迟比您预期更多的周期，ASM 部分在总时间中可以忽略不计(除了每个参数值的内部循环消耗约 3 个周期，如果初始参数为足够大)。

如果你确实需要指令周期精度(不是那么常见，上次我确实需要它是在 1990 年左右的 8 位计算机上)，你必须在纯汇编中不使用 C 来编写它，并且还计算准备/逻辑指令进入延迟 - 理想情况下以固定执行时间方式编写，因此调用 delay_cycles函数将产生任何 ticks_d 的固定开销参数值。

然后您可以计算固定开销，并从执行 ticks -= <overhead>; 开始先有确切的延迟再说。并且您必须从double切换到整数，因为 Microblaze CPU 没有 FPU 单元，所以浮点值是通过整数数学模拟的，只是初始转换为 int int ticks = (int)(ticks_d);必须花费相当多的周期，如果您有反汇编 View 并通过单指令单步进入它，您应该在调试器中看到这一点。