www.mikrocontroller.net

Forum: Compiler & IDEs Geschwindigkeit eines ARM9 mit 180MHz (UDP Checksum-Berechnung)


Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo,

ich wundere mich etwas über die Zeit, die meine Funktionen zur 
Ausführung brauchen. Ohne den Quellcode zu kennen ist es natürlich 
schwer eine Aussage zu machen, aber mir geht es nicht um ein paar 
Prozentpunkte sondern darum, ob ich etwas so gravierend falsch gemacht 
habe, dass die Ausführzeit beispielsweise doppelt so hoch ist wie 
erreichbar.

Als Beispiel meinen ultra light weight TCP/IP Stack der folgendes macht:
- ein paar Felder in den Protokoll Headern setzen (DIX, IP, UDP)
- UDP und IP checksums berechnen (dauert wohl am längsten)
- Header in den TX Buffer kopieren (Daten von 444 Byte sind schon drin).

Das ganze braucht 140us. Der Prozessor Takt ist 180MHz, die Master Clock 
90MHz. Es ist ein AT91SAM9260 MCU mit SDRAM. DCache ist für die TX 
Buffer nicht aktiviert.

Nun meine Fragen:
Hat jemand Erfahrung mit anderen TCP/IP Stack auf einem ähnlichen 
Prozessor und kann mir etwas über die Dauer sagen? Vielleicht hat ja 
auch jemand einen Link oder Buchtipp, wo ich etwas über die Ausführzeit 
von Funktionen und Algorithmen lernen kann oder muss ich selbst durch 
messen und ausprobieren ein Gefühl dafür entwickeln? 140us kommt mir 
ziemlich lang vor und es ist schon sehr hilfreich, wenn man von 
vornherein Zeiten abschätzen kann.

Ich freue mich auf Tipps und Hinweise!
Viele Grüße
Daniel

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe nun nochmal den Checksum algorithmus überarbeitet und dabei die 
Tatsache genutzt, dass man die berechnung von big endian daten auch in 
little endian durchführen kann. somit ist die routine nun fast doppelt 
so schnell (89us). Kommt mir aber immer noch ziemlich lang vor.

Zuvor habe ich die 16bit wörter in little endian umgewandelt zur 
berechnung.

hier der code meiner UDP-checksum routine:
unsigned short eth_chksum_udp (struct PD_typ *RxPd)
{

  int words;
  int i;
  long sum = 0;
  unsigned short *ptr;
  union {
    unsigned char u8[20];
    unsigned short u16[10];
    unsigned long u32[5];
  } header;

/* 
 * assemble pseudo header 
 */
  /* IP addresses */
  header.u32[0] = RxPd->ip_header->srcIP;
  header.u32[1] = RxPd->ip_header->destIP;
  /* append zero-byte */
  header.u8[8] = 0;
  /* protocol-ID */
  header.u8[9] = RxPd->ip_header->prot;
  /* UDP length field */
  header.u16[5] = RxPd->udp_header->length;

/*
 * copy udp-header
 */

  memcpy(header.u8+12, RxPd->udp_header, 6);

  /* zero udp-checksum field */
  header.u16[9] = 0;

/* 
 * calculate checksum
 */

  /* calculation for pseudo and udp header */
  for (i = 0; i < 10; i++) {
    sum += header.u16[i];
    sum += (sum & 0x10000) >> 16;
    sum = sum & 0xffff;
  }

  /* calculate 16-bit words in UDP payload */
  words = ((endians(RxPd->udp_header->length))-8) / 2;

  /* set payload pointer */
  ptr = (unsigned short*) RxPd->PMI_prot;

  /* calculation for UDP payload */
  for (i = 0; i < words; i++) {
    sum += ptr[i];
    sum += (sum & 0x10000) >> 16;
    sum = sum & 0xffff;
  }

  /* if the length is odd, append last byte and a zero-byte */
  if ( (endians(RxPd->udp_header->length)) % 2) {
    sum += ptr[words] & 0xff;
    //most significant byte is zero, useless to add
    sum += (sum & 0x10000) >> 16;
    sum = sum & 0xffff;
  }

  sum = endians((unsigned short)sum);

  if (~sum)
    return (unsigned short) ~sum;

  else 
    return 0xffff;

}

