elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Tutorial básico de Quickjs


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Sucesion de Fibonacci recursiva optimizada		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: 1 [2] Ir Abajo Respuesta Imprimir
Autor Tema: Sucesion de Fibonacci recursiva optimizada  (Leído 12,437 veces)
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #10 en: 22 Julio 2013, 07:13 am »
Cita de: rir3760 en 21 Julio 2013, 19:17 pm
En el desplazamiento si la variable es de un tipo entero con signo el valor del bit de relleno depende de la implementación, en otras palabras no esta garantizado que el resultado de ambas operaciones (división y desplazamiento) sea el mismo

Tenía entendido que en el caso de los procesadores empleados en PCs... intel, amd, etc... si se da esa condición.
En línea
do-while


Desconectado Desconectado

Mensajes: 1.276


¿Habra que sacarla de paseo?


Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #11 en: 22 Julio 2013, 09:28 am »
¡Buenas!


Había leido que de las operaciones "elementales" (+, -, * , / y %), las que mas le costaban al procesador eran / y %, la división, y efectivamente:
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. #define MAX 10000000000LLU
  6.  
  7. int main(int argc, char *argv[])
  8. {
  9.     unsigned long long i,x,y;
  10.     time_t ini;
  11.  
  12.     ini = time(NULL);
  13.  
  14.     for(i = 0 ; i < MAX ; i++)
  15.         if(i % 2);
  16.  
  17.     printf("%lu segundos\n", time(NULL) - ini);
  18.  
  19.     ini = time(NULL);
  20.  
  21.     for(i = 0 ; i < MAX ; i++)
  22.         if(i & 1);
  23.  
  24.     printf("%lu segundos\n", time(NULL) - ini);
  25.  
  26.     return 0;
  27. }
  28.  

Se nota la diferencia, pero para que sea considerable, he tenido que llegar a 10^10 iteraciones...

Aun así, se ve que es preferible comprobar el bit menos significativo en un código que requiera continuamente la comprobación de la paridad de un numero a utilizar el operador módulo.

¡Saludos!
En línea
- Doctor, confundo los números y los colores.
- Vaya marrón.
- ¿Marrón? ¡Por el culo te la hinco!
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #12 en: 22 Julio 2013, 10:08 am »
Cita de: do-while en 22 Julio 2013, 09:28 am
Se nota la diferencia, pero para que sea considerable, he tenido que llegar a 10^10 iteraciones...

Está claro que, pese a ser más pesada, una operación de división está lo suficientemente optimizada ( al menos cuando se manejan números enteros ) como para no ser un lastre excesivo... salvo que estés en un entorno de tiempo real crítico.

Lo que sí está claro es que, sobretodo en el caso de bucles con un gran número de repeticiones, las pequeñas optimizaciones se van notando cada vez más... obviamente hacer una sustitución así en, por ejemplo, una función que se ejecuta una vez cada vez que un usuario hace click sobre un botón no es una mejora a la que el vayas a sacar partido realmente.

La siguiente mejora que podrías plantearte en este código es el que sea capaz de manejar números realmente grandes... de 100, 200 ... 1000 cifras.

Funciones matemáticas optimizadas y con opción a manejar números grandes... más sus optimizaciones para números enteros normales, sería una buena base para sacar una librería matemática interesante.
En línea
amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #13 en: 22 Julio 2013, 10:43 am »
Cita de: do-while en 22 Julio 2013, 09:28 am
Se nota la diferencia, pero para que sea considerable, he tenido que llegar a 10^10 iteraciones...
Tú código no es correcto para cualquier compilador actual, mi compilador directamente se salta los fors y los ifs porque los considera que son inútiles. La prueba está en que los fors no aparecen en el código ensamblador:

