Question

作为个人项目的一部分，我想优化以下功能，以使其尽快运行。任何性能提升都很重要，因为程序其余部分的性能取决于它。

此刻，我正在使用Eigen的block（）函数，但是由于负数和越界索引不是有效的参数，因此我在使用一些附加代码来仅block（）必要的数据。

这是我要优化的功能；它尝试提取给定矩阵条目周围的子矩阵。然后目标是对所得矩阵进行哈希处理（使用boost的hash_combine的变体）并在哈希表中查找。

优化功能

#include <iostream>
#include <Eigen/Dense>

using namespace Eigen;

/// Returns a subsection from a matrix given the center and radius of the section. Fills space outside base matrix bounds with 0.
/// \param baseMatrix: The matrix from which to take a section. Entires are integers, either 0 or 1.
/// \param centerRow: The row serving as the center of the subsection.
/// \param centerCol: The column serving as the center of the subsection.
/// \param radius: The radius of the subsection, including the center entry.
/// \return A matrix of the same type as the input matrix of size radius*2-1, representing the slice of the input matrix around the provided center coordinate.
Eigen::MatrixXi GetMatrixSection(const MatrixXi &baseMatrix, int centerRow, int centerCol, int radius)
{
    //== Constraints ==
    // baseMatrix, both dimensions can be between 1 and maxInt, but will generally be in range [3, 25] matrix is usually but not always square
    // 0 <= centerRow <= baseMatrix.rows()-1
    // 0 <= centerCol <= baseMatrix.cols()-1
    // 1 <= radius <= max(baseMatrix.rows(), baseMatrix.cols())
    //    This specific implementation of the function allows for radius of any size > 0

    // Create Base Matrix to fill
    int nSize = radius * 2 - 1; // Size of resulting matrix
    MatrixXi result = Eigen::MatrixXi().Constant(nSize, nSize, 0);

    // Get indices of the top-left corner for the block operation
    int lowerRowBound = centerRow - (radius-1);
    int lowerColBound = centerCol - (radius-1);

    // Get the top-left corner of baseMatrix
    int upperLeftCopyableRow = std::max(0, lowerRowBound);
    int upperLeftCopyableCol = std::max(0, lowerColBound);

    // Determine how many rows we need to take from the baseMatrix
    int numCopyableRows = std::min((int)baseMatrix.rows()-upperLeftCopyableRow, std::min(0, lowerRowBound)+nSize);
    int numCopyableCols = std::min((int)baseMatrix.cols()-upperLeftCopyableCol, std::min(0, lowerColBound)+nSize);

    if(numCopyableRows <= 0 || numCopyableCols <= 0) return result; // if it is impossible to copy anything from result, don't try

    // Copy all data we can from the baseMatrix
    MatrixXi copiedBlock = baseMatrix.block(upperLeftCopyableRow, upperLeftCopyableCol, numCopyableRows, numCopyableCols);

    // Copy the data from baseMatrix into resulting matrix
    result.block(upperLeftCopyableRow-lowerRowBound, upperLeftCopyableCol-lowerColBound,
                 (int)copiedBlock.rows(), (int)copiedBlock.cols()) = copiedBlock;

    // Return resulting matrix
    return result;
}

我正在使用以下代码来测试上述功能的效率。

功能的计时码

int TestGetMatrixSection(MatrixXi matrixToTest, int trials=1)
{
    volatile int result = 0;
    for(int t = 0; t < trials; ++t) {
        for (int i = 1; i <= std::max(matrixToTest.rows(), matrixToTest.cols()); ++i) {
            for (int j = 0; j < matrixToTest.rows(); ++j) {
                for (int k = 0; k < matrixToTest.cols(); ++k) {
//                    std::cout << GetMatrixSection(matrixToTest, j, k, i) << "/n/n"; // printout
                    result += GetMatrixSection(matrixToTest, j, k, i).cols();
                }
            }
        }
    }
    return result;
}

int main()
{
    MatrixXi m = Eigen::MatrixXi(4, 5);
    m<< 1, 0, 0, 0, 1,
        1, 1, 0, 0, 1,
        1, 0, 1, 1, 0,
        1, 0, 0, 1, 0;
    auto startTime = std::chrono::steady_clock::now();
    TestGetMatrixSection(m, 10000);
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now()-startTime).count() << " milliseconds\n";
    return 0;
}

当前该函数有效，但是我担心性能会成为数百万次调用的问题。

预期产量

Example 3x3 matrix
[[1, 0, 1],      
 [1, 1, 0],
 [0, 1, 0]]


row index 1, col index 1, radius 2

[[1, 0, 1],      
 [1, 1, 0],
 [0, 1, 0]]


row index 0, col index 0, radius 2

[[0, 0, 0],      
 [0, 1, 0],
 [0, 1, 1]]


row index 2, col index 2, radius 2

[[1, 0, 0],      
 [1, 0, 0],
 [0, 0, 0]]


row index 0, col index 0, radius 3

[[0, 0, 0, 0, 0],
 [0, 0, 0, 0, 0],
 [0, 0, 1, 0, 1],
 [0, 0, 1, 1, 0],
 [0, 0, 0, 1, 0]]

Answer 1

假设<?php $db = new PDO('mysql:host=localhost;dbname=test', 'root', ''); try { $results = $db->query( "SELECT * FROM articles ar INNER JOIN authors au ON ar.id=au.article_id" ); } catch (Exception $e) { echo "bad query"; echo $e; } $items = $results->fetch(PDO::FETCH_ASSOC);的大小没有变化，并且您知道baseMatrix的合理上限，我建议将该矩阵存储到一个较大的矩阵中，该矩阵在每一侧均由0项扩展。实现此目的的一种可能性：

radius

像这样使用它：

template<class S>
struct ExtendedMatrix{
    typedef Eigen::Matrix<S,Eigen::Dynamic, Eigen::Dynamic> MatS;
    typedef Eigen::Ref<MatS> Ref;
    typedef Eigen::Ref<MatS const> RefC;

    // read/write reference to baseMatrix:
    Ref getBaseMatrix() {
        return storage.block(maxR-1, maxR-1, storage.rows()-2*maxR+1, storage.cols()-2*maxR+1);
    }

    // read-only reference to baseMatrix:
    RefC getBaseMatrix() const {
        return storage.block(maxR-1, maxR-1, storage.rows()-2*maxR+1, storage.cols()-2*maxR+1);
    }

    // constructor. Takes an initial matrix and a maximum radius.
    template<class Derived>
    ExtendedMatrix(Eigen::MatrixBase<Derived> const& base, int maxRadius)
        : maxR(maxRadius), storage(base.rows()+2*maxR-1, base.cols()+2*maxR-1)
    {
        storage.setZero();
        getBaseMatrix() = base;
    }

    // method to get a (read-only) block of size 2radius-1 around a given coordinate
    // entries outside the original matrix are filled with 0s.
    RefC getMatrixSection(int centerRow, int centerCol, int radius) const
    {
        assert(radius <= maxR);
        int offset = maxR-radius;
        return storage.block(centerRow+offset, centerCol+offset, 2*radius-1, 2*radius-1);
    }

protected:
    int maxR;
    MatS storage;
};

本征：优化入口周围的边界矩阵块/切片

优化功能

功能的计时码

预期产量

1 个答案: