Speicher Ausrichtung von arrays

Ich habe Probleme bei der Angleichung der Speicher für DMA-transfer auf den Cell-Prozessor. Ich brauche die letzten 4 bit der Adresse auf 0 ein.

Ich habe 4 arrays von unsigned int wo jedes element muss ausgerichtet im Speicher, so dass seine (hex) Adresse endet mit einer null.

E. g.

int main()
{
    size_t i;

    static unsigned int a[2] __attribute__ ((aligned (16)));
    static unsigned int b[2] __attribute__ ((aligned (16)));
    static unsigned int c[2] __attribute__ ((aligned (16)));
    static unsigned int d[2] __attribute__ ((aligned (16)));

    for (i = 0; i < 2; ++i) {
        printf("a[%u] = %p\n", &a[i]);
        printf("b[%u] = %p\n", &b[i]);
        printf("c[%u] = %p\n", &c[i]);
        printf("d[%u] = %p\n", &d[i]);
    }

    return 0;
}

Ausgabe:

a[0] = 0x10010b60
b[0] = 0x10010b50
c[0] = 0x10010b40
d[0] = 0x10010b30
a[1] = 0x10010b64
b[1] = 0x10010b54
c[1] = 0x10010b44
d[1] = 0x10010b34

Hier das problem, dass das 2. element jedes array scheint es nicht zu sein, 16-bit-ausgerichtet (Ihre Adresse' - Ende mit einem 4).

Brauche ich die Adressen, die wie folgt Aussehen:

a[0] = 0xXXXXXXX0
b[0] = 0xXXXXXXX0
c[0] = 0xXXXXXXX0
d[0] = 0xXXXXXXX0
a[1] = 0xXXXXXXX0
b[1] = 0xXXXXXXX0
c[1] = 0xXXXXXXX0
d[1] = 0xXXXXXXX0
  • (aligned (16)) bedeutet " ausrichten auf 16-byte-Grenzen.
  • Die Adressen, die Sie haben wollen, enden mit 0. Das heißt, Sie müssen 16-byte-alignment, nicht 16-bit-Ausrichtung. Nur eine Korrektur
InformationsquelleAutor Snps | 2014-04-29
  1. 7

    Ausrichtung-Attribut spezifiziert die Ausrichtung des Variablen oder Struktur Felder, nicht einzelne array-Elemente. Sehen Die Angabe der Attribute von Variablen für details.

    Wenn Sie immer ausrichten wollen zwei ganze zahlen zusammen, können Sie definieren eine Struktur 

    struct dma_transfer {
    unsigned int e0 __attribute__ ((aligned (16)));
    unsigned int e1 __attribute__ ((aligned (16)));
};

    Diese richtet die Elemente auf 16 byte-Grenzen.

    int main(int argc, char **argv)
{
    static struct dma_transfer a;
    static unsigned int b[2];

    printf("a.e0 = %p\n", &a.e0);
    printf("a.e1 = %p\n", &a.e1);
    printf("b[0] = %p\n", &b[0]);
    printf("b[1] = %p\n", &b[1]);

    return 0;
}

    gibt, z.B. 

    a.e0 = 0x601060
a.e1 = 0x601070
b[0] = 0x601080
b[1] = 0x601084

    Aber das bedeutet auch, dass Sie Löcher zwischen den beiden integer-Werte. Auf einem 32-bit system hast, musst du

    | int 4 bytes | Loch 12 bytes |

    | int 4 bytes | Loch 12 bytes |

    InformationsquelleAutor Olaf Dietsche
  2. 5

    Wenn arr ist ein array von 32-bit-Elemente, und die Adresse arr[0] ist 0xXXXXXXX0, dann die Adresse arr[1] unbedingt 0xXXXXXXX4.

    Für Ihren Zweck, Sie benötigen, um arrays von 16-byte-Elemente:

    typedef struct
{
    unsigned int x;
    unsigned char reserved[16-sizeof(unsigned int)];
}
element_t;

static element_t a[2] __attribute__ ((aligned (16)));
static element_t b[2] __attribute__ ((aligned (16)));
static element_t c[2] __attribute__ ((aligned (16)));
static element_t d[2] __attribute__ ((aligned (16)));

    Alternativ kannst du auch einfach unterlassen, die Verwendung von arrays zusammen.

    Verwenden Sie stattdessen die einfachen Variablen, und sagen Sie den compiler an, richten Sie Sie auf 16-bytes:

    static unsigned int a0 __attribute__ ((aligned (16)));
static unsigned int a1 __attribute__ ((aligned (16)));
static unsigned int b0 __attribute__ ((aligned (16)));
static unsigned int b1 __attribute__ ((aligned (16)));
static unsigned int c0 __attribute__ ((aligned (16)));
static unsigned int c1 __attribute__ ((aligned (16)));
static unsigned int d0 __attribute__ ((aligned (16)));
static unsigned int d1 __attribute__ ((aligned (16)));
    InformationsquelleAutor barak manos
  3. 3

    Ich glaube nicht, dass Sie tun können, dass ... Sie versuchen, den compiler zu injizieren extra Polsterung für alighment Zwecke "innen" ein unsigned int. Aber es gibt keinen Raum zu tun, dass alle bits in einer unsigned int sind bereits bei der integer selbst.

    Ich denke, die Lösung ist, wickeln Sie die ganze Zahl in eine Struktur, denn dann können Sie die __attribute__(()) Magie auf der Struktur, und machen eine Reihe von, dass.

    InformationsquelleAutor unwind
Schreibe einen Kommentar