在 C 语言中为 Xilinx Microblaze 使用内联汇编
Using Inline Assembly in C for Xilinx Microblaze
我有一个用 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;
}
仔细想想我真的不明白这些循环应该是 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（假设编译器将使用 r1 for 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 个周期，即使在分支时），为什么不将循环简化为简单的倒计时（并为 input 使用相当原生的 32b 类型）：
1: raddik %[input], %[input], -1
bnei %[input], 1b
然后你有 2 个周期的延迟循环。
但是使用延迟的主要代码...有很多 C 代码，它们也会转换为机器代码指令，并且这些代码也需要一些时间来执行，所以不清楚您在测量什么，并且为什么，以及您是否确实考虑了这些额外指令导致的执行延迟。
更新
关于 ticks -= 1 崩溃..不知道，没有意义，所以你必须进入调试器并在机器级别找出真正的原因。
但是整个事情没有多大意义，因为您试图通过 C 表达式拆分循环延迟参数 ticks_d，例如 if (padding == ...) 的块。那些条件测试将比实际填充值花费更多的周期，所以没有必要调用 NOPx(); 来进一步延迟，因为你已经延迟了几十个周期。
现在我终于发现 double Olaf 提到，仅此一项（将剩余数学转换为整数）当然会导致巨大的性能损失，甚至可能在数百个周期内。所以整个 void delay_cycles(const double ticks_d) 实际上会比你预期的延迟更多的周期，ASM 部分在总时间中可以忽略不计（除了内部循环每个参数值消耗大约 3 个周期，那个可能会增加如果初始参数足够大，总延迟会相当大。
如果你真的需要指令周期的准确性（不是那么常见，上次我确实需要它是在 1990 年左右的 8 位计算机上），你必须在没有 C 的情况下用纯 asm 编写它，并且还要计算 preparation/logic 指令进入延迟 - 理想情况下以固定执行时间方式编写，因此调用 delay_cycles 函数将导致任何 ticks_d 参数值的固定开销。
然后您可以计算该固定开销，然后先执行 ticks -= <overhead>; 以稍后获得准确的延迟。并且您必须从 double 切换到整数，因为 Microblaze CPU 没有 FPU 单元，因此浮点值由整数数学模拟，只是初始转换为 int int ticks = (int)(ticks_d); 必须花费相当多的周期，你应该在调试器中看到，如果你有反汇编视图并通过单指令进入它。
我有一个用 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;
}
仔细想想我真的不明白这些循环应该是 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（假设编译器将使用 r1 for 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 个周期，即使在分支时），为什么不将循环简化为简单的倒计时（并为 input 使用相当原生的 32b 类型）：
1: raddik %[input], %[input], -1
bnei %[input], 1b
然后你有 2 个周期的延迟循环。
但是使用延迟的主要代码...有很多 C 代码，它们也会转换为机器代码指令，并且这些代码也需要一些时间来执行，所以不清楚您在测量什么，并且为什么，以及您是否确实考虑了这些额外指令导致的执行延迟。
更新
关于 ticks -= 1 崩溃..不知道，没有意义，所以你必须进入调试器并在机器级别找出真正的原因。
但是整个事情没有多大意义，因为您试图通过 C 表达式拆分循环延迟参数 ticks_d，例如 if (padding == ...) 的块。那些条件测试将比实际填充值花费更多的周期，所以没有必要调用 NOPx(); 来进一步延迟，因为你已经延迟了几十个周期。
现在我终于发现 double Olaf 提到，仅此一项（将剩余数学转换为整数）当然会导致巨大的性能损失，甚至可能在数百个周期内。所以整个 void delay_cycles(const double ticks_d) 实际上会比你预期的延迟更多的周期，ASM 部分在总时间中可以忽略不计（除了内部循环每个参数值消耗大约 3 个周期，那个可能会增加如果初始参数足够大，总延迟会相当大。
如果你真的需要指令周期的准确性（不是那么常见，上次我确实需要它是在 1990 年左右的 8 位计算机上），你必须在没有 C 的情况下用纯 asm 编写它，并且还要计算 preparation/logic 指令进入延迟 - 理想情况下以固定执行时间方式编写，因此调用 delay_cycles 函数将导致任何 ticks_d 参数值的固定开销。
然后您可以计算该固定开销，然后先执行 ticks -= <overhead>; 以稍后获得准确的延迟。并且您必须从 double 切换到整数，因为 Microblaze CPU 没有 FPU 单元，因此浮点值由整数数学模拟，只是初始转换为 int int ticks = (int)(ticks_d); 必须花费相当多的周期，你应该在调试器中看到，如果你有反汇编视图并通过单指令进入它。