Wie misst man die Programmausführungszeit im ARM Cortex-A8-Prozessor?

Ich verwende einen ARM Cortex-A8-basierten Prozessor namens i.MX515. Es gibt eine Linux Ubuntu 9.10-Distribution. Ich führe eine sehr große Anwendung aus, die in C geschrieben ist und von der ich Gebrauch mache gettimeofday(); Funktionen, um die Dauer meiner Bewerbung zu messen.

main()

{

gettimeofday(start);
....
....
....
gettimeofday(end);

}

Diese Methode war ausreichend, um zu sehen, welche Blöcke meiner Anwendung wie viel Zeit in Anspruch nahmen. Aber jetzt, wo ich versuche, meinen Code sehr gründlich zu optimieren, sehe ich mit der Methode gettimeofday() zur Berechnung der Zeit eine Menge Schwankungen zwischen aufeinanderfolgenden Läufen (Run vor und nach meinen Optimierungen), also bin ich nicht in der Lage um die tatsächlichen Ausführungszeiten zu bestimmen, daher die Auswirkungen meiner Verbesserungen.

Kann mir jemand vorschlagen, was ich tun soll?

Wenn durch Zugriff auf den Zykluszähler (Auf der ARM-Website vorgeschlagene Idee für Cortex-M3) kann mir jemand einen Code zeigen, der mir die Schritte gibt, die ich befolgen muss, um auf den Timer zuzugreifen registriert sich auf Cortex-A8?

Wenn diese Methode nicht sehr genau ist, schlagen Sie bitte einige Alternativen vor.

Vielen Dank

Nachverfolgungen

Follow-up 1: Ich habe das folgende Programm auf Code Sorcery geschrieben, die ausführbare Datei wurde generiert und als ich versuchte, auf dem Board zu laufen, bekam ich – Illegal Instruction Message 🙁

static inline unsigned int get_cyclecount (void)
{
    unsigned int value;
    // Read CCNT Register
    asm volatile ("MRC p15, 0, %0, c9, c13, 0\t\n": "=r"(value));
    return value;
}

static inline void init_perfcounters (int32_t do_reset, int32_t enable_divider)
{
    // in general enable all counters (including cycle counter)
    int32_t value = 1;

    // peform reset:
    if (do_reset)
    {
    value |= 2;     // reset all counters to zero.
    value |= 4;     // reset cycle counter to zero.
    }

    if (enable_divider)
    value |= 8;     // enable "by 64" divider for CCNT.

    value |= 16;

    // program the performance-counter control-register:
    asm volatile ("MCR p15, 0, %0, c9, c12, 0\t\n" :: "r"(value));

    // enable all counters:
    asm volatile ("MCR p15, 0, %0, c9, c12, 1\t\n" :: "r"(0x8000000f));

    // clear overflows:
    asm volatile ("MCR p15, 0, %0, c9, c12, 3\t\n" :: "r"(0x8000000f));
}



int main()
{

    /* enable user-mode access to the performance counter*/
asm ("MCR p15, 0, %0, C9, C14, 0\n\t" :: "r"(1));

/* disable counter overflow interrupts (just in case)*/
asm ("MCR p15, 0, %0, C9, C14, 2\n\t" :: "r"(0x8000000f));

    init_perfcounters (1, 0);

    // measure the counting overhead:
    unsigned int overhead = get_cyclecount();
    overhead = get_cyclecount() - overhead;

    unsigned int t = get_cyclecount();

    // do some stuff here..
    printf("\nHello World!!");

    t = get_cyclecount() - t;

    printf ("function took exactly %d cycles (including function call) ", t - overhead);

    get_cyclecount();

    return 0;
}

Follow-up 2: Ich hatte an Freescale geschrieben, um Unterstützung zu erhalten, und sie haben mir die folgende Antwort und ein Programm zurückgeschickt (Ich habe nicht viel davon verstanden)

Hier ist, womit wir Ihnen jetzt helfen können: Ich schicke Ihnen ein Codebeispiel, das einen Stream mit dem UART sendet, aus Ihrem Code scheint es, dass Sie die MPU nicht richtig initieren.

(hash)include <stdio.h>
(hash)include <stdlib.h>

(hash)define BIT13 0x02000

(hash)define R32   volatile unsigned long *
(hash)define R16   volatile unsigned short *
(hash)define R8   volatile unsigned char *

(hash)define reg32_UART1_USR1     (*(R32)(0x73FBC094))
(hash)define reg32_UART1_UTXD     (*(R32)(0x73FBC040))

(hash)define reg16_WMCR         (*(R16)(0x73F98008))
(hash)define reg16_WSR              (*(R16)(0x73F98002))

(hash)define AIPS_TZ1_BASE_ADDR             0x70000000
(hash)define IOMUXC_BASE_ADDR               AIPS_TZ1_BASE_ADDR+0x03FA8000

typedef unsigned long  U32;
typedef unsigned short U16;
typedef unsigned char  U8;


void serv_WDOG()
{
    reg16_WSR = 0x5555;
    reg16_WSR = 0xAAAA;
}


void outbyte(char ch)
{
    while( !(reg32_UART1_USR1 & BIT13)  );

    reg32_UART1_UTXD = ch ;
}


void _init()
{

}



void pause(int time) 
{
    int i;

    for ( i=0 ; i < time ;  i++);

} 


void led()
{

//Write to Data register [DR]

    *(R32)(0x73F88000) = 0x00000040;  // 1 --> GPIO 2_6 
    pause(500000);

    *(R32)(0x73F88000) = 0x00000000;  // 0 --> GPIO 2_6 
    pause(500000);


}

void init_port_for_led()
{


//GPIO 2_6   [73F8_8000] EIM_D22  (AC11)    DIAG_LED_GPIO
//ALT1 mode
//IOMUXC_SW_MUX_CTL_PAD_EIM_D22  [+0x0074]
//MUX_MODE [2:0]  = 001: Select mux mode: ALT1 mux port: GPIO[6] of instance: gpio2.

 // IOMUXC control for GPIO2_6

*(R32)(IOMUXC_BASE_ADDR + 0x74) = 0x00000001; 

//Write to DIR register [DIR]

*(R32)(0x73F88004) = 0x00000040;  // 1 : GPIO 2_6  - output

*(R32)(0x83FDA090) = 0x00003001;
*(R32)(0x83FDA090) = 0x00000007;


}

int main ()
{
  int k = 0x12345678 ;

    reg16_WMCR = 0 ;                        // disable watchdog
    init_port_for_led() ;

    while(1)
    {
        printf("Hello word %x\n\r", k ) ;
        serv_WDOG() ;
        led() ;

    }

    return(1) ;
}

Der Zugriff auf die Leistungsindikatoren ist nicht schwierig, aber Sie müssen sie im Kernel-Modus aktivieren. Standardmäßig sind die Zähler deaktiviert.

Kurz gesagt müssen Sie die folgenden zwei Zeilen innerhalb des Kernels ausführen. Entweder als ladbares Modul oder einfach das Hinzufügen der beiden Zeilen irgendwo in der Board-Init reicht aus:

  /* enable user-mode access to the performance counter*/
  asm ("MCR p15, 0, %0, C9, C14, 0\n\t" :: "r"(1));

  /* disable counter overflow interrupts (just in case)*/
  asm ("MCR p15, 0, %0, C9, C14, 2\n\t" :: "r"(0x8000000f));

Sobald Sie dies getan haben, beginnt der Zykluszähler für jeden Zyklus zu inkrementieren. Überläufe des Registers bleiben unbemerkt und verursachen keine Probleme (außer sie könnten Ihre Messungen durcheinander bringen).

Nun wollen Sie aus dem User-Mode auf den Cycle-Counter zugreifen:

Wir beginnen mit einer Funktion, die das Register liest:

static inline unsigned int get_cyclecount (void)
{
  unsigned int value;
  // Read CCNT Register
  asm volatile ("MRC p15, 0, %0, c9, c13, 0\t\n": "=r"(value));  
  return value;
}

Und Sie möchten höchstwahrscheinlich auch den Teiler zurücksetzen und einstellen:

static inline void init_perfcounters (int32_t do_reset, int32_t enable_divider)
{
  // in general enable all counters (including cycle counter)
  int32_t value = 1;

  // peform reset:  
  if (do_reset)
  {
    value |= 2;     // reset all counters to zero.
    value |= 4;     // reset cycle counter to zero.
  } 

  if (enable_divider)
    value |= 8;     // enable "by 64" divider for CCNT.

  value |= 16;

  // program the performance-counter control-register:
  asm volatile ("MCR p15, 0, %0, c9, c12, 0\t\n" :: "r"(value));  

  // enable all counters:  
  asm volatile ("MCR p15, 0, %0, c9, c12, 1\t\n" :: "r"(0x8000000f));  

  // clear overflows:
  asm volatile ("MCR p15, 0, %0, c9, c12, 3\t\n" :: "r"(0x8000000f));
}

do_reset setzt den Zykluszähler auf Null. Einfach so.

enable_diver aktiviert den 1/64 Zyklusteiler. Ohne dieses gesetzte Flag messen Sie jeden Zyklus. Wenn es aktiviert ist, wird der Zähler alle 64 Zyklen erhöht. Dies ist nützlich, wenn Sie lange Zeiten messen möchten, die sonst zum Überlaufen des Zählers führen würden.

Wie man es benutzt:

  // init counters:
  init_perfcounters (1, 0); 

  // measure the counting overhead:
  unsigned int overhead = get_cyclecount();
  overhead = get_cyclecount() - overhead;    

  unsigned int t = get_cyclecount();

  // do some stuff here..
  call_my_function();

  t = get_cyclecount() - t;

  printf ("function took exactly %d cycles (including function call) ", t - overhead);

Sollte auf allen Cortex-A8-CPUs funktionieren.

Oh – und einige Anmerkungen:

Mit diesen Zählern messen Sie die genaue Zeit zwischen den beiden Anrufen get_cyclecount() einschließlich allem, was in anderen Prozessen oder im Kernel ausgegeben wird. Es gibt keine Möglichkeit, die Messung auf Ihren Prozess oder einen einzelnen Thread zu beschränken.

Ruft auch an get_cyclecount() ist nicht kostenlos. Es wird zu einer einzigen asm-Anweisung kompiliert, aber Bewegungen vom Coprozessor blockieren die gesamte ARM-Pipeline. Der Aufwand ist ziemlich hoch und kann Ihre Messung verfälschen. Glücklicherweise ist auch der Overhead festgelegt, sodass Sie ihn messen und von Ihren Timings abziehen können.

In meinem Beispiel habe ich das für jede Messung gemacht. Machen Sie das in der Praxis nicht. Zwischen den beiden Anrufen wird früher oder später ein Interrupt auftreten und Ihre Messungen noch weiter verzerren. Ich schlage vor, dass Sie den Overhead ein paar Mal auf einem inaktiven System messen, alle Außenstehenden ignorieren und stattdessen eine feste Konstante verwenden.

Sie müssen Ihren Code vor und nach Ihren Optimierungen mit Leistungsanalysetools profilieren.

Konto ist eine Befehlszeile und eine Funktion, mit der Sie Ihre Ressourcen überwachen können. Sie können mehr über die Verwendung und Anzeige der von acct generierten dat-Datei googeln.

Ich werde diesen Beitrag mit anderen Open-Source-Leistungsanalyse-Tools aktualisieren.

Gprof ist ein weiteres solches Werkzeug. Bitte überprüfen Sie die Dokumentation auf dasselbe.

Um die Antwort von Nils zu erweitern, nachdem ein paar Jahre vergangen sind! – Eine einfache Möglichkeit, auf diese Zähler zuzugreifen, ist Bauen Sie den Kernel mit gator. Dieser meldet dann Zählerwerte zur Verwendung mit Rationalisierendas Leistungsanalysetool von ARM.

Es zeigt jede Funktion auf einer Zeitleiste an (was Ihnen einen allgemeinen Überblick über die Leistung Ihres Systems gibt) und zeigt Ihnen genau, wie lange die Ausführung gedauert hat, zusammen mit der CPU in %, die sie belegt hat. Sie können dies mit Diagrammen jedes Zählers vergleichen, den Sie zum Sammeln eingerichtet haben, und CPU-intensive Aufgaben bis auf Quellcodeebene verfolgen.

Streamline funktioniert mit allen Prozessoren der Cortex-A-Serie.

Ich habe in einer Toolchain für ARM7 gearbeitet, die einen Simulator auf Befehlsebene hatte. Das Ausführen von Apps darin könnte Timings für einzelne Zeilen und / oder Asm-Anweisungen liefern. Das war großartig für eine Mikrooptimierung einer bestimmten Routine. Dieser Ansatz ist jedoch wahrscheinlich nicht für die Optimierung einer ganzen App/eines ganzen Systems geeignet.