Código
  1. .file	"main.cpp"
  2. 	.def	__main;	.scl	2;	.type	32;	.endef
  3. 	.section .rdata,"dr"
  4. .LC0:
  5. 	.ascii "%lu segundos\12\0"
  6. 	.section	.text.startup,"x"
  7. 	.p2align 4,,15
  8. 	.globl	main
  9. 	.def	main;	.scl	2;	.type	32;	.endef
  10. 	.seh_proc	main
  11. main:
  12. .LFB49:
  13. 	pushq	%rsi
  14. 	.seh_pushreg	%rsi
  15. 	pushq	%rbx
  16. 	.seh_pushreg	%rbx
  17. 	subq	$40, %rsp
  18. 	.seh_stackalloc	40
  19. 	.seh_endprologue
  20. 	call	__main
  21. 	movq	__imp__time64(%rip), %rbx
  22. 	xorl	%ecx, %ecx
  23. 	call	*%rbx
  24. 	xorl	%ecx, %ecx
  25. 	movq	%rax, %rsi
  26. 	call	*%rbx
  27. 	leaq	.LC0(%rip), %rcx
  28. 	movq	%rax, %rdx
  29. 	subq	%rsi, %rdx
  30. 	call	printf
  31. 	xorl	%ecx, %ecx
  32. 	call	*%rbx
  33. 	xorl	%ecx, %ecx
  34. 	movq	%rax, %rsi
  35. 	call	*%rbx
  36. 	leaq	.LC0(%rip), %rcx
  37. 	movq	%rax, %rdx
  38. 	subq	%rsi, %rdx
  39. 	call	printf
  40. 	xorl	%eax, %eax
  41. 	addq	$40, %rsp
  42. 	popq	%rbx
  43. 	popq	%rsi
  44. 	ret
  45. 	.seh_endproc
  46. 	.ident	"GCC: (rev1, Built by MinGW-builds project) 4.8.1"
  47. 	.def	printf;	.scl	2;	.type	32;	.endef

Lo modifique tal que así:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. #define MAX 5000000000LLU
  6.  
  7. int main(int argc, char *argv[])
  8. {
  9.     unsigned long long i;
  10.     unsigned int Contador = 0;
  11.     time_t ini;
  12.  
  13.     ini = time(NULL);
  14.  
  15.     for(i = 0 ; i < MAX ; i++)
  16.        Contador += i% 2;
  17.  
  18.     printf("%lu segundos\n", time(NULL) - ini);
  19.  
  20.     ini = time(NULL);
  21.  
  22.     for(i = 0 ; i < MAX ; i++)
  23.         Contador -= i&1;
  24.  
  25.     printf("%lu segundos\n", time(NULL) - ini);
  26.  
  27.      printf("%d",Contador);
  28.  
  29.     return 0;
  30. }

Ahora si que se nota que hace las operaciones, aunque haciendo pruebas. Me di cuenta que ambas operaciones dependían más del factor suerte que de otra cosa (a veces ganaba uno, otra veces ganaba otro y otras veces empataban). Analizando el código ASM:

