Правила для использования ограничить ключевого слова в C?

Я пытаюсь понять когда и если не использовать restrict ключевое слово в C и в том, какие ситуации это предоставляет материальное преимущество.

После чтения, "Демистифицируя Ограничить Ключевое слово", (который обеспечивает некоторые эмпирические правила на использовании), я получаю впечатление, что, когда функция является переданными указателями, она должна составлять возможность, что данные указали, мог бы наложиться (искажают) с любыми другими аргументами, передаваемыми в функцию. Учитывая функцию:

foo(int *a, int *b, int *c, int n) {
    for (int i = 0; i

компилятор должен перезагрузить c во втором выражении, потому что, возможно, b и c укажите на то же местоположение. Это также должно ожидать b быть сохраненным, прежде чем это сможет загрузиться a по той же причине. Это затем должно ожидать a быть сохраненным и должно перезагрузить b и c в начале следующего цикла. Если Вы вызываете функцию как это:

int a[N];
foo(a, a, a, N);

затем Вы видите, почему компилятор должен сделать это. Используя restrict эффективно говорит компилятору, что Вы никогда не будете делать этого, так, чтобы он мог отбросить избыточную загрузку c и загрузка a прежде b хранится.

В другом, ТАКИМ ОБРАЗОМ, сообщение, Nils Pipenbrinck, обеспечивает рабочий пример этого сценария, демонстрирующего выигрыш в производительности.

До сих пор я заключил, что это - хорошая идея использовать restrict на указателях Вы передаете в функции, которые не будут встроены. По-видимому, если код встраивается, компилятор может выяснить, что указатели не накладываются.

Теперь вот то, где вещи начинают становиться нечеткими для меня.

В статье Ulrich Drepper, "Что каждый программист должен знать о памяти", что делает оператор, что, "если не ограничивают, используется, все доступы указателя являются потенциальными источниками искажения", и он дает определенный пример кода субматрицы, умножение матриц, где он использует restrict.

Однако, когда я компилирую его пример кода или с или без restrict Я получаю идентичные двоичные файлы в обоих случаях. Я использую gcc version 4.2.4 (Ubuntu 4.2.4-1ubuntu4)

Вещь, которую я не могу выяснить в следующем коде, состоит в том, должно ли это быть переписано для создания более широкого применения restrict, или если анализ псевдонима в GCC настолько хорош, что он может выяснить, что ни один из аргументов не искажает друг друга. В чисто образовательных целях, как я могу сделать использование или не использование restrict вопрос в этом коде - и почему?

Для restrict скомпилированный с:

gcc -DCLS=$(getconf LEVEL1_DCACHE_LINESIZE) -DUSE_RESTRICT -Wextra -std=c99 -O3 matrixMul.c -o matrixMul

Просто удалите -DUSE_RESTRICT не использовать restrict.

#include 
#include 
#include 

#ifdef USE_RESTRICT
#else
#define restrict
#endif

#define N 1000
double _res[N][N] __attribute__ ((aligned (64)));
double _mul1[N][N] __attribute__ ((aligned (64)))
    = { [0 ... (N-1)] 
    = { [0 ... (N-1)] = 1.1f }};
double _mul2[N][N] __attribute__ ((aligned (64)))
    = { [0 ... (N-1)] 
    = { [0 ... (N-1)] = 2.2f }};

#define SM (CLS / sizeof (double))

void mm(double (* restrict res)[N], double (* restrict mul1)[N], 
        double (* restrict mul2)[N]) __attribute__ ((noinline));

void mm(double (* restrict res)[N], double (* restrict mul1)[N], 
        double (* restrict mul2)[N])
{
 int i, i2, j, j2, k, k2; 
    double *restrict rres; 
    double *restrict rmul1; 
    double *restrict rmul2; 

    for (i = 0; i < N; i += SM)
        for (j = 0; j < N; j += SM)
            for (k = 0; k < N; k += SM)
                for (i2 = 0, rres = &res[i][j],
                    rmul1 = &mul1[i][k]; i2 < SM;
                    ++i2, rres += N, rmul1 += N)
                    for (k2 = 0, rmul2 = &mul2[k][j];
                        k2 < SM; ++k2, rmul2 += N)
                        for (j2 = 0; j2 < SM; ++j2)
                          rres[j2] += rmul1[k2] * rmul2[j2];
}

int main (void)
{

    mm(_res, _mul1, _mul2);

 return 0;
}