Autor: Tauwetter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sieh Dir doch einmal den Ass.-Code an, der vom Compiler erzeugt wird. Da 
erkennt man am besten, was nicht optimal ablaufen könnte.

Ausdrücke wie: sum += ptr[i]; können u.U. uneffizient sein, wenn ptr nur 
hier gebraucht wird. ptr++ wird ggf. schneller ausgeführt.
Ich weiß nicht, wie groß 'int i' ist. 16bit oder 32bit? Nimm immer den 
Datentyp, den der Prozessor intern verwendet; das sollte hier 32bit 
sein. Andernfalls muß bei jeder Operation ggf. erst auf 32bit erweitert 
werden.
Nutze internes RAM solange es geht; externe Speicherzugriffe brauchen 
eine Ewigkeit. Dein Stack liegt hoffentlich auch im internen RAM?

Und selbst wenn alles optimal übersetzt ist: auch ein 200MHz µC braucht 
seine Zeit für die Programmabarbeitung.

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo Daniel

Daniel G. schrieb:
> Ich habe nun nochmal den Checksum algorithmus überarbeitet und dabei die
> Tatsache genutzt, dass man die berechnung von big endian daten auch in
> little endian durchführen kann. somit ist die routine nun fast doppelt
> so schnell (89us).

Aber die zuerst genannten 140µs waren doch die Zeit, die "das ganze"
(header, check sum, copy) gedauert hat, wenn ich Dich recht verstehe.

Die Routine liest die Daten, kopiert sie aber nicht. Wenn das woanders
nochmal gemacht wird kostet es viel Zeit -- besonders wenn die Daten
nicht im Cache liegen. Aber ich habe gerade etwas den Überblick
verloren, welche Deiner Daten als non-cacheable markiert waren :-)

Soweit ich das sehe, kannst Du die Prüfsumme auch für 32bit Worte
bilden und am Ende auf 16bit zusammenfalten. In beiden Fällen hilft
inline Assembler, mit dem man Zugriff auf das Carry Flag hat. Ist
schon einige Takte flotter als das was man mit einem C compiler
hinbekommt. Bevor Du dort optimierst, solltest Du allerdings unbedingt
die Speicherzugriffe überprüft haben.

Weitere Tips: http://tools.ietf.org/html/rfc1071#section-2

Gruß
Marcus
http://www.doulos.com/arm

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Danke für die Antworten!

das was am gesamten TCP/IP Stack mit EMAC Treiber überhaupt nennenswerte 
Zeit in Anspruch nimmt, ist allein die UDP checksum routine. Der Rest 
braucht nur wenige us.

Die Daten auf die die checksum routine zugreift ist weder cached noch 
buffered, nämlich der EMAC TX buffer Bereich des AT91SAM9260.

Ich weiß noch nicht, in wie weit es Sinn macht, in die Optimierung Zeit 
zu stecken (weil die Latenz möglicherweise schon klein genug ist), aber 
das mit dem zusammenrechnen der 32-bit wörter werde ich mal probieren! 
Auch werde ich mir mal den Assembler code ansehen.

Ich schreibe das Ergebnis, sobald ich es habe!

Viele Grüße,
Daniel

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel G. schrieb:
> Die Daten auf die die checksum routine zugreift ist weder cached noch
> buffered, nämlich der EMAC TX buffer Bereich des AT91SAM9260.

Damit wird jeder Zugriff bestenfalls einen Buszyklus dauern. Wären die
Daten cacheable, würden die Daten der folgenden Schleifeniteration
durch den line-fill dem Core bereits vorliegen sobald dieser sie
benötigt. Können wir davon ausgehen, dass ein Block à acht Worte
(32bit) in diesem Bereich nicht mehr verändert wird, während darauf
lesend zugegriffen wird?

> Ich weiß noch nicht, in wie weit es Sinn macht, in die Optimierung Zeit
> zu stecken (weil die Latenz möglicherweise schon klein genug ist), aber
> das mit dem zusammenrechnen der 32-bit wörter werde ich mal probieren!
> Auch werde ich mir mal den Assembler code ansehen.

Versuchs erstmal mit dem Speicher. Wenn Du dann noch Spaß hast, weiter
zu optimieren kannst Du Dich mit dem Rest beschäftigen.

Gruß
Marcus

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marcus Harnisch schrieb:
> Weitere Tips: http://tools.ietf.org/html/rfc1071#section-2

Habe anhand des Dokuments mal meinen Code überarbeitet. Suche seit 
gestern unermüdlich den Fehler: Die Checksumme wird nur für manche 
Pakete richtig berechnet und teilweise nur genau jedes Zweite mal. 
Konnte leider keine weiteren "Regeln" finden.

Vielleicht kann ja mal jemand in den Code schauen:
unsigned short eth_chksum_udp (struct PD_typ *Pd)
{

  int words;
  int i;
  int udp_payload_length;
  unsigned long sum = 0;
  unsigned long temp;
  unsigned long *ptr;
  
  struct {
    unsigned long srcIP;
    unsigned long destIP;
    unsigned char zero;
    unsigned char prot;
    unsigned short UDP_length;
    unsigned char UDP_header[6];
    unsigned short UDP_chksum;
  } __attribute__ ((packed)) pseudo_header;

/* 
 * assemble pseudo header 
 */
  /* IP addresses */
  pseudo_header.srcIP = Pd->ip_header->srcIP;
  pseudo_header.destIP = Pd->ip_header->destIP;
  /* append zero-byte */
  pseudo_header.zero = 0;
  /* protocol-ID */
  pseudo_header.prot = Pd->ip_header->prot;
  /* UDP length field */
  pseudo_header.UDP_length = Pd->udp_header->length;
  /* copy UDP header exept checksum */
  memcpy(pseudo_header.UDP_header, Pd->udp_header, 6);
  /* zero udp-checksum field */
  pseudo_header.UDP_chksum = 0;

  udp_payload_length = endians(Pd->udp_header->length) - 8;

/* 
 * calculate checksum of pseudo header
 */

  ptr = (unsigned long*) &pseudo_header;

  /* calculation for pseudo and udp header */
  for (i = 0; i < 5; i++) {
    asm volatile (
      "ldr r2, [%[ptr]], #4\n\t"
        "adds %[sum], %[sum], r2\n\t"
      "adc %[sum], %[sum], #0"
      : [sum] "+r" (sum), [ptr] "+r" (ptr)
      :: "r2", "cc"
    );
  }

/* 
 * calculate checksum of data
 */

  /* calculate number of 32-bit words in UDP payload */
  words = udp_payload_length / 4;

  /* set payload pointer */
  ptr = (unsigned long*) Pd->PMI_prot;

  /* calculation for UDP payload */
  for (i = 0; i < words; i++) {
    asm volatile (
      "ldr r2, [%[ptr]], #4\n\t"
        "adds %[sum], %[sum], r2\n\t"
      "adc %[sum], %[sum], #0"
      : [sum] "+r" (sum), [ptr] "+r" (ptr)
      :: "r2", "cc"
    );
  }
  
  /* compute the last word, the length may be odd so that zero bytes
   * have to be appended */
  i = udp_payload_length % 4;
  temp = *ptr;
  temp &= ~(0xffffffff << (i*8));

  asm volatile (
      "adds %[sum], %[sum], %[temp]\n\t"
    "adc %[sum], %[sum], #0"
    : [sum] "+r" (sum)
    : [temp] "r" (temp)
    : "cc"
  );

  /* fold the result to 16 bit */
  temp = sum & 0xffff;
  temp += sum >> 16;
  temp += (temp & 0x10000) >> 16;
  
  sum = endians((unsigned short)temp);

  if (sum < 0xffff)
    return (unsigned short) ~sum;

  else
    return 0xffff;

}

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel G. schrieb:
> Vielleicht kann ja mal jemand in den Code schauen:

Beim Überfliegen ist mir erstmal nichts aufgefallen.

Allerdings kann man das ganze auch elegant mit einem 64bit Akkumulator 
in C implementieren. Das obere Wort summiert die Carries (deferred 
carry). Ein guter Compiler setzt das so um, dass Du Dir dieses 
scheußliche GCC-Inline Assembler Geraffel sparen kannst. Am Ende high 
und low word addieren, und dann noch mal high und low half-word. Oder 
habe ich hier einen Denkfehler gemacht?