Código
  1. 	.file	"main.cpp"
  2. 	.def	__main;	.scl	2;	.type	32;	.endef
  3. 	.section .rdata,"dr"
  4. .LC0:
  5. 	.ascii "%lu segundos\12\0"
  6. .LC1:
  7. 	.ascii "%d\0"
  8. 	.section	.text.startup,"x"
  9. 	.p2align 4,,15
  10. 	.globl	main
  11. 	.def	main;	.scl	2;	.type	32;	.endef
  12. 	.seh_proc	main
  13. main:
  14. .LFB49:
  15. 	pushq	%rdi
  16. 	.seh_pushreg	%rdi
  17. 	pushq	%rsi
  18. 	.seh_pushreg	%rsi
  19. 	pushq	%rbx
  20. 	.seh_pushreg	%rbx
  21. 	subq	$32, %rsp
  22. 	.seh_stackalloc	32
  23. 	.seh_endprologue
  24. 	xorl	%ebx, %ebx
  25. 	call	__main
  26. 	movq	__imp__time64(%rip), %rsi
  27. 	xorl	%ecx, %ecx
  28. 	call	*%rsi
  29. 	xorl	%edx, %edx
  30. 	movabsq	$5000000000, %r8
  31. 	movq	%rax, %rdi
  32. 	.p2align 4,,10
  33. .L3:
  34. 	movl	%edx, %ecx
  35. 	addq	$1, %rdx
  36. 	andl	$1, %ecx
  37. 	addl	%ecx, %ebx
  38. 	cmpq	%r8, %rdx
  39. 	jne	.L3
  40. 	xorl	%ecx, %ecx
  41. 	call	*%rsi
  42. 	leaq	.LC0(%rip), %rcx
  43. 	movq	%rax, %rdx
  44. 	subq	%rdi, %rdx
  45. 	call	printf
  46. 	xorl	%ecx, %ecx
  47. 	call	*%rsi
  48. 	xorl	%edx, %edx
  49. 	movabsq	$5000000000, %r8
  50. 	movq	%rax, %rdi
  51. 	.p2align 4,,10
  52. .L5:
  53. 	movl	%edx, %ecx
  54. 	addq	$1, %rdx
  55. 	andl	$1, %ecx
  56. 	subl	%ecx, %ebx
  57. 	cmpq	%r8, %rdx
  58. 	jne	.L5
  59. 	xorl	%ecx, %ecx
  60. 	call	*%rsi
  61. 	leaq	.LC0(%rip), %rcx
  62. 	movq	%rax, %rdx
  63. 	subq	%rdi, %rdx
  64. 	call	printf
  65. 	leaq	.LC1(%rip), %rcx
  66. 	movl	%ebx, %edx
  67. 	call	printf
  68. 	xorl	%eax, %eax
  69. 	addq	$32, %rsp
  70. 	popq	%rbx
  71. 	popq	%rsi
  72. 	popq	%rdi
  73. 	ret
  74. 	.seh_endproc
  75. 	.ident	"GCC: (rev1, Built by MinGW-builds project) 4.8.1"
  76. 	.def	printf;	.scl	2;	.type	32;	.endef

Podemos identificar los dos fors aquí:

Código
  1. .L3:
  2. 	movl	%edx, %ecx
  3. 	addq	$1, %rdx
  4. 	andl	$1, %ecx
  5. 	addl	%ecx, %ebx
  6. 	cmpq	%r8, %rdx
  7. 	jne	.L3
Código
  1. .L5:
  2. 	movl	%edx, %ecx
  3. 	addq	$1, %rdx
  4. 	andl	$1, %ecx
  5. 	subl	%ecx, %ebx
  6. 	cmpq	%r8, %rdx
  7. 	jne	.L5

Fijate que el compilador lo ha optimizado haciendo las mismas operaciones en los dos casos. Es curioso que incluso desactivando la optimización del compilador, tenemos las mismas operaciones en el for:

