C for循环优化

Question

I'm trying to learn how to optimize my c code, so I found some articles on the internet and remade my function so that it should execute faster. And when I compile it without optimization flags it works (second function is about 12% faster than first), but when I use it with gcc -O3 then second function is much slower (about 50%). Do you have any idea why is that? Thanks for any help.

First function:

typedef struct {
    double *data;
    int rows;
    int columns;
} Matrix;

Matrix *matrixMultiplication(Matrix *a, Matrix *b) {
    if(a->columns != b->rows)
        return NULL;
    Matrix *matrix = createMatrix(a->rows, b->columns);
    set(0, matrix);
    for(int i = 0; i < matrix->rows; i++) {
        for(int j = 0; j < a->columns; j++) {
            for(int k = 0; k < b->columns; k++) {
                matrix->data[i * matrix->columns + k] += a->data[i * a->columns + j] * b->data[j * b->columns + k];
            }
        }
    }
    return matrix;
}

Second function:

typedef struct {
    float *data;
    unsigned int rows;
    unsigned int columns;
} Matrix_2;

unsigned int matrixMultiplication_2(Matrix_2 *a, Matrix_2 *b, Matrix_2 **c) {
    Matrix_2 *matrix;
    if(a->columns != b->rows)
        return 0;
    createMatrix_2(a->rows, b->columns, &matrix);
    set_2(0, matrix);
    for(unsigned int i = matrix->rows; i--;) {
        for(unsigned int j = a->columns; j--;) {
            for(unsigned int k = b->columns; k--;) {
                matrix->data[i * matrix->columns + k] += a->data[i * a->columns + j] * b->data[j * b->columns + k];
            }
        }
    }
    *c = matrix;
    return 1;
}

Answer 1

That's because compiler optimizations are based on pattern recognition . Your compiler knows a ton of typical code patterns, and knows how to transform them to yield faster code. However, while this library of code patterns is quite extensive, it's finite.

The first function uses the canonical for(int i = 0; i < count; i++) loop control. You can bet that any compiler worth its salt has a pattern for this, yielding close to optimal code for the loop control.

The second function uses a pattern that's rarely seen in human code. While I personally like this pattern for its brevity, there are many programmers out there that find it too cryptic to be used. Obviously, your compiler does not come with an optimizer pattern for this, so the resulting code does not get fully optimized.

---

Optimizations like replacing for(int i = 0; i < count; i++) with for(int i = count; i--;) were useful when C was still little more than a high-level assembler. But compiler optimizations have long turned code translation into a much too complicated beast to be optimized by such tricks. Today, most optimizations need to be done on the algorithmic level. Translation level optimizations should generally be left to the compiler and fostered by writing canonical code that the compiler can optimize.