più veloce possibile struct-di-array per array-di-Structs conversione

Question

ho una struttura che assomiglia a questo:

struct SoA 
{ 
    int arr1[COUNT]; 
    int arr2[COUNT]; 
}; 

E voglio farlo sembrare come questo:

struct AoS 
{ 
    int arr1_data; 
    int arr2_data; 
}; 

std::vector<AoS> points; 

come rapidamente possibile. L'ordine deve essere conservato.

Costruisce ciascun oggetto AoS singolarmente e lo spinge indietro nel modo più veloce per farlo, oppure esiste un'opzione più veloce?

SoA before; 
std::vector<AoS> after; 

for (int i = 0; i < COUNT; i++) 
    points.push_back(AoS(after.arr1[i], after.arr2[i])); 

ci sono SOA/AoS relative domande su StackOverflow, ma non ho trovato uno correlate a più rapida possibile conversione. A causa delle differenze di impaginazione strutturale non riesco a vedere alcun modo per evitare di copiare i dati da un formato all'altro, ma spero che qualcuno possa dirmi che esiste un modo per fare semplicemente riferimento ai dati in modo diverso ed evitare una copia.

Off the wall soluzioni particolarmente incoraggiate.

Answer 1

Il layout binario di SoA e AoS[]/std::vector<AoS> è diverso, quindi non c'è davvero alcun modo di trasformare l'uno con l'altro senza operazioni di copia.

Il codice che hai è abbastanza vicino a quello ottimale - un miglioramento forse per il pre-allocazione del vettore con il numero previsto di elementi. In alternativa, prova l'array raw con sia la costruzione dell'intero elemento sia l'inizializzazione per proprietà. Le modifiche devono essere misurate con attenzione (misurate sicuramente usando la build completamente ottimizzata con le dimensioni dell'array che vi aspettate) e ponderate con la leggibilità/correttezza del codice.

Se non è necessario il layout binario esatto (sembra che sia il caso in cui si utilizza il vettore) si potrebbe essere in grado di ottenere una sintassi similare creando coppie di classi personalizzate che potrebbero esporre i dati esistenti in modo diverso. Questo eviterà di copiare del tutto.

Si avrebbe bisogno tipo "vettore" (fornire indicizzazione/iterazione su istanza di SoA) e di tipo "elemento" (inizializzato con referece per esempio di SOA e indice, esponendo di accesso per i campi separati in tale indice)

Schizzo approssimativo del codice (aggiungere iteratori, ...):

class AoS_Element 
{ 
    SoA& soa; 
    int index; 
public: 
    AoS_Element(SoA& soa, int index) ... 
    int arr1_data() { return soa.arr1[index];} 
    int arr2_data() { return soa.arr2[index];} 
} 

class AoS 
{ 
    SoA& soa; 
public: 
    AoS(SoA& _soa):soa(_soa){} 
    AoS_Element operator[](int index) { return AoS_Element(soa, index);} 
}