Por referencia es mas rápido?

[Marcos071]

Hola, mi pregunta es esta...cuando paso un valor por referencia (que en realidad es un puntero a un lugar específico de memoria) es más rápido que pasar por valor? por qué?
Me parece que por referencia es más lento, segun lo que supongo, ya que por referencia podes modificar los valores de la variable, pero pasando las variables por valor no, ya que no podes modificarlos...pero no estoy seguro de que sea así...

[drbit]

Por valor es considerablemente más lento, debido a que se debe hacer una copia local dentro de la función de la variable pasada.

A los que vos te referis me imagino es a una variable constante, pero no es el caso, ya que la función puede hacer modificaciones sobre su copia local.

Saludos.

[Marcos071]

Hola, pues creo que te estas equivocando...ayer pregunté a mi profesor y me dijo esto...y menos mal que me lo dijo...


Las más rápidas, obviamente son las pasadas por valor, pues trabajan sobre una copia local.
Las referencias primero tienen que buscar la dirección del argumento (la referencia) y luego llevar o traer valores.

[drbit]

Bueno, pero por qué en vez de creer lo que te dicen no lo pruebas tu mismo y se lo muestras a tu profesor:

Código:

// Pasamos por valor
#include <stdio.h>
typedef struct {
  double a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,x,y,z,
    a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,
    p1,q1,r1,s1,t1,x1,y1,z1;
} s;

double fun(s e) {
  return 0;
}


int main() { 

  s e;
  long int i;
  for (i = 0 ; i < 1000000 ; i++ )
    fun(e);
  return 0;
}

Compilamos

Código:

gcc test.c -o sin_referencia.out

Medimos la ejecución

Código:

time ./sin_referencia.out
real    0m1.777s
user    0m1.772s
sys     0m0.004s

Ahora por refencia

Código:

#include <stdio.h>
typedef struct {
  double a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,x,y,z,
    a1,b1,c1,d1,e1,f1,g1,h1,i1,j1,k1,l1,m1,n1,o1,
    p1,q1,r1,s1,t1,x1,y1,z1;
} s;

double fun(s *e) {
  return 0;
}


int main() { 

  s e;
  long int i;
  for (i = 0 ; i < 1000000 ; i++ )
    fun(&e);
  return 0;
}

Compilamos

Código:

gcc test.c -o con_referencia.out

Y medimos!!!

Código:

time ./con_referencia.out
real    0m0.007s
user    0m0.008s
sys     0m0.000s

¿GANADOR?

[Marcos071]

Ok muy bien!!! gracias...

[m4xp0wer]

Hombre, no estoy muy seguro, pero creo que eso depende bastante del tamaño del parámetro de la función. Obviamente, con la estructura que estás pasando es más rápido por referencia, pero si fueran menos parámetros CREO que perderías menos tiempo en copiarlos a la pila que en usar la indirección del puntero (si se tratase por ejemplo de muchos enteros, al pasarlo por referencia tendrías que copiar el puntero a la pila, con lo cual sería lo mismo)

[drbit]

mmm, podría existir un caso especifico, no lo sé, pero recien probe pasando solo un entero y también se hace más rápido con el parametro por referencia.

No se me ocurre cuando una copia puede ser más rápida que simplemente pasar una dirección. Si encontras alguno pasamelo que me interesa.

Saludos.

[m4xp0wer]

He estado haciendo algunas pruebas. Mira esto:
Paso por valor:

Código:

#include<stdio.h>

int suma(int a,int b)
{
  return a+b;
}

int main()
{
  int j,i,a,b;
  a=10;
  b=30;
  for(i=0;i<30000000;i++)
    {
      j = suma(a,b);
    }
  return;
}

Paso por referencia:

Código:

#include<stdio.h>
int suma(int *a, int *b)
{
  return (*a)+(*b);
}
int main()
{
  int j,i,a,b;
  a=10;
  b=30;
  for(i=0;i<30000000;i++)
    {
      j=suma(&a,&b);
    }
  return;
}

El tiempo que tarda el segundo programa en ejecutarse es ligeramente superior al del primero

Código:

 time ./prueba1

real    0m0.185s
user    0m0.160s
sys     0m0.004s

Código:

 time ./prueba2

real    0m0.237s
user    0m0.220s
sys     0m0.000s

Esto se debe a que la indirección requiere una operación a mayores, mientras que el contenido que se introduce en la pila es del mismo tamaño en los dos casos (el tamaño de un puntero es el mismo que un int, 4 octetos)

[drbit]

Interesante.

Entonces dependería básicamente del tamaño de los parametros y cuantas operaciones hacen falta que los desreferencien. Tenes idea si el costo de desreferenciarlos es solo de la primera vez que se hace en la función, o das las veces que haga?

Saludos.

[m4xp0wer]

No estoy muy seguro, pero para una operación de tipo (*a)+(*b) necesitas 4 accesos a memoria (2 para los punteros y otros 2 para los valores), mientras que a+b necesita tan sólo 2 accesos. Yo diría que esta indirección se realiza cada vez que se necesita (no sé si se mantiene en la caché...), porque si haces por ejemplo a=b estás cambiando el valor del puntero, pero tampoco estoy demasiado seguro. Además, no creo que se guarde el estado de una llamada de la función a otra. Como mucho, la dirección ya se encontrará en la caché de nivel más bajo, con lo que el acceso será muchísimo más rápico.

Un saludo