使用数组时的抽象与性能

Question

This is a question about a concern I have about choosing between better performance and clearer code (better abstraction) when dealing with arrays. I tried to distill it down to a toy example.

C++ is particularly good at allowing abstractions without hurting performance. The question is whether this is possible in examples similar to the one below.

Consider a trivial arbitrary-size matrix class that uses contiguous row-major storage:

#include <cmath>
#include <cassert>

class Matrix {
    int nrow, ncol;
    double *data;
public:
    Matrix(int nrow, int ncol) : nrow(nrow), ncol(ncol), data(new double[nrow*ncol]) { }
    ~Matrix() { delete [] data; }

    int rows() const { return nrow; }
    int cols() const { return ncol; }

    double & operator [] (int i) { return data[i]; }

    double & operator () (int i, int j) { return data[i*ncol + j]; }
};

It has a 2D indexing operator () to make it easy to work with. It also has operator [] for contiguous access, but a better-abstracted matrix may not have this.

Let's implement a function that takes an n-by-2 matrix, essentially a list of 2D vectors, and normalizes each vector in-place.

The clear way:

inline double veclen(double x, double y) {
    return std::sqrt(x*x + y*y);
}

void normalize(Matrix &mat) {
    assert(mat.cols() == 2); // some kind of check for correct input
    for (int i=0; i < mat.rows(); ++i) {
        double norm = veclen(mat(i,0), mat(i,1));
        mat(i,0) /= norm;
        mat(i,1) /= norm;
    }
}

The fast, but less clear way:

void normalize2(Matrix &mat) {
    assert(mat.cols() == 2);
    for (int i=0; i < mat.rows(); ++i) {
        double norm = veclen(mat[2*i], mat[2*i+1]);
        mat[2*i] /= norm;
        mat[2*i+1] /= norm;
    }
}

The second version ( normalize2 ) has the potential to be faster because it is written in a way that it is clear that the second iteration of the loop will not access data that was computed in the first iteration. Thus it can potentially make better use of SIMD instructions. Looking at godbolt, this seems to be what happens (unless I'm misreading the assembly).

In the first version ( normalize ), the compiler can't know that the input matrix is not n-by-1, which would lead to overlapping array accesses.

Question: Is it possible to somehow tell the compiler that the input matrix is really n-by-2 in normalize() to allow it to optimize to the same level as it does in normalize2() ?

---

Addressing the comments:

• John Zwinck: I went and did the benchmark. normalize2() is considerably faster (2.4 vs 1.3 seconds), but only if I remove the assert macros or if I define NDEBUG . That is a rather counterintuitive effect of -DNDEBUG , isn't it? It reduces performance instead of improving it.

• Max: Evidence is both the godbolt output I linked to and the above benchmark. I am also interested in the case when these two functions cannot be inlined (eg because they are in a separate translation unit).

• Jarod42 and bolov: This is the answer I was looking for. Confirmed by the benchmark mentioned in the first point. Still, this is important to know in case one implements one's own assert (which is exactly what I do in my application).

Answer 1

I believe templates let you achieve both performance and readability.

By templating the size of your matrix (like popular math libraries do), you let the compiler know at compile time a lot of info.

I modified a bit your little class:

template<int R, int C>
class Matrix {
    double data[R * C] = {0.0};
public:
    Matrix() = default;

    int rows() const { return R; }
    int cols() const { return C; }
    int size() const { return R*C; }

    double & operator [] (int i) { return data[i]; }

    double & operator () (int row, int col) { return data[row*C + col]; }
};

inline double veclen(double x, double y) {
    return std::sqrt(x*x + y*y);
}

template<int R>
void normalize(Matrix<R, 2> &mat) {
    for (int i = 0; i < R; ++i) {
        double norm = veclen(mat(i, 0), mat(i, 1));
        mat(i, 0) /= norm;
        mat(i, 1) /= norm;
    }
}

template<int R>
void normalize2(Matrix<R, 2> &mat) {
    for (int i = 0; i < R; ++i) {
        double norm = veclen(mat[2 * i], mat[2 * i + 1]);
        mat[2 * i] /= norm;
        mat[2 * i + 1] /= norm;
    }
}

I also prefer to put data as plain member (=without pointer), so you can choose during the matrix construction where the memory is (stack or heap).

The nice extra is you are now sure at compile time that the normalize functions only accept n-by-2 matrix.

I didn't test my code on compiler explorer, because honestly I can't decipher asm. So, yes, I claim my version to be better without being sure ;)

A last word: don't roll your own matrix, use a library, like glm or eigen.

A last word²: If you don't know what to choose, prefer readability.

Answer 2

An answer that is acceptable to me was essentially given by @bolov and @Jared42 in the comments. Since they did not post it, I will do so myself.

To let the compiler know that the matrix is of size n-by-2, it is sufficient to add code to the beginning of the function that makes the rest of the code unreachable when the matrix size is not correct.

For example, adding

if (mat.cols() != 2)
    throw std::runtime_error("Input array is not of expected shape.");

to the beginning of normalize() allows it to run exactly as fast as normalize2() (1.3 instead of 2.4 seconds in my benchmark with clang 5.0).

We can also add an assert(mat.cols() == 2) , but this results in the counterintuitive effect that defining -DNDEBUG during compilation makes the function considerably slower (as it removes the assertion).