Как да добавя забавяне от 150 цикъла на ARM?

Направих няколко измервания на моя Raspberry PI 2 работа delay() за 1-100000000 цикли в коефициенти 10 и изчислих броя на цикъла от изминалото време. Това показва, че без кешове само едно преминаване през празен цикъл е повече от достатъчно за забавяне от 150 цикъла (това е само sub + bcs). Единичен NOP (в последователност от 150) отнема 32 (общо 5030) цикъла без кеш памети и 1,5 цикъла с (общо 226,5). The orr;add;and;mov;orr;add;and;mov; цикъл също така показва колко конвейерна и суперскаларна е CPU, като отнема само 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 пъти.

Надявам се това да е помогнало.