Jak przydzielić pamięć wyrównaną tylko przy użyciu biblioteki standardowej?

Trzy nieco różne odpowiedzi w zależności od tego, jak patrzysz na pytanie:

1) wystarczajÄ ... co na dokĹ ' adne pytanie zadane jest rozwiÄ ... zanie Jonathana Lefflera, z tym, Ĺźe aby zaokrÄ ... gnÄ ... Ä ‡ do 16-wyrównanych, potrzebujesz tylko 15 dodatkowych bajtăłw, a nie 16.

A:

/* allocate a buffer with room to add 0-15 bytes to ensure 16-alignment */
void *mem = malloc(1024+15);
ASSERT(mem); // some kind of error-handling code
/* round up to multiple of 16: add 15 and then round down by masking */
void *ptr = ((char*)mem+15) & ~ (size_t)0x0F;

B:

free(mem);

2) dla bardziej ogólnej funkcji alokacji pamięci, wywołujący nie chce mieć dwóch wskaźników (jeden do użycia i jeden do uwolnienia). Więc przechowujesz wskaźnik do "prawdziwego" bufora poniżej wyrównany bufor.

A:

void *mem = malloc(1024+15+sizeof(void*));
if (!mem) return mem;
void *ptr = ((char*)mem+sizeof(void*)+15) & ~ (size_t)0x0F;
((void**)ptr)[-1] = mem;
return ptr;

B:

if (ptr) free(((void**)ptr)[-1]);

Zauważ, że w przeciwieństwie do (1), gdzie tylko 15 bajtów zostało dodanych do mem, ten kod może faktycznie zmniejszyć wyrównanie, jeśli twoja implementacja zagwarantuje wyrównanie 32-bajtowe z malloc (mało prawdopodobne, ale teoretycznie implementacja C może mieć wyrównany Typ 32-bajtowy). To nie ma znaczenia, jeśli tylko wywołasz memset_16aligned, ale jeśli użyjesz pamięci do struktury, to może to mieć znaczenie.

Nie jestem oczywiście poza tym, jaka jest dobra poprawka (poza ostrzeżeniem użytkownika, że zwrócony bufor nie musi być odpowiedni dla dowolnych struktur), ponieważ nie ma możliwości programowego określenia, jaka jest gwarancja wyrównania specyficzna dla implementacji. Domyślam się, że przy starcie można przydzielić dwa lub więcej 1-bajtowych buforów i założyć, że najgorsze wyrównanie, które widzisz, to wyrównanie gwarantowane. Jeśli się mylisz, marnujesz pamięć. Kto ma lepszy pomysł, niech powie więc...

[Dodano : "Standardowa" sztuczka polega na stworzeniu Unii "typów, które mogą być maksymalnie wyrównane" w celu określenia wymaganego wyrównania. Maksymalnie wyrównane typy mogą być (w C99) 'long long', 'long double', 'void *', lub ' void (*)(void)'; Jeśli włączysz <stdint.h>, Możesz prawdopodobnie użyć 'intmax_t ' zamiast long long (i, na maszynach Power 6 (AIX), intmax_t da ci 128-bitowy Typ integer). Wymagania dostosowawcze dla tej unii można określić poprzez włączenie jej do struktura z pojedynczym znakiem, po którym następuje Unia:

struct alignment
{
    char     c;
    union
    {
        intmax_t      imax;
        long double   ldbl;
        void         *vptr;
        void        (*fptr)(void);
    }        u;
} align_data;
size_t align = (char *)&align_data.u.imax - &align_data.c;

Następnie należy użyć większego z żądanego wyrównania (w przykładzie 16) i align obliczonej powyżej wartości.

NA (64-bitowym) Solarisie 10 wygląda na to, że podstawowe wyrównanie dla wyniku malloc() jest wielokrotnością 32 bajtów.
]

W praktyce alokatory wyrównane często przyjmują parametr wyrównania, a nie są podłączone do sieci. Więc użytkownik przejdzie w wielkości struktury, którą mu zależy o (lub najmniejszej mocy 2 większej lub równej temu) i wszystko będzie dobrze.

3) Użyj tego, co zapewnia twoja platforma: posix_memalign dla POSIX, _aligned_malloc Dla Windows.

4) Jeśli używasz C11, To najczystszą - przenośną i zwięzłą - opcją jest użycie funkcji biblioteki standardowej aligned_alloc to zostało wprowadzone w tej wersji specyfikacji języka.

Możesz też spróbować posix_memalign() (Oczywiście na platformach POSIX).

