为什么C动态数组乘法比std :: vector版本更好

时间：

openmp mult_1: time: 5.882000 s

array mult_2: time: 1.478000 s

我的汇编标志是：

/usr/bin/g++ -fopenmp -pthread -std=c++1y -O3

C矢量版本

typedef std::vector<std::vector<float>> matrix_f;
void mult_1 (const matrix_f &  matrixOne,const matrix_f & matrixTwo,matrix_f & result) {
    const int matrixSize = (int)result.size();
    #pragma omp parallel for simd
    for (int rowResult = 0; rowResult < matrixSize; ++rowResult) {
        for (int colResult = 0; colResult < matrixSize; ++colResult) {
            for (int k = 0; k < matrixSize; ++k) {
                result[rowResult][colResult] += matrixOne[rowResult][k] * matrixTwo[k][colResult];  
            }
        }
    }
}

动态阵列版本

void mult_2 ( float *  matrixOne,float * matrixTwo,float * result,int size)  {
    for (int row = 0; row < size; ++row) {
        for (int col = 0; col < size; ++col) {
            for (int k = 0; k < size; ++k) {
                (*(result+(size*row)+col)) += (*(matrixOne+(size*row)+k)) * (*(matrixTwo+(size*k)+col));
            }
        }
    }
}

测试：

C矢量版本

utils::ChronoTimer timer;
/* set Up simple matrix */
utils::matrix::matrix_f matr1 = std::vector<std::vector<float>>(size,std::vector<float>(size));
fillRandomMatrix(matr1);

utils::matrix::matrix_f matr2 = std::vector<std::vector<float>>(size,std::vector<float>(size));
fillRandomMatrix(matr2);

utils::matrix::matrix_f result = std::vector<std::vector<float>>(size,std::vector<float>(size));    
timer.init();
utils::matrix::mult_1(matr1,matr2,result);
std::printf("openmp mult_1: time: %f msn",timer.now() / 1000);

动态阵列版本

utils::ChronoTimer timer;

float *p_matr1 = new float[size*size];
float *p_matr2 = new float[size*size];
float *p_result = new float[size*size];

fillRandomMatrixArray(p_matr1,size);
fillRandomMatrixArray(p_matr2,size);

timer.init();
utils::matrix::mult_2(p_matr1,p_matr2,p_result,size);
std::printf("array mult_2: time: %f msn",timer.now() / 1000);

delete [] p_matr1;
delete [] p_matr2;
delete [] p_result;

我正在检查一些以前的帖子,但我找不到任何与我的问题相关的link,link2,link3：

更新：
我重新测试了答案,而矢量作品稍微好一些：

vector mult: time: 1.194000 s

array mult_2: time: 1.202000 s

C矢量版本

void mult (const std::vector<float> &  matrixOne,const std::vector<float> & matrixTwo,std::vector<float> & result,int size) {
    for (int row = 0; row < size; ++row) {
        for (int col = 0; col < size; ++col) {
            for (int k = 0; k <size; ++k) {
                result[(size*row)+col] += matrixOne[(size*row)+k] * matrixTwo[(size*k)+col];
            }
        }
    }
}

动态阵列版本

void mult_2 ( float *  matrixOne,int size)  {
    for (int row = 0; row < size; ++row) {
        for (int col = 0; col < size; ++col) {
            for (int k = 0; k < size; ++k) {
                (*(result+(size*row)+col)) += (*(matrixOne+(size*row)+k)) * (*(matrixTwo+(size*k)+col));
            }
        }
    }
}

此外,我的矢量化版本工作更好(0.803秒);