Понимание квалификатора limited на примерах

Ниже я буду ссылаться на варианты использования из документа Sun, на который есть ссылка в вопросе.

(Относительно) очевидным случаем будет случай mem_copy(), который подпадает под 2-ю категорию вариантов использования в документе Sun (функция f1()). Допустим, у нас есть следующие две реализации:

void mem_copy_1(void * restrict s1, const void * restrict s2, size_t n);
void mem_copy_2(void *          s1, const void *          s2, size_t n);

Поскольку мы знаем, что между двумя массивами, на которые указывают s1 и s2, нет перекрытия, код для первой функции будет простым:

void mem_copy_1(void * restrict s1, const void * restrict s2, size_t n)
{
     // naively copy array s2 to array s1.
     for (int i=0; i<n; i++)
         s1[i] = s2[i];
     return;
}

s2 = '....................1234567890abcde' <- s2 before the naive copy
s1 = '1234567890abcde....................' <- s1 after the naive copy
s2 = '....................1234567890abcde' <- s2 after the naive copy

OTOH, во 2-й функции может быть перекрытие. В этом случае нам нужно проверить, расположен ли исходный массив перед целевым или наоборот, и соответственно выбрать границы индекса цикла.

Например, скажите s1 = 100 и s2 = 105. Тогда, если n=15, после копирования вновь скопированный массив s1 переполнит первые 10 байт исходного массива s2. Нам нужно убедиться, что мы сначала скопировали младшие байты.

s2 = '.....1234567890abcde' <- s2 before the naive copy
s1 = '1234567890abcde.....' <- s1 after the naive copy
s2 = '.....67890abcdeabcde' <- s2 after the naive copy

Однако, если s1 = 105 и s2 = 100, то запись младших байтов сначала переполнит последние 10 байтов исходного s2, и мы получим ошибочную копию.

s2 = '1234567890abcde.....' <- s2 before the naive copy
s1 = '.....123451234512345' <- s1 after the naive copy - not what we wanted
s2 = '123451234512345.....' <- s2 after the naive copy

В этом случае нам нужно сначала скопировать последние байты массива, возможно, отступив назад. Код будет выглядеть примерно так:

void mem_copy_2(void *s1, const void *s2, size_t n)
{
    if (((unsigned) s1) < ((unsigned) s2))
        for (int i=0; i<n; i++)
             s1[i] = s2[i];
    else
        for (int i=(n-1); i>=0; i--)
             s1[i] = s2[i];
    return;
}

Легко увидеть, как модификатор restrict дает шанс на лучшую оптимизацию скорости, устранение лишнего кода и решение if-else.

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

Первый вариант использования (функция init()) можно рассматривать как вариант второго, описанного выше. Здесь два массива создаются одним вызовом динамического выделения памяти.

Обозначение двух указателей как restrict-ed обеспечивает оптимизацию, при которой в противном случае порядок инструкций имел бы значение. Например, если у нас есть код:

a1[5] = 4;
a2[3] = 8;

затем оптимизатор может переупорядочить эти операторы, если сочтет это полезным.

OTOH, если указатели не restricted, то важно, чтобы 1-е присваивание выполнялось перед вторым. Это связано с тем, что существует вероятность того, что a1[5] и a2[3] на самом деле являются одним и тем же местом в памяти! Легко видеть, что в этом случае конечное значение должно быть 8. Если мы переупорядочим инструкции, то конечное значение будет 4!

Опять же, если непересекающиеся указатели даны этому предполагаемому коду restricted, результат не определен.