pomiar czasu c++ jak zwiększyć dokładność

Question

Cześć 

Jak mogę zwiększyć dokładność pomiaru czasu ? Chodzi o to aby przy sortowaniu tablicy o mniejszym rozmiarze otrzymać jakiś konkretny wynik a nie 0.

#include<iostream>
#include<conio.h>
#include<ctime>
#include<stdlib.h>
#include<chrono>
#define N 2000

using namespace std;

using tp = std::chrono::time_point<std::chrono::system_clock>;
using duration = std::chrono::duration<long double>;

void filltab(int *t);
void bubbleSort(int *t);
void printArray(int *t);

int main()
{
    int t[N];

    filltab(t);
    tp start = std::chrono::system_clock::now();
    bubbleSort(t);
    duration d = std::chrono::system_clock::now() - start;
    printf("Czas:%.20lf sekund",(d).count());
    return 0;
}

void filltab(int *tab)
{
    srand(time(NULL));

    for(int i=0; i<N; i++)
    {
        tab[i]=rand()%101;
    }
}

void bubbleSort(int *t)
{
    int zamiana,schowek;

    do
    {
        zamiana=0;
        for (int i=0; i<N; i++)
        {
            if (t[i]>t[i+1])
            {
                zamiana=+1;
                schowek=t[i];
                t[i]=t[i+1];
                t[i+1]=schowek;
            }
        }
    }
    while(zamiana!=0);

}

void printArray(int *t)
{
    for (int j=0; j<N; j++)
    {
        cout<<t[j]<<endl;
    }
}

 

Answer 1

main.cpp:24:33: warning: format specifies type 'double' but the argument has type 'rep' (aka 'long double') [-Wformat]
    printf("Czas:%.20lf sekund",(d).count());
                 ~~~~~~         ^~~~~~~~~~~

Użyj zwykłe `double` zamiast `long double` (i cout zamiast zgadywania formatów).

Comments

using duration = std::chrono::duration<double>;
cout<<(d).count();

Jeśli chodziło ci o te zmiany to nie dają oczekiwanego efektu

---

To nie wiem co powiedzieć, bo mi działają:

#define N 20000
int main()
{
    int t[N];
 
    filltab(t);
    auto start = std::chrono::system_clock::now();
    bubbleSort(t);
    std::chrono::duration<double> d = std::chrono::system_clock::now() - start;
    std::cout << d.count() << "\n";
    return 0;
}

Spróbuj jeszcze użyć `high_resolution_clock` zamiast `system_clock`.

---

Przy sortowaniu tablicy przy np. N 200 ciągle jest 0. Zarówno jak używam system_clock i high_resolution_clock.

Answer 2

Do linii 25 poprawiłem... 

#include <iostream>
#include <conio.h>
#include <ctime>
#include <cstdlib>
#include <chrono>
#define N 1000
 
using namespace std;
 
void filltab(int *t);
void bubbleSort(int *t);
void printArray(int *t);
 
int main()
{
    int t[N];
 
    filltab(t);
    auto start = std::chrono::high_resolution_clock::now();
    bubbleSort(t);
    auto stop = std::chrono::high_resolution_clock::now();
    auto d_mks = std::chrono::duration_cast<std::chrono::microseconds>(stop - start).count();
    std::cout << "Czas: " << d_mks << " mikrosekund.\n";
    
    return EXIT_SUCCESS;
}

 

Comments

Przy sortowaniu małych tablic np. N=200 wynik jest równy 0

---

Przeczytaj w dokumentacji jak działa i czy działa high_resolution_clock. Dodatkowo sprawdź co robi kompilator w przypadku optymalizacji. Pomiar dla małych ilości danych nie ma większego sensu choć jest dostępna rozdzielczość nawet nanoseconds http://en.cppreference.com/w/cpp/chrono/duration

Pomiary wykonuje się raczej w pętli powtarzając działania i wyciągając średnią. Zawsze może Ci się "wbić" pomiędzy operacje jakieś działanie  lub możesz mieć szczęście z cache. Tu potrzeba jest odrobiny statystyki.

---

Dzięki za odpowiedź, ale mam jeszcze jedno pytanie. Kiedy bym chciał liczyć średnią to i tak nie ma sensu, bo jeśli wynik pojedyńczego pomiaru jest równy 0. To obliczanie średniej nic mi nie daje. Jeśli chodzi o zmianę na micro czy nano sekundy to też nie rozwiązuje problemu, bo jeśli wynik w sekundach jest inny niż 0 to po prostu wartość jest zwiększana w przypadku micro i nano. Natomiast jeśli wynik w sekundach jest równy 0 to w micro i nano jest taki sam.

---

Po prostu nie licz dla 100 wstawianych wartości bo to nie ma żadnego sensu. Szum zjawisk systemowych totalnie zaburzy Ci wyniki a mała wartość czasu może być poniżej dostarczanej rozdzielczości przez platformę. Poziom milisekund jest do sensownych (o wiele większych niż proponowane przez Ciebie) wielkości kontenerów akceptowalny. Popatrz co jest wpisane w 1 akapicie: http://en.cppreference.com/w/cpp/chrono/high_resolution_clock

Zapoznaj się z zegarami tu: http://en.cppreference.com/w/cpp/chrono

I jeśli masz pytania co do chrono, warto zerknąć tu: https://www.youtube.com/watch?v=P32hvk8b13M

Jeśli jednak interesuje Cię pomiar bardzo dokładny, odeślę już do mechanizmów systemowych.

PS. Ja korzystam często z tej biblioteki: https://github.com/google/benchmark

Answer 3

Cześć :)

Spróbuj wykorzystać bibliotekę sys/time.h

Przykład:

#include <sys/time.h>

int main()
{

    int t[N];
    struct timeval koniec, poczatek;


    filltab(t);

    gettimeofday(&poczatek, NULL);

    bubbleSort(t);

    gettimeofday(&koniec, NULL);

    printf("took %lu\n", koniec.tv_usec - poczatek.tv_usec);

    return 0;

}

Comments

Dostajesz downvote'y za specyficzne dla systemu rozwiązanie, w dodatku w C (C++ ma do tego uniwersalne narzędzia).

Gdyby to było C na Linuxie, to by jeszcze było w miarę ok - na przykład sam libstdc++ <chrono> wewnętrznie używa gettimeofday, (ale też lepsze funkcje w zależności od konfiguracji): https://github.com/gcc-mirror/gcc/blob/da8dff89fa9398f04b107e388cb706517ced9505/libstdc%2B%2B-v3/src/c%2B%2B11/chrono.cc#L54

Tylko, że niestety robisz to błędnie - samo odejmowanie tv_usec nie ma sensu, wynik może wyjść ujemny.

---

Już rozumiem, dziękuję za wytłumaczenie

Szkoda, że są te downvote'y, ale no cóż jak źle, to źle.

---

- W ogólnym przypadku to dobrze, że są, bo to konstruktywna krytyka. Pozwalają zachować samodyscyplinę. (Nie odbierają punktów).

---

@adrian17, 

Hej,

Dziękuję z komentarz konstruktywny i pozwalający mi poprawnie zrobić taką operację.

Zajęło mi go przetrawienie i tych łapek w dół, wróciłem tu dopiero co po posłuchaniu podcastu.

Pozdrawiam,

Jakub