Dimensioni C equivalenti per macro

Question

Quindi sto ottimizzando del codice srotolando alcuni loop (sì, so che dovrei fare affidamento sul mio compilatore per farlo, ma non sto lavorando con la mia scelta di compilatori) e Volevo farlo con un po 'di grazia in modo che, nel caso in cui le mie dimensioni dei dati dovessero cambiare a causa di alcune modifiche in futuro, il codice si degraderebbe elegantemente.

Qualcosa di simile:

typedef struct { 
    uint32_t alpha; 
    uint32_t two; 
    uint32_t iii; 
} Entry; 

/*...*/ 

uint8_t * bytes = (uint8_t *) entry; 
#define PROCESS_ENTRY(i) bytes[i] ^= 1; /*...etc, etc, */ 
#if (sizeof(Entry) == 12) 
    PROCESS_ENTRY(0);PROCESS_ENTRY(1);PROCESS_ENTRY(2); 
    PROCESS_ENTRY(3);PROCESS_ENTRY(4);PROCESS_ENTRY(5); 
    PROCESS_ENTRY(6);PROCESS_ENTRY(7);PROCESS_ENTRY(8); 
    PROCESS_ENTRY(9);PROCESS_ENTRY(10);PROCESS_ENTRY(11); 
#else 
# warning Using non-optimized code 
    size_t i; 
    for (i = 0; i < sizeof(Entry); i++) 
    { 
     PROCESS_ENTRY(i); 
    } 
#endif 
#undef PROCESS_ENTRY 

Questo non funziona, naturalmente, dal momento sizeof non è disponibile per il pre-processore (almeno, questo è quello che sembrava this answer per indicare).

C'è una soluzione facile che posso usare per ottenere la sizeof una struttura dati da usare con una macro C, o sono solo SOL?

Answer 1

Non è possibile fallo nel preprocessore, ma non è necessario. Basta generare una pianura if nella macro:

#define PROCESS_ENTRY(i) bytes[i] ^= 1; /*...etc, etc, */ 
if (sizeof(Entry) == 12) { 
    PROCESS_ENTRY(0);PROCESS_ENTRY(1);PROCESS_ENTRY(2); 
    PROCESS_ENTRY(3);PROCESS_ENTRY(4);PROCESS_ENTRY(5); 
    PROCESS_ENTRY(6);PROCESS_ENTRY(7);PROCESS_ENTRY(8); 
    PROCESS_ENTRY(9);PROCESS_ENTRY(10);PROCESS_ENTRY(11); 
} else { 
    size_t i; 
    for (i = 0; i < sizeof(Entry); i++) { 
     PROCESS_ENTRY(i); 
    } 
} 

sizeof è un'espressione costante, e il confronto costante contro la costante è anche costante. Qualsiasi compilatore C sane ottimizzerà il ramo che è sempre falso in fase di compilazione - la piegatura costante è una delle ottimizzazioni di base. Perdi lo #warning, però.

Answer 2

Se si utilizza autoconf o un altro sistema di configurazione di build, è possibile controllare la dimensione delle strutture di dati al momento della configurazione e scrivere le intestazioni (come #define SIZEOF_Entry 12). Naturalmente questo diventa più complicato durante la compilazione incrociata e così via, ma presumo che le tue architetture di costruzione e di destinazione siano le stesse.

Altrimenti si, sei sfortunato.

Answer 3

Se si desidera la dimensione più piccola possibile per la struttura (o per allinearla a un limite di 4 byte o qualsiasi altra cosa), è possibile utilizzare gli attributi impacchettati o allineati.

In Visual C++, è possibile utilizzare #pragma pack, e nel GCC è possibile utilizzare __attribute __ ((al sacco)) e __attribute __ ((allineato (num-bytes))

Answer 4

Sei fuori di fortuna -. Il preprocessore non sa nemmeno quale sia una struttura, per non parlare di come risolverne le dimensioni

In un caso come questo si può semplicemente definire una costante a ciò che si conosce per conoscere la dimensione della struttura, quindi asserire staticamente che è effettivamente uguale alla dimensione usando il trucco dell'array di dimensioni negative

Inoltre si potrebbe provare solo a fare if (sizeof(Entry) == 12) e vedere se il compilatore è in grado di valutare le condizioni del ramo al momento della compilazione e rimuovere il codice morto. Non è una grande domanda.

Answer 5

Questo probabilmente non aiuterà, ma se avete la possibilità di fare questo in C++ è possibile utilizzare un modello per causare il compilatore che vengano avviati al ciclo appropriata al momento della compilazione:

template <std::size_t SizeOfEntry> 
void process_entry_loop(...) 
{ 
    // ... the nonoptimized version of the loop 
} 

template <> 
void process_entry_loop<12>(...) 
{ 
    // ... the optimized version of the loop 
} 

// ... 

process_entry_loop<sizeof(Entry)>(...); 

Answer 6

Vengono in mente altri due approcci: scrivere una piccola app per scrivere il ciclo srotolato o utilizzare una variazione su Duff's device con le dimensioni previste della struttura.