Wie man GCC sagen, dass ein Zeiger-argument ist immer double-word-aligned?

In meinem Programm habe ich eine Funktion, welche eine einfache addition c[0:15] = a[0:15] + b[0:15]. Der Funktionsprototyp lautet:

void vecadd(float * restrict a, float * restrict b, float * restrict c);

Auf unsere 32-bit-embedded-Architektur gibt es eine load/store-option laden/speichern von doppelten Worte, wie:

r16 = 0x4000  ;
strd r0,[r16] ; stores r0 in [0x4000] and r1 in [0x4004]

Den GCC-optimizer erkennt die vector Art der Schleife und erzeugt zwei Zweige der code - eine für den Fall, wo die 3 arrays double-word-aligned (so verwendet er das double load/store-Anweisungen) und die andere für den Fall, dass die arrays sind Wort-ausgerichtet (wobei es nutzt die single-load/store-option).

Das problem ist, dass die Adresse, die Ausrichtung zu überprüfen ist teuer, relativ zu der neben der Teil und das möchte ich beseitigen, indem hinting der compiler, dass a, b und c sind immer 8-ausgerichtet. Gibt es einen Modifikator hinzufügen, um die pointer-Erklärung zu sagen, das der compiler nicht?

Den arrays, die sind verwendet für den Aufruf dieser Funktion haben ausgerichtet(8) Attribut, aber es spiegelt sich nicht in der Funktion code selbst. ist es möglich dieses Attribut hinzufügen, um die Parameter für die Funktion?

Auch wenn mein code unten nicht helfen können (wegen C++), möchten Sie vielleicht printf("%p") &array[0] und &array[1] in deinem code, nur um sicherzugehen, dass das ausrichten wird gehorcht, und pro element - nicht nur auf die array-Startadresse.
ist es eigentlich erforderlich, dass es NICHT richten pro array-element. Es muss schon eine zusammenhängende Reihe von Schwimmern, deren Herkunft 8-ausgerichtet.

InformationsquelleAutor ysap | 2012-03-07

alignment c c99 gcc

10

Wenn die Attribute nicht funktionieren, oder die nicht eine option ....

Ich bin mir nicht sicher, aber versuchen Sie dies:
```
void vecadd (float * restrict a, float * restrict b, float * restrict c)
{
   a = __builtin_assume_aligned (a, 8);
   b = __builtin_assume_aligned (b, 8);
   c = __builtin_assume_aligned (c, 8);

   for ....
```
Sollte GCC sagen, dass der Zeiger ausgerichtet sind. Aus, dass, ob es das macht, was Sie wollen, hängt davon ab, ob der compiler kann diese information effektiv ist, ist es möglicherweise nicht schlau genug: diese Optimierungen sind nicht einfach.

Weitere option könnte sein, wickeln Sie den Schwimmer innerhalb der union müssen auf 8 byte ausgerichtet:
```
typedef union {
  float f;
  long long dummy;
} aligned_float;

void vedadd (aligned_float * a, ......
```
Ich denke, dass sollte Durchsetzung der 8-byte-Ausrichtung, aber wieder, ich weiß nicht, ob der compiler schlau genug ist, es zu benutzen.
- Doh! Ich habe gerade bemerkt auf der nächsten Seite des GCC Handbuch __builtin_assume_aligned. Ich werde Bearbeiten Sie die Antwort.
- Danke, @ams. Dies ist wahrscheinlich die perfekte Lösung. Leider, auf unseren compiler, obwohl kompiliert naja es hat keinen Einfluss auf die Ausgabe und der compiler macht immer noch einmal zu überprüfen, ob die Zeiger ausgerichtet sind oder nicht und wählt die benötigten code-Pfad.
- Wenn jemand kann bestätigen, es funktioniert auf anderen Architekturen, ich nehme an diese Antwort.
- Ihre union Vorschlag, BTW, ist nicht das, was ich Suche, da es jedes element des Arrays 8 ausgerichtet ist, während ich den Umgang mit array von floats. Ich kann jedoch, pack zwei Schwimmern in einem struct zu arbeiten in der gleichen Weise.
- ... ODER kann ich nur werfen ein array mit Fließkommazahlen zu align_float, wenn Sie die Funktion aufrufen. Dies könnte funktionieren, ich werde es einmal versuchen.
- Casting-Sachen rund um wohl einen Schlechten Plan, als Sie erhalten können aliasing-Fehler. Es gibt keinen Grund, Sie nicht haben, können union {float f[100]; long long dummy} aber 🙂
- Dies scheint nicht zu funktionieren auf meinem Core-i7-4765T für dieser einfache code: kompilieren mit gcc -std=c99 test.c -S -masm=intel -O3 -march=native bekomme ich testGood zu verwenden AVX-Vektorisierung, während testBad mit __builtin_assume_aligned nur verwendet x87 Instruktionen.
- Bedenken Sie, dass diese aligned_float union hat Größe=8, und ein array hätte es Polsterung. Sie haben zu werfen die Zeiger auf float* bevor Sie es verwenden können normalerweise. typedef __attribute__((aligned(8))) float aligned_float; arbeitet mit gcc (z.B. als eine Funktion arg), aber die klappern nicht ableiten Ausrichtung ab. godbolt.org/z/tCLkfp (immer Noch auto-vectorizes mit movups, nicht movaps auf x86 zum Beispiel.)
- Nein, wenn Sie Gießen es dann, du machst es falsch. Sie sollten immer die Verwendung der union-dot-notation zugreifen. Ein array ist möglich, und wenn Sie möchten, dass jedes element 8-byte-ausgerichtet, die Polsterung ist selbstverständlich. Dieser Typ funktioniert nicht transparent.
InformationsquelleAutor ams
10

Folgenden ein Stück Beispiel-code habe ich gefunden auf meinem system, ich habe versucht, die folgende Lösung, die auch Ideen von ein paar der Antworten, die früher gegeben: im Grunde erstellen Sie eine union von einer kleinen Reihe von Schwimmern, die mit einer 64-bit-Typ, in diesem Fall eine SIMD Vektor von floats - und rufen Sie die Funktion mit einer Form der Operanden float-arrays:
```
typedef float f2 __attribute__((vector_size(8)));
typedef union { f2 v; float f[2]; } simdfu;

void vecadd(f2 * restrict a, f2 * restrict b, f2 * restrict c);

float a[16] __attribute__((aligned(8)));
float b[16] __attribute__((aligned(8)));
float c[16] __attribute__((aligned(8)));

int main()
{
    vecadd((f2 *) a, (f2 *) b, (f2 *) c);
    return 0;
}
```
Nun der compiler erzeugt nicht das 4-ausgerichtet Zweig.

Jedoch die __builtin_assume_aligned() wäre die bessere Lösung, die Verhinderung der Besetzung und möglichen Nebenwirkungen, wenn es nur funktioniert.

EDIT: ich habe bemerkt, dass die builtin-Funktion ist tatsächlich buggy auf unsere Umsetzung (ich.e, nicht nur es funktioniert nicht, aber es bewirkt, dass die Berechnung Fehler später im code.

InformationsquelleAutor ysap
6

Wie man GCC sagen, dass ein Zeiger-argument ist immer double-word-aligned?

Sieht es aus wie neuere Versionen von GCC haben __builtin_übernehmen_ausgerichtet:
Built-in-Funktion: void * __builtin_assume_aligned (const void *exp, size_t align, ...)

Diese Funktion liefert das erste argument, und kann der compiler davon ausgehen, dass der zurückgegebene Zeiger ist mindestens ausrichten bytes ausgerichtet.
Diese Einbauten können entweder zwei oder drei Argumente, wenn es drei,
das Dritte argument sollte der integer-Typ, und wenn es ungleich null ist
bedeutet Fluchtungsfehler ausgeglichen. Zum Beispiel:
```
void *x = __builtin_assume_aligned (arg, 16);
```
bedeutet, dass der compiler kann davon ausgehen, x, Satz zu arg, ist mindestens 16-byte-ausgerichtet, während:
```
void *x = __builtin_assume_aligned (arg, 32, 8);
```
bedeutet, dass der compiler kann davon ausgehen, für die x, Satz zu arg, das (char *) x - 8 ist ein 32-byte-ausgerichtet.
Basierend auf einige andere Fragen und Antworten auf Stack Overflow circa 2010, scheint es, dass die built-in war nicht verfügbar in GCC 3 und Anfang der GCC-4. Aber ich weiß nicht, wo der cut-off-Punkt ist.
- Danke. Es wurde erwähnt, in ein paar der Antworten hier, und war in den GCC an der Zeit zu Fragen.
InformationsquelleAutor jww

gcc-Versionen wurden dodgy über align() auf einfache Typdefinitionen und arrays. In der Regel tun, was Sie wollen, hätten Sie wickeln Sie die Schwimmer in einem struct, und die darin enthaltenen Schwimmer haben die Ausrichtung Beschränkung.

Mit operator-überladung kann man fast machen diese schmerzlos, es wird jedoch vorausgesetzt du kannst c++ - syntax.

#include <stdio.h>
#include <string.h>

#define restrict __restrict__

typedef float oldfloat8 __attribute__ ((aligned(8)));

struct float8
{
    float f __attribute__ ((aligned(8)));

    float8 &operator=(float _f) { f = _f; return *this; }
    float8 &operator=(double _f) { f = _f; return *this; }
    float8 &operator=(int _f) { f = _f; return *this; }

    operator float() { return f; }
};

int Myfunc(float8 * restrict a, float8 * restrict b, float8 * restrict c);

int MyFunc(float8 * restrict a, float8 * restrict b, float8 * restrict c)
{
    return *c = *a* *b;
}

int main(int argc, char **argv)
{
    float8 a, b, c;

    float8 p[4];

    printf("sizeof(oldfloat8) == %d\n", (int)sizeof(oldfloat8));
    printf("sizeof(float8) == %d\n", (int)sizeof(float8));

    printf("addr p[0] == %p\n", &p[0] );
    printf("addr p[1] == %p\n", &p[1] );

    a = 2.0;
    b = 7.0;
    MyFunc( &a, &b, &c );
    return 0;
}

Danke, @Joe. 1. bin ich nur auf C. 2. mögliche problem sehe ich hier (wie in anderen Kommentaren) ist, dass es scheint, wie bei der Deklaration eines Vektors von float8 Elemente, jedes element 8 ausgerichtet. Dadurch wird eine nicht zusammenhängende Reihe von float-Raum, frei-Raum, usw. Ich nehme an, die printf() p[0] und p[1] zeigen, dass der Tat.

InformationsquelleAutor Joe

1

Ausrichtung Spezifikationen in der Regel nur Arbeit für Ausrichtungen, die kleiner sind als der Basis-Typ des Zeigers, nicht größer.

Ich denke, am einfachsten ist es, zu erklären, Ihre ganze array mit einem alignment-Spezifikation, so etwas wie
```
typedef float myvector[16];
typedef myvector alignedVector __attribute__((aligned (8));
```
(Die syntax nicht richtig sein könnte, habe ich immer Schwierigkeiten haben, zu wissen, wo man diese __attribute__s)

Verwenden und diese Art in Ihrem gesamten code. Für Ihre Funktion, definition, ich würde versuchen,
```
void vecadd(alignedVector * restrict a, alignedVector * restrict b, alignedVector * restrict c);
```
Dies gibt Ihnen eine zusätzliche Dereferenzierung aber das ist nur syntax. So etwas wie *a ist nur ein noop und nur eine moderne Neuinterpretation der Zeiger als Zeiger auf das erste element.
- Danke. Warum nicht setzen Sie das Attribut auf der 1. typedef?
- Ich weiß einfach nicht, wo das Attribut für ein array-Typ. Die syntax ist grausam.
- Folgenden Joe ' s Kommentar, ich denke, die Antwort auf meine Frage oben ist, dass man die 1. typedef wird das array Elemente 8 ausgerichtet ist, und nicht das array selbst (aber natürlich, es wird ausgerichtet werden, aufgrund der Ausrichtung des 1. element). Macht es Sinn?
InformationsquelleAutor Jens Gustedt
-1

Ich es nie benutzt, aber es ist _Attribut_((aligned (8)))

Wenn ich Lesen Sie die Dokumentation, Recht, dann ist es so genutzt:
```
void vecadd(float * restrict a __attribute__((aligned (8))), 
            float * restrict b __attribute__((aligned (8))), 
            float * restrict c __attribute__((aligned (8))));
```
sehen http://ohse.de/uwe/articles/gcc-attributes.html#type-aligned
- Es sei denn, ich es verpasst, dann GCC-Dokumentation und die Seite, die du verlinkt genannten align-Attribut für Variablen und Funktionen, aber nicht für die Funktion Prototyp Parameter. Können Sie dem entsprechenden Abschnitt der Seite, die Sie verlinkt?
- Ich glaube nicht, dass dies funktioniert. Dies teilt dem compiler mit, dass die Zeiger-variable selbst ist 8 byte ausgerichtet.
- Ich kann dies bestätigen nicht kompilieren. error: alignment may not be specified for
- Ich denke, eine Typdefinition der Argumente wird klar, dass die compile-Fehler.
InformationsquelleAutor Jörg Beyer

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.