Código
  1. 	.file	"main.cpp"
  2. 	.def	__main;	.scl	2;	.type	32;	.endef
  3. 	.section .rdata,"dr"
  4. .LC0:
  5. 	.ascii "%lu segundos\12\0"
  6. .LC1:
  7. 	.ascii "%d\0"
  8. 	.text
  9. 	.globl	main
  10. 	.def	main;	.scl	2;	.type	32;	.endef
  11. 	.seh_proc	main
  12. main:
  13. .LFB36:
  14. 	pushq	%rbp
  15. 	.seh_pushreg	%rbp
  16. 	movq	%rsp, %rbp
  17. 	.seh_setframe	%rbp, 0
  18. 	subq	$64, %rsp
  19. 	.seh_stackalloc	64
  20. 	.seh_endprologue
  21. 	movl	%ecx, 16(%rbp)
  22. 	movq	%rdx, 24(%rbp)
  23. 	call	__main
  24. 	movl	$0, -12(%rbp)
  25. 	movl	$0, %ecx
  26. 	call	time
  27. 	movq	%rax, -24(%rbp)
  28. 	movq	$0, -8(%rbp)
  29. 	jmp	.L2
  30. .L3:
  31. 	movq	-8(%rbp), %rax
  32. 	andl	$1, %eax
  33. 	addl	%eax, -12(%rbp)
  34. 	addq	$1, -8(%rbp)
  35. .L2:
  36. 	movabsq	$4999999999, %rax
  37. 	cmpq	%rax, -8(%rbp)
  38. 	jbe	.L3
  39. 	movl	$0, %ecx
  40. 	call	time
  41. 	subq	-24(%rbp), %rax
  42. 	movq	%rax, %rdx
  43. 	leaq	.LC0(%rip), %rcx
  44. 	call	printf
  45. 	movl	$0, %ecx
  46. 	call	time
  47. 	movq	%rax, -24(%rbp)
  48. 	movq	$0, -8(%rbp)
  49. 	jmp	.L4
  50. .L5:
  51. 	movq	-8(%rbp), %rax
  52. 	andl	$1, %eax
  53. 	subl	%eax, -12(%rbp)
  54. 	addq	$1, -8(%rbp)
  55. .L4:
  56. 	movabsq	$4999999999, %rax
  57. 	cmpq	%rax, -8(%rbp)
  58. 	jbe	.L5
  59. 	movl	$0, %ecx
  60. 	call	time
  61. 	subq	-24(%rbp), %rax
  62. 	movq	%rax, %rdx
  63. 	leaq	.LC0(%rip), %rcx
  64. 	call	printf
  65. 	movl	-12(%rbp), %eax
  66. 	movl	%eax, %edx
  67. 	leaq	.LC1(%rip), %rcx
  68. 	call	printf
  69. 	movl	$0, %eax
  70. 	addq	$64, %rsp
  71. 	popq	%rbp
  72. 	ret
  73. 	.seh_endproc
  74. 	.ident	"GCC: (rev1, Built by MinGW-builds project) 4.8.1"
  75. 	.def	time;	.scl	2;	.type	32;	.endef
  76. 	.def	printf;	.scl	2;	.type	32;	.endef

Código
  1. 	jmp	.L2
  2. .L3:
  3. 	movq	-8(%rbp), %rax
  4. 	andl	$1, %eax
  5. 	addl	%eax, -12(%rbp)
  6. 	addq	$1, -8(%rbp)
  7. .L2:
  8. 	movabsq	$4999999999, %rax
  9. 	cmpq	%rax, -8(%rbp)
  10. 	jbe	.L3
Código
  1. 	jmp	.L4
  2. .L5:
  3. 	movq	-8(%rbp), %rax
  4. 	andl	$1, %eax
  5. 	subl	%eax, -12(%rbp)
  6. 	addq	$1, -8(%rbp)
  7. .L4:
  8. 	movabsq	$4999999999, %rax
  9. 	cmpq	%rax, -8(%rbp)
  10. 	jbe	.L5

Ergo, no. No hay diferencia entre % y & en un compilador actual.
En línea
Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #14 en: 22 Julio 2013, 11:00 am »
La pregunta entonces es... ¿ Es aplicable ese resultado a cualquier compilador ?

Creo que habría entonces que hacer una batería de pruebas con diferentes compiladores, porque no creo que todos implementen las mismas optimizaciones...

Eso si... te lo has currado mirándote el código en ensamblador
En línea
do-while


Desconectado Desconectado

Mensajes: 1.276


¿Habra que sacarla de paseo?


Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #15 en: 26 Julio 2013, 10:30 am »
amchacon, eres un tramposo...  :xD