Oto alternatywne podejście do części "zaokrąglić". Nie jest to najlepiej zakodowane rozwiązanie, ale wykonuje zadanie, a tego typu składnia jest nieco łatwiejsza do zapamiętania(plus działa na wartości wyrównania, które nie są potęgą 2). Rzut uintptr_t był konieczny, aby uspokoić kompilator; arytmetyka wskaźnikowa nie jest zbyt lubiana w dzieleniu lub mnożeniu.

void *mem = malloc(1024 + 15);
void *ptr = (void*) ((uintptr_t) mem + 15) / 16 * 16;
memset_16aligned(ptr, 0, 1024);
free(mem);

Niestety, w C99 wydaje się dość trudne, aby zagwarantować dostosowanie dowolnego rodzaju w sposób, który byłby przenośny w każdej implementacji C zgodnej z C99. Dlaczego? Ponieważ wskaźnik nie jest gwarantowany jako "adres bajtowy", można sobie wyobrazić z płaskim modelem pamięci. Podobnie jak reprezentacja uintptr_t nie jest tak gwarantowana, która sama w sobie jest typem opcjonalnym.

Możemy wiedzieć o niektórych implementacjach, które używają reprezentacji dla void * (i przez definition, także char * ), który jest prostym adresem bajtowym, ale przez C99 jest nieprzejrzysty dla nas, programistów. Implementacja może reprezentować wskaźnik przez zbiór {segment, offset} gdzie offset może mieć wyrównanie "w rzeczywistości."Dlaczego, wskaźnik może być nawet jakąś formą wartości wyszukiwania tabel hash lub nawet wartością wyszukiwania linked-list. Może zakodować informacje o granicach.

W ostatnim projekcie c1x dla standardu C widzimy _alignas Słowo kluczowe. To może trochę pomóc.

Jedyną gwarancją, jaką daje nam C99, jest to, że funkcje alokacji pamięci zwrócą wskaźnik odpowiedni do przypisania do wskaźnika wskazującego na dowolny typ obiektu. Ponieważ nie możemy określić wyrównania obiektów, nie możemy zaimplementować własnych funkcji alokacji z odpowiedzialnością za wyrównanie w dobrze zdefiniowany, przenośny sposób.

Dobrze byłoby się mylić co do tego twierdzenia.

Na froncie wypełnienia o liczbie bajtów 16 vs 15, rzeczywista liczba, którą musisz dodać, aby uzyskać wyrównanie N, wynosi max(0,N-M) gdzie M jest naturalnym wyrównaniem alokatora pamięci (i oba są potęgami 2).

Ponieważ minimalne wyrównanie pamięci dowolnego alokatora wynosi 1 bajt, 15=max(0,16-1) jest konserwatywną odpowiedzią. Jeśli jednak wiesz, że alokator pamięci da Ci 32-bitowe wyrównane adresy int( co jest dość powszechne), możesz użyć 12 jako podkładka.

Nie jest to ważne w tym przykładzie, ale może być ważne w systemie wbudowanym z 12K pamięci RAM, gdzie liczy się każda zapisana liczba int.

Najlepszym sposobem na zaimplementowanie go, jeśli zamierzasz próbować zapisać każdy możliwy bajt, jest makro, dzięki któremu możesz go dostosować do swojej macierzystej pamięci. Ponownie, jest to prawdopodobnie przydatne tylko dla systemów wbudowanych, gdzie trzeba zapisać każdy bajt.

W poniższym przykładzie, w większości systemów wartość 1 jest odpowiednia dla MEMORY_ALLOCATOR_NATIVE_ALIGNMENT, jednak dla naszego teoretycznego systemu wbudowanego z 32-bitowymi alokacjami wyrównanymi, następujące mogą zaoszczędzić trochę cennej pamięci:]}

#define MEMORY_ALLOCATOR_NATIVE_ALIGNMENT    4
#define ALIGN_PAD2(N,M) (((N)>(M)) ? ((N)-(M)) : 0)
#define ALIGN_PAD(N) ALIGN_PAD2((N), MEMORY_ALLOCATOR_NATIVE_ALIGNMENT)

Być może byliby zadowoleni ze znajomości memalign ? I jak zauważa Jonathan Leffler, istnieją dwie nowsze funkcje, o których warto wiedzieć.

Robimy takie rzeczy cały czas dla przyspieszenia.framework, mocno wektoryzowana biblioteka OS X / iOS, w której musimy cały czas zwracać uwagę na wyrównanie. Istnieje sporo opcji, jedna lub dwie z nich nie widziałem wymienione powyżej.

