C++ 矩阵与向量相乘的最快方法是什么？

有没有人能建议在这个函数中用更快的方法将矩阵乘以向量

  inline void multiply(
        std::vector< std::vector<double> > &matrix,
        std::vector<double> &vector,
        std::vector<double> &result
    ){
        int size = (int) vector.size();

        result.resize(size);

        #pragma omp parallel for
        for(int i = 0; i < size; ++i){
              int j = 0;

            for(; j <= size - 16; j += 16){
                result[i] += matrix[i][j] * vector[j]
                    + matrix[i][j + 1] * vector[j + 1]
                    + matrix[i][j + 2] * vector[j + 2]
                    + matrix[i][j + 3] * vector[j + 3]
                    + matrix[i][j + 4] * vector[j + 4]
                    + matrix[i][j + 5] * vector[j + 5]
                    + matrix[i][j + 6] * vector[j + 6]
                    + matrix[i][j + 7] * vector[j + 7]
                    + matrix[i][j + 8] * vector[j + 8]
                    + matrix[i][j + 9] * vector[j + 9]
                    + matrix[i][j + 10] * vector[j + 10]
                    + matrix[i][j + 11] * vector[j + 11]
                    + matrix[i][j + 12] * vector[j + 12]
                    + matrix[i][j + 13] * vector[j + 13]
                    + matrix[i][j + 14] * vector[j + 14]
                    + matrix[i][j + 15] * vector[j + 15];
            }

            for(; j < size; ++j){
                result[i] += matrix[i][j] * vector[j];
            }
        }
    }

inlinevoidmultiply(
标准：：矢量<标准：：矢量>&矩阵，
标准：：向量和向量，
向量与结果
){
int size=（int）vector.size（）；
结果：调整大小（大小）；
#pragma-omp并行
对于（int i=0；i对于（；j取决于您的硬件，使用GPU并行化（ex:CUDA）可能会有很大帮助。
取决于您的硬件，使用GPU并行化（ex:CUDA）可能会有很大帮助。
即使它被“多次调用”，您是否测量并分析过这确实是您程序中的瓶颈？始终在手动优化之前进行测量。并且始终在测量之前启用优化。请记住“足够好”经常是足够好的。当你进行手动优化时，请记住，它经常使代码变得非常模糊，所以有很好的文档（注释）是必须的。最后，现代编译器非常擅长优化，包括循环展开。代码似乎有缺陷，因为
结果
不能保证在函数启动时设置为零。您可以使用。
std:：vector
不是（听说）特别有效。最好有一个1d向量并操纵它的索引。只是好奇：你的手动分块到大小为16的块是否比（j=0；j
的简单
快？我希望现代编译器能够对其自身进行优化。即使它“被多次调用”，您是否测量并分析过这确实是您程序中的瓶颈？始终在手动优化之前进行测量。并且始终在测量之前启用优化。请记住“足够好”经常是足够好的。当你进行手动优化时，请记住，它经常使代码变得非常模糊，所以有很好的文档（注释）是必须的。最后，现代编译器非常擅长优化，包括循环展开。代码似乎有缺陷，因为
结果
不能保证在函数启动时设置为零。您可以使用。
std:：vector
不是（听说）特别有效。最好是有一个1d向量并操纵它的索引。只是好奇：你的手动分块到大小为16的块是否比（j=0；j
的简单
更快？我希望现代编译器能够自行优化它。