come fa Malloc a capire l'allineamento?

Question

seguente estratto dal here

pw = (widget *)malloc(sizeof(widget)); 

alloca storage raw. Infatti, la chiamata malloc alloca memoria che è abbastanza grande e opportunamente allineati per contenere un oggetto di tipo widget di

vedi anche fast pImpl da erba Sutter, ha detto:

allineamento. Qualsiasi allineamento di memoria. Ogni memoria che è allocata dinamicamente via nuovo o malloc è garantito per essere correttamente allineato per oggetti di qualsiasi tipo, ma i buffer che non sono allocati dinamicamente non hanno tale garanzia

io sono curioso di questo, come Malloc conosce l'allineamento del tipo personalizzato?

Answer 1

I requisiti di allineamento sono ricorsivi: l'allineamento di qualsiasi struct è semplicemente l'allineamento più grande di uno qualsiasi dei suoi membri e ciò è inteso in modo ricorsivo. Per esempio, e assumendo che l'allineamento di ciascun tipo fondamentale sia uguale alla sua dimensione (questo non è sempre vero in generale), lo struct X { int; char; double; } ha l'allineamento di double e sarà riempito per essere un multiplo della dimensione del doppio (ad esempio 4 (int), 1 (char), 3 (padding), 8 (double)). Lo struct Y { int; X; float; } ha l'allineamento di X, che è il più grande e uguale all'allineamento di double e Y è disposto di conseguenza: 4 (int), 4 (padding), 16 (X), 4 (float), 4 (padding)).

(Tutti i numeri sono solo esempi e potrebbero differire sulla vostra macchina.)

Pertanto, rompendo verso il basso per i tipi fondamentali, abbiamo solo bisogno di conoscere una manciata di allineamenti fondamentali, e tra coloro c'è un ben noto più grande. C++ definisce anche un tipo maxalign_t (penso) il cui allineamento è quell'allineamento più grande.

Tutto malloc() ha bisogno di fare è di scegliere un indirizzo che è un multiplo di tale valore.

Answer 2

L'unica informazione che può essere utilizzata da malloc() è la dimensione della richiesta passata. In generale, potrebbe fare qualcosa come arrotondare la dimensione passata alla potenza maggiore (o uguale) di due, e allineare la memoria in base a quel valore. Potrebbe anche esserci un limite superiore sul valore di allineamento, ad esempio 8 byte.

Quanto sopra è una discussione ipotetica e l'implementazione effettiva dipende dall'architettura della macchina e dalla libreria di runtime che si sta utilizzando. Forse il tuo malloc() restituisce sempre blocchi allineati su 8 byte e non deve mai fare nulla di diverso.

Answer 3

Penso che la parte più rilevante della citazione Herb Sutter è la parte che ho segnato in grassetto:

allineamento. Qualsiasi allineamento di memoria. Ogni memoria che è allocata dinamicamente tramite nuovo o malloc è garantito per essere correttamente allineato per gli oggetti di qualsiasi tipo, ma i buffer che non sono allocati dinamicamente non hanno tale garanzia

Non deve sapere ciò che si digita avere in mente, perché è l'allineamento per qualsiasi tipo. Su un dato sistema, c'è una dimensione di allineamento massima che è sempre necessaria o significativa; ad esempio, un sistema con parole di quattro byte avrà probabilmente un allineamento massimo di quattro byte.

Questo è anche chiaro dal the malloc(3) man-page, che dice in parte:

I malloc() e calloc() funzioni restituiscono un puntatore alla memoria allocata che è opportunamente allineato per qualsiasi tipo di variabile.

Answer 4

1) Allineare al minimo comune multiplo di tutti gli allineamenti. per esempio. se gli interi richiedono un allineamento di 4 byte, ma i puntatori richiedono 8, quindi allocare tutto a 8 byte di allineamento. Questo fa sì che tutto sia allineato.

2) Utilizzare l'argomento dimensione per determinare l'allineamento corretto. Per le dimensioni ridotte è possibile dedurre il tipo, ad esempio malloc(1) (supponendo che le dimensioni di altri tipi non siano 1) sia sempre un carattere. C++ new ha il vantaggio di essere sicuro per tipo e quindi può sempre prendere decisioni di allineamento in questo modo.

Answer 5

precedente per C++ 11 allineamento è stato trattato abbastanza semplice utilizzando il più grande allineamento dove il valore esatto era sconosciuto e malloc/calloc ancora funziona in questo modo. Ciò significa che l'allocazione di malloc è correttamente allineata per qualsiasi tipo.

allineamento errato può causare il comportamento non definito secondo lo standard ma ho visto compilatori x86 essere generosi e solo sanzionare con prestazioni inferiori.

Si noti che è anche possibile modificare l'allineamento tramite le opzioni di compilazione o direttive. (pacchetto pragma per VisualStudio per esempio).

Ma quando si tratta di nuova collocazione, quindi C++ 11 ci porta nuove parole chiave chiamati alignof e alignas. Ecco un codice che mostra l'effetto se l'allineamento massimo del compilatore è maggiore di 1. Il primo posizionamento nuovo è automaticamente buono ma non il secondo.

#include <iostream> 
#include <malloc.h> 
using namespace std; 
int main() 
{ 
     struct A { char c; }; 
     struct B { int i; char c; }; 

     unsigned char * buffer = (unsigned char *)malloc(1000000); 
     long mp = (long)buffer; 

     // First placment new 
     long alignofA = alignof(A) - 1; 
     cout << "alignment of A: " << std::hex << (alignofA + 1) << endl; 
     cout << "placement address before alignment: " << std::hex << mp << endl; 
     if (mp&alignofA) 
     { 
      mp |= alignofA; 
      ++mp; 
     } 
     cout << "placement address after alignment : " << std::hex <<mp << endl; 
     A * a = new((unsigned char *)mp)A; 
     mp += sizeof(A); 

     // Second placment new 
     long alignofB = alignof(B) - 1; 
     cout << "alignment of B: " << std::hex << (alignofB + 1) << endl; 
     cout << "placement address before alignment: " << std::hex << mp << endl; 
     if (mp&alignofB) 
     { 
      mp |= alignofB; 
      ++mp; 
     } 
     cout << "placement address after alignment : " << std::hex << mp << endl; 
     B * b = new((unsigned char *)mp)B; 
     mp += sizeof(B); 
} 

immagino prestazioni di questo codice può essere migliorata con alcune operazioni bit per bit.

EDIT: sostituito costoso modulo di calcolo con operazioni bit per bit. Sperando ancora che qualcuno trovi qualcosa ancora più veloce.