Najszybszą metodą dla takiej małej tablicy jest przyklejenie jej na stos. Z GCC / clang:

 void my_func( void )
 {
     uint8_t array[1024] __attribute__ ((aligned(16)));
     ...
 }

Nie jest wymagana funkcja free (). Zazwyczaj są to dwie instrukcje: odjmij 1024 ze wskaźnika stosu, then I wskaźnik stosu / align = "left"/ Prawdopodobnie żądający potrzebował danych na stercie, ponieważ jego żywotność tablicy przekroczyła stos lub rekurencja jest w pracy lub przestrzeń stosu jest na poważnej premii.

Na OS X / iOS wszystkie połączenia do malloc/calloc / etc. są zawsze wyrównane 16 bajtów. Jeśli na przykład potrzebujesz wyrównania 32 bajtów dla AVX, możesz użyć posix_memalign:

void *buf = NULL;
int err = posix_memalign( &buf, 32 /*alignment*/, 1024 /*size*/);
if( err )
   RunInCirclesWaivingArmsWildly();
...
free(buf);

Niektórzy wspominali o interfejsie C++, który działa podobnie.

Nie należy zapominać, że strony są wyrównane do dużych potęg dwóch, więc bufory wyrównane do strony są wyrównane do 16 bajtów. Tak więc, mmap () i valloc () oraz inne podobne interfejsy są również opcjami. mmap () ma tę zaletę, że bufor może być prenitializowany z czymś niezerowym, jeśli chcesz. Ponieważ mają one Rozmiar wyrównany do strony, nie otrzymasz z nich minimalnej alokacji i prawdopodobnie będzie to spowodowane błędem maszyny Wirtualnej przy pierwszym dotknięciu.

#include <stdint.h>
void My_func( uint8_t *tempBuf, ... )
{
    uint8_t *alignedBuf = (uint8_t*) 
                          (((uintptr_t) tempBuf + ((uintptr_t)alignment-1)) 
                                        & -((uintptr_t) alignment));
    ...
}

dodanie alignment - 1 spowoduje przesunięcie wskaźnika poza pierwszy adres wyrównany, a następnie dodanie-alignment (np. 0xfff...ff0 Dla wyrównania=16) przywraca go do wyrównanego adresu.

Jako opisane przez inne posty, w innych systemach operacyjnych Bez 16-bajtowych gwarancji wyrównania, możesz wywołać malloc z większym rozmiarem, odstawić wskaźnik za free() później, a następnie wyrównać jak opisano bezpośrednio powyżej i użyć wyrównanego wskaźnika, tak jak opisano w przypadku naszego bufora temp.

Jeśli chodzi o aligned_memset, to jest to raczej głupie. Musisz tylko zapętlić do 15 bajtów, aby dotrzeć do wyrównanego adresu, a następnie przejść do wyrównanych sklepów z możliwym kodem czyszczenia na koniec. Można nawet czyścić bity w kodzie wektorowym, albo jako nieprzypisane sklepy, które nakładają się na wyrównany region (pod warunkiem, że długość jest co najmniej długością wektora) lub za pomocą czegoś takiego jak movmaskdqu. Ktoś jest leniwy. Jest to jednak prawdopodobnie rozsądne pytanie, jeśli ankieter chce wiedzieć, czy czujesz się komfortowo z stdint.H, operatory bitowe i podstawy pamięci, więc wymyślony przykład można wybaczyć.

Jestem zaskoczony, że nikt nie głosował Shao 's odpowiedź , że, jak rozumiem, niemożliwe jest wykonanie tego, o co prosi się w standardzie C99, ponieważ konwersja wskaźnika na typ całkowy formalnie jest niezdefiniowanym zachowaniem. (Oprócz standardu umożliwiającego konwersję uintptr_t void*, ale standard nie wydaje się pozwalać na jakiekolwiek manipulacje wartością uintptr_t, a następnie jej konwersję z powrotem.)

Użycie memalign, Aligned-Memory-Blocks może być dobrym rozwiązaniem problemu.

Pierwszą rzeczą, która wpadła mi do głowy podczas czytania tego pytania, było zdefiniowanie wyrównanej struktury, utworzenie jej instancji, a następnie wskazanie na nią.

Czy Jest jakiś fundamentalny powód, dla którego tęsknię, skoro nikt inny tego nie zasugerował?

