Как добавить задержку в 150 циклов на ARM?

Я сделал несколько измерений на моем Raspberry PI 2 running delay () для 1–1000000 циклов с коэффициентом 10 и вычислил количество циклов по истечении времени. Это показывает, что без кешей всего одного прохода через пустой цикл более чем достаточно для задержки в 150 циклов (это просто sub + bcs). Один NOP (в последовательности из 150) занимает 32 (всего 5030) циклов без кешей и 1,5 цикла с (всего 226,5). Orr; add; и; mov; orr; add; и; mov; loop также показывает, насколько конвейерным и суперскалярным является ЦП, занимая всего 0,15 цикла на код операции. Не так хорошо, чтобы получить цикл хорошего времени.

В заключение я должен отказаться и просто использовать задержку на основе таймера. На самом деле это быстрее без кешей, чем цикл, который занимает 150 циклов с кешами.

void delay(uint32_t count) {
    uint32_t a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0;
    while(count--) {
// branch icache dcache cycles/loop
// no     no     no     ~507
// no     no     yes      43.005
// no     yes    no        1.005
// no     yes    yes       1.005
// yes    no     no     ~507
// yes    no     yes      43.005
// yes    yes    no        1.005
// yes    yes    yes       1.005
// asm ("");

// branch icache dcache cycles/loop
// no     no     no     ~750
// no     no     yes      67.500
// no     yes    no       16.500
// no     yes    yes      16.500
// yes    no     no     ~750
// yes    no     yes      67.500
// yes    yes    no       16.500
// yes    yes    yes      16.500
// asm ("nop");
// asm ("nop");
// asm ("nop");
// asm ("nop");
// asm ("nop");
// asm ("nop");
// asm ("nop");
// asm ("nop");
// asm ("nop");
// asm ("nop");

// branch icache dcache cycles/loop
// no     no     no     ~505
// no     no     yes      43.500
// no     yes    no        1.500
// no     yes    yes       1.500
// yes    no     no     ~505
// yes    no     yes      43.500
// yes    yes    no        1.500
// yes    yes    yes       1.500
 asm ("orr %0, %0, %0" : "=r" (a) : "r" (a));
 asm ("add %0, %0, %0" : "=r" (b) : "r" (b));
 asm ("and %0, %0, %0" : "=r" (c) : "r" (c));
 asm ("mov %0, %0" : "=r" (d) : "r" (d));
 asm ("orr %0, %0, %0" : "=r" (e) : "r" (e));
 asm ("add %0, %0, %0" : "=r" (f) : "r" (f));
 asm ("and %0, %0, %0" : "=r" (g) : "r" (g));
 asm ("mov %0, %0" : "=r" (h) : "r" (h));

// branch icache dcache cycles/loop
// no     no     no     ~1010
// no     no     yes       85.005
// no     yes    no        18.000
// no     yes    yes       18.000
// yes    no     no     ~1010
// yes    no     yes       85.005
// yes    yes    no        18.000
// yes    yes    yes       18.000
// isb();

// branch icache dcache cycles/loop
// no     no     no     ~5075
// no     no     yes      481.501
// no     yes    no       141.000
// no     yes    yes      141.000
// yes    no     no     ~5075
// yes    no     yes      481.501
// yes    yes    no       141.000
// yes    yes    yes      141.000
// isb();
// isb();
// isb();
// isb();
// isb();
// isb();
// isb();
// isb();
// isb();
// isb();
    }
}

Для задержки вам может потребоваться ПОВТОР МАКРОФУНКЦИИ. Используя цикл во время выполнения, всегда будет оптимизация, и сам цикл тоже стоит времени. Вы можете повторить макрос NOP 150 раз. Не будет ни оптимизации, ни лишних циклов.

Вот шаблон повторяющегося макроса:

#define MACRO_CMB( A , B)           A##B
#define M_RPT(__N, __macro)         MACRO_CMB(M_RPT, __N)(__macro)

#define M_RPT0(__macro)
#define M_RPT1(__macro)             M_RPT0(__macro)   __macro(0)
#define M_RPT2(__macro)             M_RPT1(__macro)   __macro(1)
#define M_RPT3(__macro)             M_RPT2(__macro)   __macro(2)
...
#define M_RPT256(__macro)           M_RPT255(__macro) __macro(255)

Вы можете определить свою инструкцию NOP следующим образом:

#define MY_NOP(__N)                 __asm ("nop");    // or sth like "MOV R0,R0"

Затем вы можете повторить инструкцию 150 раз, просто вызвав это ：

M_RPT(150, MY_NOP);

Он действительно будет выполнен 150 раз.

Надеюсь, это помогло.