Wie die Multiplikation und addition-Interna in ARM-Cortex-a8?

wie die Verwendung der Multiplikations-akkumulations-Interna von GCC?

float32x4_t vmlaq_f32 (float32x4_t , float32x4_t , float32x4_t);

Kann mir jemand erklären, was die drei Parameter ich übergeben muss dieser Funktion. Ich meine die Quell-und Ziel-Registern und was die Funktion zurückgibt?

Hilfe!!!!!

InformationsquelleAutor der Frage HaggarTheHorrible | 2010-07-13

  1. 19

    Einfach, sagte der vmla Anweisung ist die folgende:

    struct 
{
  float val[4];
} float32x4_t


float32x4_t vmla (float32x4_t a, float32x4_t b, float32x4_t c)
{
  float32x4 result;

  for (int i=0; i<4; i++)
  {
    result.val[i] =  b.val[i]*c.val[i]+a.val[i];
  }

  return result;
}

    - Und all dies stellt in einer einzigen assembler Anweisung 🙂

    Können Sie die NEON-assembler intrinsischen unter anderem in typischen 4x4-matrix-Multiplikationen für 3D-Grafiken wie diese:

    float32x4_t transform (float32x4_t * matrix, float32x4_t vector)
{
  /* in a perfect world this code would compile into just four instructions */
  float32x4_t result;

  result = vml (matrix[0], vector);
  result = vmla (result, matrix[1], vector);
  result = vmla (result, matrix[2], vector);
  result = vmla (result, matrix[3], vector);

  return result;
}

    Das spart ein paar Zyklen, weil Sie nicht haben, fügen Sie die Ergebnisse nach der Multiplikation. Die Zugabe wird so oft verwendet, dass multiplizieren-sammelt hsa mainstream geworden in diesen Tagen (auch x86-hat Sie Hinzugefügt einige neuere SSE-Befehlssatz).

    Außerdem erwähnenswert: Multiplikations-akkumulations-Operationen wie diese sind sehr gemeinsam in der linearen algebra und DSP (digital signal processing) - Anwendungen. ARM war sehr smart und umgesetzt schnell Weg innerhalb der Cortex-A8 NEON-Kern. Dieses fast-path-kicks in, wenn das erste argument (den Akkumulator) eines VMLA Unterricht ist das Ergebnis eines vorausgehenden VML oder VMLA Unterricht. Ich könnte ins detail gehen, aber kurz gesagt eine solche Anweisung Serie läuft vier mal schneller als ein VML - /VADD /VML /VADD-Serie.

    Werfen Sie einen Blick auf meine einfache matrix-Multiplikation: ich habe genau das getan hat. Aufgrund dieses fast-path wird es laufen ungefähr vier mal schneller als Implementierung geschrieben, mit VML und FÜGEN Sie statt VMLA.

    InformationsquelleAutor der Antwort Nils Pipenbrinck

  2. 8

    Google würde für vmlaq_f32 auftauchte die Referenz für die der rvct compiler-tools. Hier ist, was es sagt:

    Vector multiply accumulate: vmla -> Vr[i] := Va[i] + Vb[i] * Vc[i]
...
float32x4_t vmlaq_f32 (float32x4_t a, float32x4_t b, float32x4_t c);

    UND

    Folgende Typen sind definiert, die zum darstellen von Vektoren. NEON-Vektor-Datentypen werden nach dem folgenden Muster:
    <Typ><size>x<Anzahl der lanes>_t
    Zum Beispiel, int16x4_t ist ein Vektor mit vier Bahnen, die jeweils eine signierte 16-bit-Ganzzahl. Tabelle E. 1 listet die Vektor-Datentypen.

    IOW, der Rückgabewert der Funktion wird ein Vektor mit 4 32-bit-floats, und jedes element des Vektors wird berechnet durch die Multiplikation der entsprechenden Elemente der b und cund das hinzufügen der Inhalte der a.

    HTH

    InformationsquelleAutor der Antwort Aidan Cully

  3. 1
    result = vml (matrix[0], vector);
result = vmla (result, matrix[1], vector);
result = vmla (result, matrix[2], vector);
result = vmla (result, matrix[3], vector);

    Diese Sequenz nicht funktioniert, obwohl. Das problem ist, dass die x-Komponente Reichert sich nur in x-moduliert durch die Zeilen der matrix und kann ausgedrückt werden als:

    result.x = vector.x * (matrix[0][0] + matrix[1][0] + matrix[2][0] + matrix[3][0]);

    ...

    Die richtige Reihenfolge wäre:

    result = vml (matrix[0], vector.xxxx);
result = vmla(result, matrix[1], vector.yyyy);

    ...

    NEON-und SSE-nicht gebaut-in-Auswahl für die Felder (dies würde erfordern 8 bit im Unterricht incoding, pro-Vektor-register). GLSL/HLSL zum Beispiel hat diese Art der Ausstattung, so dass die meisten GPUs haben auch.

    Alternativer Weg, um dies zu erreichen wäre:

    result.x = dp4(vector, matrix[0]);
result.y = dp4(vector, matrix[1]);

    ... //und natürlich, die matrix wäre transponieren für diese ergeben dasselbe Ergebnis

    Den mul,madd,madd,madd-Sequenz ist in der Regel bevorzugt, da es nicht erforderlich, schreiben die Maske für das Ziel-register Felder.

    Sonst den code sieht gut aus. =)

    InformationsquelleAutor der Antwort gpudude

Schreibe einen Kommentar