Jako notatka boczna, ponieważ użyłem tablicy znaków (zakładając, że znak systemu jest 8 bitów (tj. 1 bajt)), nie widzę potrzeby atrybutu ((spakowany)) koniecznie (popraw mnie, jeśli się mylę), ale i tak go wstawiłem.

To działa na dwóch systemy próbowałem go na, ale jest możliwe, że jest optymalizacja kompilatora, że jestem nieświadomy dając mi fałszywych pozytywów vis-a-vis skuteczności kodu. Używałem gcc 4.9.2 na OSX i GCC 5.2.1 na Ubuntu.

#include <stdio.h>
#include <stdlib.h>

int main ()
{

   void *mem;

   void *ptr;

   // answer a) here
   struct __attribute__((packed)) s_CozyMem {
       char acSpace[16];
   };

   mem = malloc(sizeof(struct s_CozyMem));
   ptr = mem;

   // memset_16aligned(ptr, 0, 1024);

   // Check if it's aligned
   if(((unsigned long)ptr & 15) == 0) printf("Aligned to 16 bytes.\n");
   else printf("Rubbish.\n");

   // answer b) here
   free(mem);

   return 1;
}

MacOS X specific:

1. wszystkie wskaźniki przypisane do malloc są wyrównane do 16 bajtów.

2. C11 jest obsługiwany, więc możesz po prostu wywołać aligned_malloc (16, size).

3. MacOS X wybiera kod, który jest zoptymalizowany pod kątem poszczególnych procesorów w czasie rozruchu dla memset, memcpy i memmove, a ten kod wykorzystuje sztuczki, o których nigdy nie słyszałeś, aby uczynić go szybkim. 99% szans, że memset działa szybciej niż jakikolwiek ręcznie napisany memset16, co sprawia, że całe pytanie jest bezcelowe.

Jeśli chcesz 100% przenośnego rozwiązania, przed C11 nie ma żadnego. Ponieważ nie ma przenośnego sposobu na testowanie wyrównania wskaźnika. Jeśli nie musi być w 100% przenośny, możesz użyć

char* p = malloc (size + 15);
p += (- (unsigned int) p) % 16;

Zakłada się, że wyrównanie wskaźnika jest przechowywane w najniższych bitach podczas konwersji wskaźnika na niepodpisaną liczbę całkowitą. Konwersja do niepodpisanej liczby całkowitej traci informacje i jest zdefiniowana w implementacji, ale to nie ma znaczenia, ponieważ nie konwertujemy wyniku z powrotem na wskaźnik.

Najgorsze jest to, że oryginalny wskaźnik musi być gdzieś zapisany, aby wywołać z nim funkcję free (). Podsumowując, naprawdę wątpiłbym w mądrość tego projektu.

Wystarczy użyć memalign? http://linux.die.net/man/3/memalign

Możesz także dodać jakieś 16 bajtów, a następnie wcisnąć oryginalny ptr do 16 bitów, dodając (16-mod) jak poniżej wskaźnika:

main(){
void *mem1 = malloc(1024+16);
void *mem = ((char*)mem1)+1; // force misalign ( my computer always aligns)
printf ( " ptr = %p \n ", mem );
void *ptr = ((long)mem+16) & ~ 0x0F;
printf ( " aligned ptr = %p \n ", ptr );

printf (" ptr after adding diff mod %p (same as above ) ", (long)mem1 + (16 -((long)mem1%16)) );


free(mem1);
}

Jeśli istnieją ograniczenia, że nie można zmarnować jednego bajtu, To rozwiązanie to działa: Uwaga: jest przypadek, w którym można to wykonać w nieskończoność: D

   void *mem;  
   void *ptr;
try:
   mem =  malloc(1024);  
   if (mem % 16 != 0) {  
       free(mem);  
       goto try;
   }  
   ptr = mem;  
   memset_16aligned(ptr, 0, 1024);

Do rozwiązania użyłem koncepcji wyściółki, która wyrównuje pamięć i nie marnuje pamięć pojedynczego bajtu .

Jeśli istnieją ograniczenia, nie można zmarnować ani jednego bajtu. Wszystkie wskaźniki przypisane do malloc są wyrównane do 16 bajtów.

C11 jest obsługiwany, więc możesz po prostu wywołać aligned_malloc (16, size).

void *mem = malloc(1024+16);
void *ptr = ((char *)mem+16) & ~ 0x0F;
memset_16aligned(ptr, 0, 1024);
free(mem);

long add;   
mem = (void*)malloc(1024 +15);
add = (long)mem;
add = add - (add % 16);//align to 16 byte boundary
ptr = (whatever*)(add);