C sizeof equivalent for macros

Question

Así que estoy optimizando algunos códigos desenrollando algunos loops (sí, sé que debo confiar en mi compilador para hacer esto por mí, pero no estoy trabajando con mi elección de compiladores) y Quería hacerlo con elegancia, de modo que, en caso de que el tamaño de mis datos cambie debido a algunas ediciones en el futuro, el código se degradará elegantemente.

Algo así como:

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 

Esto no funciona, por supuesto, ya sizeof no está disponible para el pre-procesador (al menos, eso es lo que parecía indicar this answer).

¿Existe una solución fácil que pueda usar para obtener sizeof una estructura de datos para usar con una macro C, o solo soy SOL?

Answer 1

No se puede hazlo en el preprocesador, pero no es necesario. Sólo generar una llanura if en su 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 es una expresión constante, y la comparación de una constante contra la constante también es constante. Cualquier compilador C sano optimizará la ramificación que siempre es falsa en tiempo de compilación. El plegado constante es una de las optimizaciones más básicas. Sin embargo, pierdes el #warning.

Answer 2

Si usa autoconf u otro sistema de configuración de compilación, puede verificar el tamaño de las estructuras de datos en el momento de la configuración y escribir encabezados (como #define SIZEOF_Entry 12). Por supuesto, esto se vuelve más complicado cuando se compila de forma cruzada y eso, pero asumo que las arquitecturas de compilación y destino son las mismas.

De lo contrario sí, no tiene suerte.

Answer 3

Si desea el tamaño más pequeño posible para la estructura (o para alinearlo con un límite de 4 bytes, o lo que sea), puede usar los atributos empaquetados o alineados.

En Visual C++, puede utilizar #pragma pack, y en GCC puede utilizar __attribute __ ((lleno)) y __ __attribute ((alineado (num-bytes))

Answer 4

Usted está de suerte -. Preprocesador ni siquiera sabe qué es una estructura, y mucho menos forma de calcular su tamaño.

En un caso como este, puede definir una constante a lo que sabe el tamaño de la estructura, entonces afirmar estáticamente que en realidad es igual al tamaño usando el truco de matriz de tamaño negativo.

También podría intentar simplemente haciendo if (sizeof(Entry) == 12), y vea si su compilador es capaz de evaluar la condición de la sucursal en tiempo de compilación y eliminar el código muerto. No es tan grande preguntar.

Answer 5

Esto probablemente no va a ayudar, pero si usted tiene la capacidad de hacer esto en C++ se puede utilizar una plantilla para que el compilador para despachar al bucle apropiada en tiempo de compilación:

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

Otros dos enfoques vienen a la mente: escriba una aplicación pequeña para escribir el ciclo desenrollado, o use una variación en Duff's device con el tamaño esperado de la estructura.