¿Uso realista de la palabra clave 'restringir' C99?

Estaba buscando documentación y preguntas / respuestas y la vi mencionada. Leí una breve descripción, afirmando que sería básicamente una promesa del programador que el puntero no se usará para apuntar a otro lado.

¿Alguien puede ofrecer algunos casos realistas en los que valga la pena usar esto?

restrictdice que el puntero es lo único que accede al objeto subyacente. Elimina el potencial de alias de puntero, permitiendo una mejor optimización por parte del compilador.

Por ejemplo, supongamos que tengo una máquina con instrucciones especializadas que pueden multiplicar vectores de números en la memoria, y tengo el siguiente código:

void MultiplyArrays(int* dest, int* src1, int* src2, int n)
{
    for(int i = 0; i < n; i++)
    {
        dest[i] = src1[i]*src2[i];
    }
}

El compilador debe manejar adecuadamente if dest, src1y src2superponerse, lo que significa que debe hacer una multiplicación a la vez, de principio a fin. Al tener restrict, el compilador es libre de optimizar este código utilizando las instrucciones vectoriales.

Wikipedia tiene una entrada restrict, con otro ejemplo, aquí .

El ejemplo de Wikipedia es muy esclarecedor.

Muestra claramente cómo permite guardar una instrucción de ensamblaje .

Sin restricción:

void f(int *a, int *b, int *x) {
  *a += *x;
  *b += *x;
}

Pseudo ensamblaje:

load R1 ← *x    ; Load the value of x pointer
load R2 ← *a    ; Load the value of a pointer
add R2 += R1    ; Perform Addition
set R2 → *a     ; Update the value of a pointer
; Similarly for b, note that x is loaded twice,
; because x may point to a (a aliased by x) thus 
; the value of x will change when the value of a
; changes.
load R1 ← *x
load R2 ← *b
add R2 += R1
set R2 → *b

Con restringir:

void fr(int *restrict a, int *restrict b, int *restrict x);

Pseudo ensamblaje:

load R1 ← *x
load R2 ← *a
add R2 += R1
set R2 → *a
; Note that x is not reloaded,
; because the compiler knows it is unchanged
; "load R1 ← *x" is no longer needed.
load R2 ← *b
add R2 += R1
set R2 → *b

¿GCC realmente lo hace?

GCC 4.8 Linux x86-64:

gcc -g -std=c99 -O0 -c main.c
objdump -S main.o

Con -O0 , son lo mismo.

Con -O3:

void f(int *a, int *b, int *x) {
    *a += *x;
   0:   8b 02                   mov    (%rdx),%eax
   2:   01 07                   add    %eax,(%rdi)
    *b += *x;
   4:   8b 02                   mov    (%rdx),%eax
   6:   01 06                   add    %eax,(%rsi)  

void fr(int *restrict a, int *restrict b, int *restrict x) {
    *a += *x;
  10:   8b 02                   mov    (%rdx),%eax
  12:   01 07                   add    %eax,(%rdi)
    *b += *x;
  14:   01 06                   add    %eax,(%rsi) 

Para los no iniciados, la convención de convocatoria es:

• rdi = primer parámetro
• rsi = segundo parámetro
• rdx = tercer parámetro

La salida de GCC fue incluso más clara que el artículo wiki: 4 instrucciones vs 3 instrucciones.

Matrices

Hasta ahora, tenemos ahorros en una sola instrucción, pero si el puntero representa las matrices que se van a recorrer, un caso de uso común, entonces se podrían guardar un montón de instrucciones, como menciona supercat .

Considere por ejemplo:

void f(char *restrict p1, char *restrict p2) {
    for (int i = 0; i < 50; i++) {
        p1[i] = 4;
        p2[i] = 9;
    }
}

Debido a que restrictun compilador inteligente (o humano), podría optimizar eso para:

memset(p1, 4, 50);
memset(p2, 9, 50);

que es potencialmente mucho más eficiente, ya que puede ser un ensamblaje optimizado en una implementación decente de libc (como glibc): ¿Es mejor usar std :: memcpy () o std :: copy () en términos de rendimiento?

¿GCC realmente lo hace?

GCC 5.2.1.Linux x86-64 Ubuntu 15.10:

gcc -g -std=c99 -O0 -c main.c
objdump -dr main.o

Con -O0ambos son lo mismo.

Con -O3:

• con restricción:

  3f0:   48 85 d2                test   %rdx,%rdx
  3f3:   74 33                   je     428 <fr+0x38>
  3f5:   55                      push   %rbp
  3f6:   53                      push   %rbx
  3f7:   48 89 f5                mov    %rsi,%rbp
  3fa:   be 04 00 00 00          mov    $0x4,%esi
  3ff:   48 89 d3                mov    %rdx,%rbx
  402:   48 83 ec 08             sub    $0x8,%rsp
  406:   e8 00 00 00 00          callq  40b <fr+0x1b>
                          407: R_X86_64_PC32      memset-0x4
  40b:   48 83 c4 08             add    $0x8,%rsp
  40f:   48 89 da                mov    %rbx,%rdx
  412:   48 89 ef                mov    %rbp,%rdi
  415:   5b                      pop    %rbx
  416:   5d                      pop    %rbp
  417:   be 09 00 00 00          mov    $0x9,%esi
  41c:   e9 00 00 00 00          jmpq   421 <fr+0x31>
                          41d: R_X86_64_PC32      memset-0x4
  421:   0f 1f 80 00 00 00 00    nopl   0x0(%rax)
  428:   f3 c3                   repz retq

  Dos memsetllamadas como se esperaba.

• sin restricción: no hay llamadas stdlib, solo un desenrollamiento de bucle ancho de 16 iteraciones que no pretendo reproducir aquí :-)

No he tenido la paciencia para compararlos, pero creo que la versión restringida será más rápida.

C99

Veamos el estándar por completo.

restrictdice que dos punteros no pueden apuntar a regiones de memoria superpuestas. El uso más común es para argumentos de función.

Esto restringe cómo se puede llamar a la función, pero permite más optimizaciones en tiempo de compilación.

Si la persona que llama no sigue el restrictcontrato, comportamiento indefinido.

El C99 N1256 borrador 6.7.3 / 7 "Calificadores de tipo" dice:

El uso previsto del calificador de restricción (como la clase de almacenamiento de registro) es para promover la optimización, y eliminar todas las instancias del calificador de todas las unidades de traducción de preprocesamiento que componen un programa conforme no cambia su significado (es decir, comportamiento observable).

y 6.7.3.1 "Definición formal de restricción" da los detalles sangrientos.

Regla de alias estricta

La restrictpalabra clave solo afecta a punteros de tipos compatibles (por ejemplo, dos int*) porque las estrictas reglas de alias dicen que el alias de tipos incompatibles es un comportamiento indefinido por defecto, por lo que los compiladores pueden asumir que no sucede y optimizar.

Ver: ¿Cuál es la estricta regla de alias?

Ver también

• C ++ 14 aún no tiene un análogo para restrict, pero GCC tiene __restrict__como extensión: ¿Qué significa la palabra clave restringir en C ++?
• Muchas preguntas que se hacen: de acuerdo con los detalles sangrientos, ¿este código UB o no?
  • Comprensión restringir calificador por ejemplos
  • Preguntas de puntero restringidas
  • ¿Es legal asignar un puntero restringido a otro puntero y usar el segundo puntero para modificar el valor?
• Una pregunta de "cuándo usar": cuándo usar restringir y cuándo no
• El GCC relacionado __attribute__((malloc)), que dice que el valor de retorno de una función no tiene un alias para nada: GCC: __attribute __ ((malloc))