Problemi di misura N volte il tempo di esecuzione di un blocco di codice

Question

Modifica Ho appena trovato il mio problema dopo aver scritto questo lungo post che spiega ogni piccolo dettaglio ... Se qualcuno mi può dare una buona risposta su quello che sto facendo di sbagliato e come posso ottenere il tempo di esecuzione in secondi (utilizzando un galleggiante con 5 cifre decimali o giù di lì), io contrassegnare che, come accettato. Suggerimento:. Il problema era su come ho interpretato la pagina man clock_getttime ()

Ciao,

dire Let ho una funzione denominata myOperation che ho bisogno di misurare il tempo di esecuzione di. Per misurarla, sto usando clock_gettime() come era raccomandare qui in uno dei commenti.

Il mio insegnante ci raccomanda di misurarla N volte in modo che possiamo avere una, la deviazione standard media e mediana per la relazione finale. Egli raccomanda anche di eseguiamo volte myOperation M invece di uno solo. Se myOperation è un'operazione molto veloce, misurandolo M volte ci permettono di ottenere un senso del "tempo reale" ci vuole; causare l'orologio in uso potrebbe non avere la precisione richiesta per misurare tale operazione. Quindi, l'esecuzione myOperation solo una volta o volte M Dipende molto se l'operazione si prende abbastanza a lungo per la precisione dell'orologio che stiamo usando.

Sto avendo problemi ad affrontare che l'esecuzione volte M. L'aumento M diminuisce (molto) il valore medio finale. Il che non ha senso per me. E 'come questo, in media si prende 3 a 5 secondi per viaggio dal punto A al punto B. Ma poi si va da A a B e di nuovo a A 5 volte (che lo rende 10 volte, causa A a B è lo stesso di B a a) e si misura che. Che si divide per 10, la media si arriva si suppone che sia la stessa media si prende un viaggio dal punto A al punto B, che è da 3 a 5 secondi.

Questo è quello che voglio il mio codice da fare, ma non funziona. Se continuo aumento del numero di volte che va da A a B e viceversa A, la media sarà sempre più in basso ogni volta, non ha senso per me.

teoria abbastanza, ecco il mio codice:

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

#define MEASUREMENTS 1
#define OPERATIONS   1

typedef struct timespec TimeClock;

TimeClock diffTimeClock(TimeClock start, TimeClock end) {
    TimeClock aux;

    if((end.tv_nsec - start.tv_nsec) < 0) {
        aux.tv_sec = end.tv_sec - start.tv_sec - 1;
        aux.tv_nsec = 1E9 + end.tv_nsec - start.tv_nsec;
    } else {
        aux.tv_sec = end.tv_sec - start.tv_sec;
        aux.tv_nsec = end.tv_nsec - start.tv_nsec;
    }

    return aux;
}

int main(void) {
    TimeClock sTime, eTime, dTime;
    int i, j;

    for(i = 0; i < MEASUREMENTS; i++) {
        printf(" » MEASURE %02d\n", i+1);

        clock_gettime(CLOCK_REALTIME, &sTime);

        for(j = 0; j < OPERATIONS; j++) {
            myOperation();
        }

        clock_gettime(CLOCK_REALTIME, &eTime);

        dTime = diffTimeClock(sTime, eTime);

        printf("   - NSEC (TOTAL): %ld\n", dTime.tv_nsec);
        printf("   - NSEC (OP): %ld\n\n", dTime.tv_nsec / OPERATIONS);
    }

    return 0;
}

Note: rel La funzione diffTimeClock di cui sopra è da questo Post . Ho sostituito la mia operazione reale con myOperation(), perché non ha alcun senso per pubblicare le mie funzioni reali come avrei dovuto postare lunghi blocchi di codice, si può facilmente codificare un myOperation() con quello che vuoi compilare il codice se lo si desidera.

Come si può vedere, OPERATIONS = 1 ed i risultati sono i seguenti:

 » MEASURE 01
   - NSEC (TOTAL): 27456580
   - NSEC (OP): 27456580

Per OPERATIONS = 100 i risultati sono i seguenti:

 » MEASURE 01
   - NSEC (TOTAL): 218929736
   - NSEC (OP): 2189297

Per OPERATIONS = 1000 i risultati sono i seguenti:

 » MEASURE 01
   - NSEC (TOTAL): 862834890
   - NSEC (OP): 862834

Per OPERATIONS = 10000 i risultati sono i seguenti:

 » MEASURE 01
   - NSEC (TOTAL): 574133641
   - NSEC (OP): 57413

Ora, io non sono un mago di matematica, lontano da esso in realtà, ma questo non ha alcun senso per me di sorta. Ho già parlato di questo con un amico che è su questo progetto con me e anche lui non riesco a capire le differenze. Non capisco il motivo per cui il valore è sempre più in basso, quando ho aumentare OPERATIONS. L'operazione in sé dovrebbe prendere lo stesso tempo (in media, ovviamente, non è la stessa ora), non importa quante volte ho eseguirlo.

Si potrebbe dirmi che che in realtà dipende l'operazione stessa, i dati che vengono letti e che alcuni dati potrebbero essere già nella cache e bla bla, ma non credo che sia il problema. Nel mio caso, myOperation sta leggendo 5000 righe di testo da un file CSV, separando i valori ; e l'inserimento di quei valori in una struttura di dati. Per ogni iterazione, sto distruggendo la struttura dei dati e l'inizializzazione di nuovo.

Ora che ci penso, anche io che penso che ci'S un problema di misurazione del tempo con clock_gettime(), forse non sto usando nel modo giusto. Voglio dire, guarda l'ultimo esempio, dove OPERATIONS = 10000. Il tempo totale impiegato era 574133641ns, che sarebbe circa 0,5s; che è impossibile, ci sono voluti un paio di minuti come non ho potuto stare a guardare lo schermo di attesa ed è andato a mangiare qualcosa.

Answer 1

Hai solo bisogno di cambiare la vostra funzione diffTimeClock() per restituire il numero di secondi differenza, come double:

double diffTimeClock(TimeClock start, TimeClock end) {
    double diff;

    diff = (end.tv_nsec - start.tv_nsec) / 1E9;
    diff += (end.tv_sec - start.tv_sec);

    return diff;
}

e nella principale cambiamento di routine dTime ad un double, e le printfs per soddisfare:

printf("   - SEC (TOTAL): %f\n", dTime);
printf("   - SEC (OP): %f\n\n", dTime / OPERATIONS);

Answer 2

appare come il tipo TimeClock ha due campi, uno per i secondi e uno per nanosecondi. Non ha senso distinguere solo il campo nanosec con il numero di operazioni. È necessario dividere il tempo totale.

Answer 3

Se si utilizza un sistema POSIX dove c'è gettimeofday () funzione si può usare qualcosa di simile a questo per ottenere l'ora corrente in microsecondi:

long long timeInMicroseconds(void) {
    struct timeval tv;

    gettimeofday(&tv,NULL);
    return (((long long)tv.tv_sec)*1000000)+tv.tv_usec;
}

Il motivo per cui questo è molto pratico è che, al fine di calcolare quanto il vostro funzione ha preso quello che devi fare proprio questo:

long long start = timeInMicroseconds();
... do your task N times ...
printf("Total microseconds: %lld", timeInMicroseconds()-start);

Quindi, non si ha a che fare con due numeri interi, uno con secondi e uno con microsecondi. Aggiunta e tempi sottraendo funzionerà in modo evidente.

Answer 4

io uso in genere la funzione time () per questo. Essa mostra il tempo orologio da parete, ma questo è proprio quello che interessa alla fine.

Una Gotcha con test delle prestazioni è il sistema operativo può memorizzare nella cache le operazioni correlate del file system. Così la seconda (e successivi) piste possono essere molto più veloce rispetto alla prima esecuzione. È in genere bisogno di prova può operazioni e media il risultato di ottenere una buona sensazione per i risultati di eventuali modifiche apportate. Ci sono così tante variabili Questo può aiutare a filtrare il rumore.