Deja que los niños jueguen en igualdad de condiciones, que sino se sienten discriminados...  ;D

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. #define MIN 37
  6. #define MAX 42
  7.  
  8. typedef unsigned long long fibo_t;
  9.  
  10. unsigned long long llamadas_clasico;
  11. unsigned long long llamadas_optimizado;
  12.  
  13. #define MAX_CACHE 33
  14.  
  15. unsigned long long Fibonaci_Cache[MAX_CACHE] = {1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597
  16. ,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,31524578};
  17.  
  18. fibo_t fibo_clasico(fibo_t n)
  19. {
  20.     llamadas_clasico++;
  21.  
  22.     if(n < MAX_CACHE)
  23.         return Fibonaci_Cache[n];
  24.  
  25.     return fibo_clasico(n - 1) + fibo_clasico(n - 2);
  26. }
  27.  
  28. fibo_t fibo(fibo_t n)
  29. {
  30.     llamadas_optimizado++;
  31.  
  32.     if(n < MAX_CACHE)
  33.         return Fibonaci_Cache[n];
  34.  
  35.     if(n % 2) //n impar y mayor que 2
  36.     {
  37.         fibo_t k1,k2;
  38.  
  39.         k1 = fibo((n + 1) / 2);
  40.         k2 = fibo((n - 1) / 2);
  41.  
  42.         return k1 * k1 + k2 * k2;
  43.     }
  44.  
  45.     //n par y mayor que 2
  46.     return fibo(n / 2) * (fibo((n / 2) + 1) + fibo((n / 2) - 1));
  47.     //si n == 2 fibo(n / 2) * fibo(n / 2 + 1) = fibo(1) * fibo(2)
  48.     //habria recursion infinita si no se pone n == 2 como caso base
  49. }
  50.  
  51. int main(int argc, char *argv[])
  52. {
  53.     fibo_t i,valor;
  54.     time_t ini;
  55.  
  56.     printf("Fibonacci clasico:\n");
  57.  
  58.     ini = time(NULL);
  59.  
  60.     for(i = MIN ; i < MAX ; i++)
  61.     {
  62.         llamadas_clasico = 0;
  63.         valor = fibo_clasico(i);
  64.  
  65.         printf("  fibo_clasico(%llu) = %llu (%llu llamadas)\n",i,valor,llamadas_clasico);
  66.     }
  67.  
  68.     printf("%llu segundos\n",time(NULL) - ini);
  69.  
  70.     printf("\nFibonacci optimizado:\n");
  71.  
  72.     ini = time(NULL);
  73.  
  74.     for(i = MIN ; i < MAX ; i++)
  75.     {
  76.         llamadas_optimizado = 0;
  77.         valor = fibo(i);
  78.  
  79.         printf("  fibo(%llu) = %llu (%llu llamadas)\n",i,valor,llamadas_optimizado);
  80.     }
  81.  
  82.     printf("%llu segundos\n",time(NULL) - ini);
  83.  
  84.     return 0;
  85. }
  86.  

¡Saludos!

Por cierto, ¿cómo has conseguido el código en ensamblador? Supongo que será alguna opción del compilador, pero nunca me he metido mucho a jugar con el, así que no se que opción has utilizado...

¡Saludos!
« Última modificación: 26 Julio 2013, 10:32 am por do-while » En línea
- Doctor, confundo los números y los colores.
- Vaya marrón.
- ¿Marrón? ¡Por el culo te la hinco!
amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #16 en: 26 Julio 2013, 10:49 am »
Cita de: eferion en 22 Julio 2013, 11:00 am
La pregunta entonces es... ¿ Es aplicable ese resultado a cualquier compilador ?

Creo que habría entonces que hacer una batería de pruebas con diferentes compiladores, porque no creo que todos implementen las mismas optimizaciones...
Seguramente las implementaciones varien de un compilador a otro, pero lo normal esque hagan estas optimizaciones automáticamente, si no esque estás usando un compilador-patata.

