¿Es más eficaz?
Debería ser exactamente igual. Por definición, es un agregado simple que contiene una matriz como único miembro.
La situación parece ser más complicada, ya std::array
que no siempre produce un código ensamblador idéntico en comparación con C-array dependiendo de la plataforma específica.
Probé esta situación específica en godbolt :
#include <array>
void test(double* const C, const double* const A,
const double* const B, const size_t size) {
for (size_t i = 0; i < size; i++) {
std::array<double, 2> arr = {0.e0};
for (size_t j = 0; j < size; j++) {
arr[0] += A[i] * B[j];
arr[1] += A[j] * B[i];
}
C[i] += arr[0];
C[i] += arr[1];
}
}
GCC y Clang producen un código ensamblador idéntico tanto para la versión C-array como para la std::array
versión.
Sin embargo, MSVC e ICPC producen un código de ensamblaje diferente para cada versión de la matriz. (Probé ICPC19 con -Ofast
y -Os
; MSVC -Ox
y -Os
)
No tengo idea de por qué este es el caso (de hecho, esperaría un comportamiento exactamente idéntico de std :: array y c-array). Quizás se empleen diferentes estrategias de optimización.
Como un pequeño extra: parece haber un error en ICPC con
#pragma simd
para la vectorización cuando se usa la matriz c en algunas situaciones (el código de la matriz c produce una salida incorrecta; la std::array
versión funciona bien).
Desafortunadamente, todavía no tengo un ejemplo de trabajo mínimo para eso, ya que descubrí ese problema mientras optimizaba un fragmento de código bastante complicado.
Presentaré un informe de error a intel cuando esté seguro de que no entendí mal algo sobre C-array / std::array
y #pragma simd
.