Das deferred Carry hat noch einen anderen Vorteil: Die Abhängigkeiten 
zwischen den Iterationen verschwinden. Damit kann das auf performanteren 
CPUs unter Ausnutzung der SIMD Einheiten vektorisiert werden. Für den 
Cortex-A9 übersetzt (mit 32 Bit Akku) sieht das schon ganz lecker aus.

Aber viel wichtiger: DEN CACHE EINSCHALTEN! Da es um Lesezugriffe geht, 
reicht ja WT Konfiguration.

Gruß
Marcus

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marcus Harnisch schrieb:
> Allerdings kann man das ganze auch elegant mit einem 64bit Akkumulator
> in C implementieren. Das obere Wort summiert die Carries (deferred
> carry). Ein guter Compiler setzt das so um, dass Du Dir dieses
> scheußliche GCC-Inline Assembler Geraffel sparen kannst. Am Ende high
> und low word addieren, und dann noch mal high und low half-word. Oder
> habe ich hier einen Denkfehler gemacht?

Vielen Dank für den guten Tipp! Ist GCC denn einer dieser guten 
Compiler? :-) Wie du es sagst, müsste es gehen, so habe ich den 
Algorithmus auch verstanden.

Ich bin den gesamten Assembler code instruction für instruction 
durchgegangen und alles ist genau so wie ich es wollte. Vielleicht ist 
doch etwas an meinem Algorithmus falsch:

1. Die Wörter (32bit) zusammenrechnen und nach jeder addition das carry 
bit, wenn vorhanden, aufaddieren.

2. beide halbwörter addieren und carry dazu addieren.

3. invertieren

Oder funktioniert das mit dem carry aufaddieren im asm code nicht wie 
ich denke?

Um caches kümmere ich mich danach. erstmal diese Baustelle beenden.

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielleicht ist es sinnvoll den Titel zu ändern und zumindest "UDP 
checksum" mit reinzunehmen, wegen der suchfunktion.

Vorschlag: "UDP checksum Geschwindigkeit auf ARM9"

Kann das mal ein Admin bitte machen?

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel G. schrieb:
> Ist GCC denn einer dieser guten Compiler? :-)

Bei oberflächlicher Inspektion sieht der erzeugte Code OK aus. Für 
tiefergehende Untersuchungen hab ich gerade keine Zeit.

Gruß
Marcus

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Habe den Fehler noch finden können: Die Daten auf die ich 32-bit 
Wort-weise zugreifen wollte waren nicht aligned :-| Wenn C durch 
Assembler ersetzt wird, ist das natürlich fatal. Wie konnte mir das nur 
passieren?!?!?!

Werden den Code nun überarbeiten und nur halbe Wörter mit deferred carry 
zusammenzählen. Melde mich dann wieder!

Viele Grüße
Daniel

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel G. schrieb:
> Habe den Fehler noch finden können: Die Daten auf die ich 32-bit
> Wort-weise zugreifen wollte waren nicht aligned :-| Wenn C durch
> Assembler ersetzt wird, ist das natürlich fatal.

Das ist immer fatal -- auch in C (wenn der compiler es nicht 
mitbekommt). Du kannst es bei Deinem Core wenigstens durch einen Fault 
abfangen:
http://infocenter.arm.com/help/topic/com.arm.doc.d...

Hast Du Einfluss auf das Aligment der Daten?

> Werden den Code nun überarbeiten und nur halbe Wörter mit deferred carry
> zusammenzählen.

Halbe Worte? Nun als Referenz vielleicht. Aber denke daran, dass Du 
damit etwa doppelt so viele Speicherzugriffe hast, die wohlgemerkt alle 
über den Systembus und nicht etwa vom Cache :^) bedient werden.

--
Marcus

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marcus Harnisch schrieb:
> Das ist immer fatal -- auch in C (wenn der compiler es nicht
> mitbekommt). Du kannst es bei Deinem Core wenigstens durch einen Fault
> abfangen:
> http://infocenter.arm.com/help/topic/com.arm.doc.d...

DANKE!!! Deine Tipps sind ja Gold wert!

Werde mich heute nochmal an den Code machen und mir eine elegante Lösung 
überlegen. Vielleicht auch mit viel asm weil dann die carries durch adcs 
gleich mit der wort-addition aufaddiert werden können.

ja, ja, die caches mach ich auch an! Muss mich vorher nur noch 
cache-clean kümmern, bevor EMAC per DMA auf die Daten zugreift. :-)

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Habe die Routine nochmal überarbeitet. Nun erreiche ich ohne Caches (die 
ich dann auch noch anschalte) eine Berechnungszeit von etwa 30us für die 
UDP checksum bei einer Paketgröße von 450B.

Der Code besteht aus zwei Teilen: einer Routine (eth_chksum_sum) die die 
one's complement sum berechnet und für UDP und IP benutzt werden kann. 
Und dann eben für IP und UDP die hauptroutine. Hier der Code:


/************************************************
 * UDP CHECKSUM CALCULATION                     *
 ************************************************/

unsigned short eth_chksum_udp (struct PD_typ *Pd)
{

  unsigned int udp_length;
  unsigned long sum;
  
  struct {
    unsigned long srcIP;
    unsigned long destIP;
    unsigned char zero;
    unsigned char prot;
    unsigned short UDP_length;
  } __attribute__((packed, aligned(4))) pseudo_header;


/* 
 * assemble pseudo header 
 */

  /* IP addresses */
  pseudo_header.srcIP = Pd->ip_header->srcIP;
  pseudo_header.destIP = Pd->ip_header->destIP;
  /* append zero-byte */
  pseudo_header.zero = 0;
  /* protocol-ID */
  pseudo_header.prot = Pd->ip_header->prot;
  /* UDP length field */
  pseudo_header.UDP_length = Pd->udp_header->length;


/*
 * calculate checksum
 */
  
  /* UDP frame length in bytes */
  udp_length = endians(Pd->udp_header->length);


  /* pseuso header */
  sum = eth_chksum_sum (&pseudo_header, 12);

  /* UDP header */
  sum += eth_chksum_sum (Pd->udp_header, 6);
  sum += sum >> 16;  //carry
  sum &= 0xffff;

  /* UDP payload */
  sum += eth_chksum_sum (Pd->PMI_prot, udp_length - 8);
  sum += sum >> 16;  //carry
  sum &= 0xffff;

  if (sum < 0xffff)
    return (unsigned short) ~sum;

  else
    return 0xffff;

}


/************************************************
 * One's complement sum                         *
 ************************************************/

unsigned long eth_chksum_sum (void* ptr, unsigned int length) {

/* 
 * the routine assumes, that the data has at least a 16bit
 * alignment. The length of the data can be odd. 
 */

  unsigned long temp = 0, sum = 0;
  unsigned int aligned_bytes, unaligned_bytes;

  /* return if ptr hasn't got at least a 16bit alignment */
  if ((unsigned int)ptr % 2) {
    return 0;
  }

  /* if pointer is not 4B aligned */
  if ((unsigned int)ptr % 4) {
    unaligned_bytes = 2 + ((length - 2) & 3);
    aligned_bytes = length - unaligned_bytes;

    /* add the halfword before the first aligned word */
    sum = *(unsigned short*)ptr;
    
    /* adjust pointer and counter */
    ptr += 2;
    unaligned_bytes -= 2;
  }

  /* if pointer is 4B aligned */
  else {
    unaligned_bytes = length & 3;
    aligned_bytes = length - unaligned_bytes;
  }
  

  /* start calculation */
  if (aligned_bytes) {
    asm volatile (
      /* sum loop */
      "1:"                "\t"
      "ldr  r2, [%[ptr]], #4"      "\n\t"
      "adds  %[sum], %[sum], r2"      "\n\t"
      "adc  %[sum], %[sum], #0"      "\n\t"

      /* check loop termination condition */
      "subs  %[abytes], %[abytes], #4"  "\n\t"
      "bne  1b"              "\n\t"

      :[sum] "+r" (sum), [ptr] "+r" (ptr), [abytes] "+r" (aligned_bytes)
      :: "r2", "cc"
    );
  }

  /* add remaining bytes, if existent */
  if (unaligned_bytes) {
    
    temp = *(unsigned long*)ptr;
    temp &= ~(0xffffffff << (unaligned_bytes*8));

    asm volatile (
      "adds  %[sum], %[sum], %[temp]"  "\n\t"
      "adc  %[sum], %[sum], #0"
      :[sum] "+r" (sum)
      :[temp] "r" (temp)
      : "cc"
    );
  }

  /* fold 32bit sum to 16bit */
  temp = sum & 0xffff;
  temp += sum >> 16;
  temp += temp >> 16;
  sum = temp & 0xffff;

  return sum;

}

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel G. schrieb:
> Habe die Routine nochmal überarbeitet. Nun erreiche ich ohne Caches (die
> ich dann auch noch anschalte) eine Berechnungszeit von etwa 30us für die
> UDP checksum bei einer Paketgröße von 450B.