Cita de: do-while en 26 Julio 2013, 10:30 am
amchacon, eres un tramposo...  :xD

Deja que los niños jueguen en igualdad de condiciones, que sino se sienten discriminados...  ;D
En las sucesiones lineales se pueden hacer muchas trampas  :xD

Seguramente en los juegos lo implementarán así, para ganar rendimiento.

Cita de: do-while en 26 Julio 2013, 10:30 am
Por cierto, ¿cómo has conseguido el código en ensamblador? Supongo que será alguna opción del compilador, pero nunca me he metido mucho a jugar con el, así que no se que opción has utilizado...
Hay que pasarle el flag -S al compilador.

Si usas un IDE como Codeblocks, se puede hacer la siguiente chapuzilla:

- Crea un proyecto de consola, pon el código y vete a Project -> build options -> other options. Escribir -S

Dale a reconstruir todo (control+F11). Al final dará un error (porque intentará linkar y verá que no puede  ;D). Vete a la carpeta obj de tu proyecto y abre el archivo con el notepad.
« Última modificación: 26 Julio 2013, 10:51 am por amchacon » En línea
Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
do-while


Desconectado Desconectado

Mensajes: 1.276


¿Habra que sacarla de paseo?


Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #17 en: 26 Julio 2013, 11:43 am »
¡Buenas!

Me acabo de dar cuenta de que el último valor del vector está mal. Se te ha colado un 1 entre el 3 y el 5. Te aviso por si vas a utilizar el código para otros programas, no vaya a ser que no te salgan los cálculos y te vuelvas loco buscando el origen de todo mal (a mi me ha pasado  ;D) Aquí te dejo el vector correcto.

Código
  1. unsigned long long Fibonaci_Cache[MAX_CACHE] = {0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597
  2. ,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578};
  3.  

¡Saludos!
En línea
- Doctor, confundo los números y los colores.
- Vaya marrón.
- ¿Marrón? ¡Por el culo te la hinco!
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Sucesion de Fibonacci recursiva optimizada
« Respuesta #18 en: 29 Julio 2013, 13:47 pm »
Cita de: amchacon en 26 Julio 2013, 10:49 am
Seguramente las implementaciones varien de un compilador a otro, pero lo normal esque hagan estas optimizaciones automáticamente, si no esque estás usando un compilador-patata.

Yo solo me refería la hecho de que las optimizaciones comentadas fuesen equivalentes al menos en los compiladores más utilizados... ya que si alguno de éstos no es capaz de optimizar alguna de las posibilidades propuestas tal vez habría que optar por la opción B.

En cuanto a las optimizaciones automáticas... variarán en función de cómo configures la compilación... compilar con debug = 0 optimizaciones y de ahí hasta lo que te ofrezca el propio compilador... luego también puedes añadir flags para que las optimizaciones vayan en pro de la velocidad o en pro del consumo de memoria...

En fin, que yo creo que es malo generalizar en este tema.
En línea
Páginas: 1 [2] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Sucesión Fibonacci [Batch] « 1 2 »
Scripting 		leogtz 17 15,220 Último mensaje 15 Junio 2009, 17:26 pm
por leogtz
[Código-Ruby]Sucesión Fibonacci - JaAViEr
Scripting 		0x5d 0 2,748 Último mensaje 8 Enero 2012, 08:57 am
por 0x5d
Duda en el código (porgrama sucesión de Fibonacci)
Programación C/C++ 		b_rabbit10 2 2,611 Último mensaje 18 Febrero 2013, 22:15 pm
por b_rabbit10
[Perl] Ejemplo de Sucesion Fibonacci
Scripting 		BigBear 0 2,647 Último mensaje 5 Diciembre 2014, 15:04 pm
por BigBear
Cómo conseguir una red inalámbrica optimizada
Noticias 		wolfbcn 0 1,098 Último mensaje 27 Octubre 2016, 14:53 pm
por wolfbcn
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines