Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » AYUDA URGENTE: Función de retardo

C/Visual C - AYUDA URGENTE: Función de retardo

Volver
Nuevo Tema
<<>>
 
Vista:

AYUDA URGENTE: Función de retardo

Publicado por Carlos Escribano Rey (1 intervención) el 23/10/2001 15:45:45
Buenas. Mi problema es que tengo que medir tiempos de proceso de algoritmos de ordenación, pero los ordenatas van a tal leche que no veo forma de que los tiempos den algo distinto de cero patatero.

La cosa consiste en tomar el tiempo de reloj, ejecutar el algoritmo para ordenar la tabla, y al salir, tomar de nuevo el tiempo y restar, es fácil. El problema está en que la cosa va demasiado deprisa y en pocos ciclos de reloj ha ordenado todo, y no es apreciable. Para eso necesito un retardo que no me cuelgue el ordenador y que sea eficiente para grandes cantidades de elementos en tabla. Con un bucle normalillo no me sale bien, aunque de 300.000 vueltas (que lo he hecho, de verdad, y sigue dando cero).

¡Necesito ayuda! Salu2o3, y muchas gracias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Medición de tiempos de proceso en algoritmos de ordenación

Publicado por Alejandro (1153 intervenciones) el 17/10/2024 17:53:42
¡Hola, Carlos! Entiendo tu problema. Cuando los algoritmos de ordenación se ejecutan muy rápido, puede ser difícil medir el tiempo de ejecución de manera precisa. Aquí hay algunas sugerencias para introducir un retardo sin colgar el ordenador y obtener mediciones más significativas:

1. Aumentar el tamaño de los datos


Asegúrate de que estás utilizando un tamaño de datos lo suficientemente grande para que el algoritmo de ordenación tenga un tiempo de ejecución apreciable. Por ejemplo, en lugar de ordenar 300,000 elementos, prueba con 1,000,000 o más.

2. Repetir el proceso


Ejecuta el algoritmo de ordenación varias veces y promedia los tiempos. Esto te dará una mejor idea del tiempo de ejecución. Por ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
void ordenar(int* arr, int n) {
    // Implementa tu algoritmo de ordenación aquí
}
 
int main() {
    int n = 1000000; // Tamaño del arreglo
    int* arr = (int*)malloc(n * sizeof(int));
 
    // Rellenar el arreglo con datos aleatorios
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % 1000000;
    }
 
    clock_t start, end;
    double cpu_time_used;
    int repeticiones = 10; // Número de repeticiones
    double total_time = 0;
 
    for (int i = 0; i < repeticiones; i++) {
        start = clock();
        ordenar(arr, n);
        end = clock();
        cpu_time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
        total_time += cpu_time_used;
    }
 
    printf("Tiempo promedio: %f segundos\n", total_time / repeticiones);
    free(arr);
    return 0;
}

3. Introducir un retardo artificial


Si necesitas un retardo, puedes usar un bucle que consuma tiempo, pero asegúrate de que no sea demasiado largo. Aquí hay un ejemplo de cómo hacerlo:

1
2
3
4
void retardo(int milisegundos) {
    clock_t inicio = clock();
    while (clock() < inicio + milisegundos * (CLOCKS_PER_SEC / 1000));
}

4. Usar funciones de temporización más precisas


En lugar de `clock()`, puedes usar funciones más precisas como `gettimeofday()` en sistemas Unix o `QueryPerformanceCounter()` en Windows. Estas funciones pueden darte una mejor resolución en la medición del tiempo.

5. Ejemplo de uso de `gettimeofday()`


Aquí tienes un ejemplo de cómo usar `gettimeofday()`:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
 
void ordenar(int* arr, int n) {
    // Implementa tu algoritmo de ordenación aquí
}
 
int main() {
    int n = 1000000; // Tamaño del arreglo
    int* arr = (int*)malloc(n * sizeof(int));
 
    // Rellenar el arreglo con datos aleatorios
    for (int i = 0; i < n; i++) {
        arr[i] = rand() % 1000000;
    }
 
    struct timeval start, end;
    double total_time = 0;
    int repeticiones = 10; // Número de repeticiones
 
    for (int i = 0; i < repeticiones; i++) {
        gettimeofday(&start, NULL);
        ordenar(arr, n);
        gettimeofday(&end, NULL);
        double time_taken = (end.tv_sec - start.tv_sec) * 1e6; // convertir a microsegundos
        time_taken = (time_taken + (end.tv_usec - start.tv_usec)) * 1e-6; // convertir a segundos
        total_time += time_taken;
    }
 
    printf("Tiempo promedio: %f segundos\n", total_time / repeticiones);
    free(arr);
    return 0;
}

Conclusión


Prueba estas sugerencias y ajusta el tamaño de los datos y el número de repeticiones para obtener mediciones más precisas. ¡Suerte!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar