-1

我有一个用 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

4

1 回答 1

0

仔细想想，我真的不明白这些循环应该是 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 部分，我看到：

for n = 1 （假设编译器将使用r1for 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 == ...). 并且这些条件测试将花费比实际填充值更多的周期，因此没有必要进一步调用NOPx();延迟，因为您已经延迟了数十个周期。

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

如果你真的需要指令周期的准确性（不那么常见，上次我确实需要这个是在 1990 年左右的 8 位计算机上），你必须在没有 C 的情况下用纯 asm 编写它，并将准备/逻辑指令也计入延迟- 理想地以固定执行时间的方式编写，因此调用delay_cycles函数将对任何ticks_d参数值产生固定开销。

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

于 2017-09-04T13:06:16.270 回答