Medir velocidad de ejecución de un programa en lenguaje C.-

[NOB2014]

Hola a todos.
Voy a exponer el código y como lo implemente para que me digan si es correcto porque me quedan dudas con el resultado, por Ej. 4294967199, ¿estos son milisegundos y 4.30.... segundos?.-

En cuanto a Linux, se puede poner esta línea para que la salida vaya a un archivo de texto. -
>> (time ls) 2> salida.txt

Código (c) [Seleccionar] Expandir

int main( void ){
size_t vector[] = {99, 8, 13, 6, 10, 40, 7, 2, 1,74}, *ptrV = vector;
static size_t elementos = sizeof (vector) / sizeof (size_t);
clock_t cl = clock();

ordenar(ptrV, elementos);
mostrar(ptrV, elementos);

cl = clock() - cl;

printf("\n\n %lu", (cl*1000)/CLOCKS_PER_SEC);

return 0;
}
Saludos.
Daniel

[class_OpenGL]

No, el resultado está en milisegundos. Deduzco que por alguna razón te está saliendo un número negativo en la operación "cl = clock() - cl;", pero al interpretar ese número negativo como un entero sin signo, te sale ese número. Si en vez de mostrarlo como un entero sin signo lo mostraras con signo, te saldría -97 ms...

No sé por qué razón te sale un tiempo negativo... Prueba a compilar con otro compilador. Yo he compilado el código tal y como tu lo tienes y me salen resultados coherentes...

[NOB2014]

Hola.
Bueno a pesar de no lograr el cometido porque realmente todas las pruebas que hice no me dieron resultdo, encontré una aplicación utilizando la librería windows.h  que funciona muy bien, me gustaría colgarla aquí, pero como no conozco si es legal esto de sacar programas de una página y copiarlo en otra mejor lo dejamos ahí. -
Lo que quiero consultarles concretamente es ¿es posible generar números aleatorios sin que se repitan?  o la única manera es por cada número generado verificar si ya se encuentra en el arreglo. -

Código (c) [Seleccionar] Expandir

#include<stdio.h>
#include<stdlib.h>
#include<time.h>


void llenar( size_t *ptrNumeros );
void ordenar( size_t *ptrNumeros );
void mostrar( size_t *ptrNumeros );
#define TAM 102

int main( int argc, char *argv[] ){
size_t numeros[TAM], *ptrNumeros = numeros;

llenar( ptrNumeros );
ordenar( ptrNumeros );
mostrar( ptrNumeros );

return 0;
}

void llenar( size_t *ptrNumeros ){
size_t hora = time(NULL), i;
srand(hora);

for(i = 0; i < TAM; i++){
*(ptrNumeros + i) = rand()% 100 + 200;
}
}

void ordenar( size_t *ptrNumeros ){
size_t i = 0, tmp = 0;

while(1){
if( *( ptrNumeros+i) >  *(ptrNumeros+(i+1)) ){
tmp = *(ptrNumeros+i);
*(ptrNumeros+i) = *(ptrNumeros+(i+1));
*(ptrNumeros+(i+1)) = tmp;
}
if( i+1 == TAM ){
if( tmp == 0) break;
else{tmp = 0; i = -1;}
}
i++;
}
}

void mostrar(size_t *ptrNumeros){
size_t i;

for( i = 0; i < TAM; i++ ){
if( i%10 == 0 ) printf( "\n" );
printf( " %u", *(ptrNumeros+i) );
}
}

Saludos.
Daniel

[class_OpenGL]

Podrías generar un número aleatorio guardado en el primer elemento, y cuando calcules un número aleatorio en el segundo, si este es igual al primero, generas otro número aleatorio, y así para todas las posiciones del arreglo. Es una solución relativamente sencilla, pero no sé si será la mejor porque dependes de que te salga un número aleatorio diferente (saldrá, pero no sé después de cuántas ejecuciones)

[NOB2014]

Hola, amigo.
Te dejo la manera que lo hice, no tarda tanto en aparecer los 100 números, Parece ser lo que me propones.

Código (c) [Seleccionar] Expandir

void llenar( size_t *ptrNumeros ){
size_t hora = time(NULL), i, tmp, ok = 0;
srand(hora);

for(i = 0; i < TAM; i++){
do{
tmp = rand()% 999 + 1 ;
ok = verifica( ptrNumeros, tmp );
}while(ok);
*( ptrNumeros + i ) = tmp;
}
}

int verifica( size_t *ptrNumeros, size_t tmp ){
size_t i, stop = 0;

for( i = 0; i < TAM; i++ ){
if( *( ptrNumeros + i) == tmp )
stop = 1;
}

return stop;
}

Saludos.

[MAFUS]

Con el problema de contar los tiempos: yo he terminado de hacer este programa y me cuenta hasta los microsegundos.

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <time.h>

int main() {
    time_t c=clock();
    long unsigned j = 1;
   
    for(long unsigned i = 0; i < 1000000000; ++i) {
        if(i == j) {
            printf("t(%lu) = %f\n", j, (clock() - c)*1.0/CLOCKS_PER_SEC);
            j *= 10;
        }
    }
    printf("t(%lu) = %f\n", j, (clock() - c)*1.0/CLOCKS_PER_SEC);
   
    return 0;
}

[crack81]

Hola : NOB2014

Tu código parase que ya funciona solo mencionaria unos detalles

Ejemplo esta linea:

Código (c) [Seleccionar] Expandir

size_t numeros[TAM], *ptrNumeros = numeros;

No es necesario crear un arreglo y luego asignárselo a un puntero. Si por ejemplo lo vas a pasar por parametro a una funcion, el cual esta declarado de esta forma:

Código (c) [Seleccionar] Expandir

void llenar( size_t *ptrNumeros )
basta con ponerlo directamente al final de cuentas un arreglo es una estructura que apunta a una dirección en resumen es un puntero

Ejemplo:

Código (c) [Seleccionar] Expandir

size_t numeros[TAM]
llenar( numeros );

Otro detalle, este ya es en gustos, te aconsejaría remplazar esta forma de asignar el arreglo:

Código (c) [Seleccionar] Expandir

*(ptrNumeros + i) = rand()% 100 + 200;
Y recomendaría mejor esta:

Código (c) [Seleccionar] Expandir

ptrNumeros[i]= rand()% 100 + 200;

Las dos formas funcionan igual pero, la segunda forma hace tu código mas legible, y se hace mas a relucir cuando se aumenta el tamaño y complejidad del proyecto


Espero mis comentarios no se tomen a mal
Salutos....

[NOB2014]

Hola.
MAFUS, te dejo una captura para que me digas que es lo que estoy leyendo, segundos, milesegundos. -



crack81, muchas pero muchas gracias por esas sugerencias no tenes una idea como se agradece de este lado, no obstante (como lo aclare al principio) lo hice con punteros porque estoy estudiando justamente punteros y estaba practicando. -

Un abrazo y muchas gracias por el tiempo que le dedicaron al tema. -
Daniel

[class_OpenGL]

Solo es cuestión de observación. ¿Estás usando cl/CLOCKS_PER_SEC o (cl*1000)/CLOCKS_PER_SEC? Si estás usando la primera opción, son segundos (te lo dice CLOCKS_PER_SEC), pero si estás usando la segunda  opción estás viendo milisegundos, porque estás multiplicando los segundos por 1000.

[MAFUS]

La unidad es el segundo: 1.000000 es 1 segundo.