Sehr schön :-)

> Der Code besteht aus zwei Teilen: einer Routine (eth_chksum_sum) die die
> one's complement sum berechnet und für UDP und IP benutzt werden kann.
> Und dann eben für IP und UDP die hauptroutine.

Ich dachte, das wäre der selbe Algorithmus. Warum zwei Funktionen?

>  Hier der Code:

Das mit dem Alignment würde ich viel pragmatischer angehen (falls das in 
Deinem System möglich ist). Das Aligment des Datenzeigers sollte eine 
Vorbedingung sein. Du könntest Dir einen entsprehenden Typ definieren 
und einen Parameter dieses Typs übergeben.
typedef uint8_t auint8_t __attribute__((aligned(4)));

Warum so viel Assembler. Das ist doch schlecht wartbar und vor allem 
nicht portabel. Vorteile neuer CPUs werden gar nicht ausgenutzt, da die 
Instruktionen hart verdrahtet sind. Der pipeline interlock zwischen dem 
Laden des Halbworts und Summieren ist ebenfalls hart verdrahtet. Ein 
Compiler würde durch geeignete Maßnahmen versuchen, das zu entspannen.

Versuch mal das hier. Sollte nicht erheblich langsamer sein (wenn 
überhaupt) und ist mehr oder weniger lesbar:
uint16_t chksum_32(auint8_t *ptr, uint32_t len)
{
    uint32_t i;
    uint32_t tail;
    uint32_t *wptr;
    uint64_t sum64 = 0;
    uint32_t sum32;
    uint16_t retval;

    if (len == 0)
        return 0xFFFF;

    assert(!((uint32_t)ptr % sizeof(uint32_t))); // ensure proper alignment

    wptr = (uint32_t *)ptr;

    for (i=0; i<len/4; i++) {
        sum64 += wptr[i];
    }

    if (len % 4) {
        // create bitmask to clear trailing bytes that are not part of the
        // data array.
        tail = wptr[i] & ~(0xFFFFFFFF << ((len % 4) * 8));

        sum64 += tail;
    }
    sum64  = (sum64 & 0xFFFFFFFF) + (sum64 >> 32); // Add carries and sum
    sum32  = (sum64 + (sum64 >> 32)) & 0xFFFFFFFF; // Add possible new carry

    sum32  = (sum32 & 0xFFFF) + (sum32 >> 16);     // Fold word into half word
    retval = (sum32 + (sum32 >> 16)) & 0xFFFF;     // Add possible new carry

    if (~retval)
        return ~retval;
    else 
        return 0xffff; 
}

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich schrieb:
> In beiden Fällen hilft inline Assembler, mit dem man Zugriff auf das Carry
> Flag hat. Ist schon einige Takte flotter als das was man mit einem C
> compiler hinbekommt.

Wer schreibt denn so einen Mist ;-)

(Ich hatte zu dieser Zeit noch nicht die Idee mit dem 64bit Akkumulator, 
die sowohl von GCC als auch von RVCT sehr effizient umgesetzt wird)

Gruß
Marcus

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Marcus Harnisch schrieb:
> Ich dachte, das wäre der selbe Algorithmus. Warum zwei Funktionen?

Hast mich nur falsch verstanden: Der algorithmus ist derselbe nur 
aufgerufen wird er von jeweils einer anderen Routine für IP und UDP. Die 
zu sendenden daten liegen noch verstreut und werden erst nach der 
checksummenberechnung zusammengesetzt. Daher kann die checksumme auch 
nicht am stück berechnet werden.

Marcus Harnisch schrieb:
> Der pipeline interlock zwischen dem
> Laden des Halbworts und Summieren ist ebenfalls hart verdrahtet. Ein
> Compiler würde durch geeignete Maßnahmen versuchen, das zu entspannen.

Was meinst Du? Ich lade doch kein Halbwort in asm?! Oder meinst du, dass 
ich nach dem addieren wieder zum laden springe? Wie könnte ein compiler 
das besser machen? die anzahl steht ja nicht fest, so das die schleife 
nicht abgewickelt werden kann.

Danke für den Code, ich werde mich Montag damit auseinander setzen.

Grüße
Daniel

Autor: Marcus Harnisch (mharnisch) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Daniel G. schrieb:
> Was meinst Du? Ich lade doch kein Halbwort in asm?!

Entschuldige, das Wort natürlich. Es gibt zusätzlich zur externen
Speicherlatenz einen sogenannten load-use-interlock zwischen dem LDR
und der anschließenden Addition.  Ich fürchte, das der Compiler hier
nichts mehr optimieren kann. Das ist hier nur ein Taktzyklus, aber ein
gutes Beispiel für eine Optimierungs-Sackgasse durch zu starke
Einschränkung (Vorgabe der Assembler Befehle).

Das ist im Einzelfall durchaus sinnvoll, aber bei diesem einfachen
Algorithmus eher hinderlich wie sich im Laufe dieses Threads
herausstellte.

> Wie könnte ein compiler das besser machen? die anzahl steht ja nicht
> fest, so das die schleife nicht abgewickelt werden kann.

Klar kann sie. Nur für die übrigbleibenden Iterationen muss dann
weiterer Code ausgeführt werden. Du rollst ja die Schleife selbst
schon dadurch ab, dass Du ganze Worte lädst und dadurch zwei Halbworte
pro Iteration bearbeitest. Und am Ende bearbeitest Du das
abschließende Halbwort, falls vorhanden. Der Compiler macht das
ähnlich, nur eben für mehrere Worte.

Bei dem vom RealView Compiler erzeugten Code werden hier zwei Worte
pro Iteration bearbeitet. Durch die nun längere lineare Code Sequenz
hat der Compiler mehr Möglichkeiten die Befehle so umzusortieren, dass
Wartezeiten vermieden werden (z.B. durch Maximierung des Abstands
zwischen Laden und Bearbeiten eines Wortes). So stellt man zum
Beispiel fest, dass das erste Wort bereits vor Eintritt in die
Schleife geladen wird, während in der Schleife bereits das Wort der
nächsten Iteration aus dem Speicher geholt wird. Dadurch lassen sich
Latenzen auch gut verstecken.

Schönes Wochenende
Marcus

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Guten Morgen!

Habe soeben die TX Buffer als write-through eingeschaltet und latenzen 
gemessen. Dabei ist mir aufgefallen, dass ich bei der letzten Messung 
vergessen hatte die compiler optimierung wieder einzuschalten. Die 
genannten 35us bezogen sich also auf ohne cache und ohne compiler 
optimierung.

Mit compiler opt. und cache komme ich jetzt auf etwa 8us für UDP 
checksum erzeugung.

8us sind etwa 1400 prozessor zyklen. 5 instruktionen per wort in der 
schleife in der die wörter zusammengerechnet werden, das sind bei einer 
paketgröße von 450B etwa 550 instruktionen. ldr braucht ein bisschen um 
daten zu holen, vor allem bei einem cache miss. Ein prozessor takt ist 
5,6ns lang. viel ist da wohl nicht mehr rauszuholen.

Ich muss mich erstmal wieder um andere Dinge kümmern, aber wenn ich hier 
noch weitere messungen oder experimente gemacht habe, schreib ich 
wieder!

Autor: Andreas Ferber (aferber)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nur mal so als kleiner Hinweis, wenn es dir auf ein Maximum an 
Geschwindigkeit ankommt, dann lass die Checksumme weg. Siehe RFC 768, 
die Prüfsumme ist bei UDP optional, zum weglassen das Feld im Header auf 
0 setzen.

Andreas

Autor: Daniel G. (motello)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Andreas Ferber schrieb:
> Nur mal so als kleiner Hinweis, wenn es dir auf ein Maximum an
> Geschwindigkeit ankommt, dann lass die Checksumme weg. Siehe RFC 768,
> die Prüfsumme ist bei UDP optional, zum weglassen das Feld im Header auf
> 0 setzen.

Ich weiß, aber ich will wissen ob meine Daten richtig ankommen :-)

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.