Cuál es la forma más eficiente de hacer operaciones bit a bit en una matriz C

Question

tengo una matriz C como:

char byte_array[10]; 

y otra que actúa como una máscara:

char byte_mask[10]; 

me gustaría obtener otra matriz que es el resultado de la primera, más la segunda que utiliza una operación de bit a bit, en cada byte.

¿Cuál es la forma más eficiente de hacer esto?

gracias por sus respuestas.

Answer 1

for (i = 10 ; i-- > 0 ;) 
    result_array[i] = byte_array[i] & byte_mask[i]; 

• Yendo hacia atrás precarga del procesador de caché líneas.
• Incluir la disminución en la comparación puede guardar algunas instrucciones.

Esto funcionará para todas las matrices y procesadores. Sin embargo, si sabe que sus matrices están alineadas con palabras, un método más rápido es convertir a un tipo más grande y hacer el mismo cálculo. Por ejemplo, digamos n=16 en lugar de n=10. Entonces esto sería mucho más rápido:

uint32_t* input32 = (uint32_t*)byte_array; 
uint32_t* mask32 = (uint32_t*)byte_mask; 
uint32_t* result32 = (uint32_t*)result_array; 
for (i = 4 ; i-- > 0 ;) 
    result32[i] = input32[i] & mask32[i]; 

(Por supuesto que necesitan un tipo adecuado para uint32_t, y si n no es una potencia de 2 que necesita para limpiar el inicio y/o fin para que el 32- bit cosas está alineado.)

Variación: La pregunta específicamente requiere que los resultados se coloquen en una matriz separada, sin embargo, sería casi seguro que sería más rápido modificar la matriz de entrada en contexto.

Answer 2

Si desea hacerlo más rápido, asegúrese de que byte_array tiene una longitud que es múltiplo de 4 (8 en equipos de 64 bits), y luego:

char byte_array[12]; 
char byte_mask[12]; 
/* Checks for proper alignment */ 
assert(((unsigned int)(void *)byte_array) & 3 == 0); 
assert(((unsigned int)(void *)byte_mask) & 3 == 0); 
for (i = 0; i < (10+3)/4; i++) { 
    ((unsigned int *)(byte_array))[i] &= ((unsigned int *)(byte_mask))[i]; 
} 

Esto es mucho más rápido que hacerlo bytes por byte.

(Tenga en cuenta que se trata de una mutación en el lugar;. Si desea mantener el byte_array original también, entonces, obviamente, necesita almacenar los resultados en otra matriz en lugar)

Answer 3

\#define CHAR_ARRAY_SIZE (10) 
\#define INT_ARRAY_SIZE  ((CHAR_ARRAY_SIZE/ (sizeof (unsigned int)) + 1) 

typedef union _arr_tag_ { 

    char   byte_array [CHAR_ARRAY_SIZE]; 
    unsigned int int_array [INT_ARRAY_SIZE]; 

} arr_tag; 

Ahora INT_array para el enmascaramiento. Esto podría funcionar tanto para procesadores de 32 bits como de 64 bits.

arr_tag arr_src, arr_result, arr_mask; 

for (int i = 0; i < INT_ARRAY_SIZE; i ++) { 
    arr_result.int_array [i] = arr_src.int_array[i] & arr_mask.int_array [i]; 
} 

probar esto, código también puede tener un aspecto limpio.