🚀 go-pugleaf

On Wednesday, April 11, 2018 at 6:50:09 PM UTC+2, Maciek wrote:
> Cześć. Chciałem zapytać dlaczego poniższy test nie działa:
> 
> std::cout<<((double)(c_after - c_before)/CLOCKS_PER_SEC>=1.0)<<" \r";
> 
> Chodzi o to e chce coś zrobić kiedy ten test będzie true c_after - c_before mają wynik funkcji clock().
> 
> To tyle w dużym skrócie. Dzięki cześć.

Wyrażenie wygląda OK, wyświetl sobie c_after oraz c_before
i zobacz co tam masz.

BTW skoro używasz C++, to zainteresuj się nagłówkiem chrono,
bardzo porządnie zrobiony -- http://en.cppreference.com/w/cpp/header/chrono.

w.

W dniu środa, 11 kwietnia 2018 21:53:29 UTC+2 użytkownik Wojciech Muła napisał:
> On Wednesday, April 11, 2018 at 6:50:09 PM UTC+2, Maciek wrote:
> > Cześć. Chciałem zapytać dlaczego poniższy test nie działa:
> > 
> > std::cout<<((double)(c_after - c_before)/CLOCKS_PER_SEC>=1.0)<<" \r";
> > 
> > Chodzi o to e chce coś zrobić kiedy ten test będzie true c_after - c_before mają wynik funkcji clock().
> > 
> > To tyle w dużym skrócie. Dzięki cześć.
> 
> Wyrażenie wygląda OK, wyświetl sobie c_after oraz c_before
> i zobacz co tam masz.
> 
> BTW skoro używasz C++, to zainteresuj się nagłówkiem chrono,
> bardzo porządnie zrobiony -- http://en.cppreference.com/w/cpp/header/chrono.
> 
> w.

To jesteś mi w stanie wytumaczyć dlaczego poniższa funkcja nie działa:

            unsigned int a=0, b=0, c=0, d=0, result=0;
            unsigned int op_per_sec;
            std::clock_t c_before, c_after=0;
            c_before=std::clock();
            std::vector<unsigned int> vec(1000000);
            for(unsigned int i=0; i<100000000; ++i) {
                result = a+b+c+d;
                ++op_per_sec;
                c_after = std::clock();
                if((double(c_after - c_before)/CLOCKS_PER_SEC)>=1.0)
                std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
                std::cout.flush();
                c_before = std::clock();
                op_per_sec = 0;
            }
        }

konkretnie linia                 std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";

nic mi nie wypisuje.

W dniu 2018-04-12 o 09:56, Maciek pisze:
> 
> To jesteś mi w stanie wytumaczyć dlaczego poniższa funkcja nie działa:
> 
>              unsigned int a=0, b=0, c=0, d=0, result=0;
>              unsigned int op_per_sec;
>              std::clock_t c_before, c_after=0;
>              c_before=std::clock();
>              std::vector<unsigned int> vec(1000000);
>              for(unsigned int i=0; i<100000000; ++i) {
>                  result = a+b+c+d;
>                  ++op_per_sec;
>                  c_after = std::clock();
>                  if((double(c_after - c_before)/CLOCKS_PER_SEC)>=1.0)
>                  std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
>                  std::cout.flush();
>                  c_before = std::clock();
>                  op_per_sec = 0;
>              }
>          }
> 
> konkretnie linia                 std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
> 
> nic mi nie wypisuje.
> 

Może problemem jest instrukcja sterująca "if"?

P.S.

> if((double(c_after - c_before)/CLOCKS_PER_SEC)>=1.0) 

Tu są 2 możliwe problemy:
1) c_after - c_before : ta wartość jest bardzo mała w porównaniu do CLOCKS_PER_SEC. Więc możliwe, że dzielenie jest < 1.0. 
Może jest to twój błąd, bo obie wartości ustawiasz w tej samej iteracji twojej pętli, wiec różnica jest bardzo mała (bo jest to zaledwie kilkanaście cykli).
Wiec jak dzielisz to przez 1M to na pewno jest dużo mniej niż 1...

2) CLOCKS_PER_SEC może być int: ze strony: http://en.cppreference.com/w/cpp/chrono/c/CLOCKS_PER_SEC
#define CLOCKS_PER_SEC /*implementation defined*/
POSIX defines CLOCKS_PER_SEC as one million, regardless of the actual precision of std::clock().
Dokładnie nie pamiętam zasad promocji typów w C++, ale dla pewności należało by również rzutować CLOCKS_PER_SEC do double
if((double(c_after - c_before)/((double)CLOCKS_PER_SEC))>=1.0)

On Thursday, April 12, 2018 at 9:56:05 AM UTC+2, Maciek wrote:
> W dniu środa, 11 kwietnia 2018 21:53:29 UTC+2 użytkownik Wojciech Muła napisał:
> > On Wednesday, April 11, 2018 at 6:50:09 PM UTC+2, Maciek wrote:
> > > Cześć. Chciałem zapytać dlaczego poniższy test nie działa:
> > > 
> > > std::cout<<((double)(c_after - c_before)/CLOCKS_PER_SEC>=1.0)<<" \r";
> > > 
> > > Chodzi o to e chce coś zrobić kiedy ten test będzie true c_after - c_before mają wynik funkcji clock().
> > > 
> > > To tyle w dużym skrócie. Dzięki cześć.
> > 
> > Wyrażenie wygląda OK, wyświetl sobie c_after oraz c_before
> > i zobacz co tam masz.
> > 
> > BTW skoro używasz C++, to zainteresuj się nagłówkiem chrono,
> > bardzo porządnie zrobiony -- http://en.cppreference.com/w/cpp/header/chrono.
> > 
> > w.
> 
> To jesteś mi w stanie wytumaczyć dlaczego poniższa funkcja nie działa:
> 
>             unsigned int a=0, b=0, c=0, d=0, result=0;
>             unsigned int op_per_sec;
>             std::clock_t c_before, c_after=0;
>             c_before=std::clock();
>             std::vector<unsigned int> vec(1000000);
>             for(unsigned int i=0; i<100000000; ++i) {
>                 result = a+b+c+d;
>                 ++op_per_sec;
>                 c_after = std::clock();
>                 if((double(c_after - c_before)/CLOCKS_PER_SEC)>=1.0)
>                 std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
>                 std::cout.flush();
>                 c_before = std::clock();
>                 op_per_sec = 0;
>             }
>         }
> 
> konkretnie linia                 std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
> 
> nic mi nie wypisuje.

Popatrz na ten program dobrze. Nadmiar pythona;p

>                 std::cout.flush();
>                 c_before = std::clock();
>                 op_per_sec = 0;

robisz w _każdej_ pętli, więc c_before zawsze
jest aktualne, ma wartość z poprzedniej pętli,
mierzysz więc czas wykonania pojedyńczej pętli, nie
od początku/od resetu.

Wstaw klamerki

unsigned int bar(){
    uint64_t  a=0, b=0, c=0, d=0, result=0;
    uint64_t  op_per_sec;
    std::clock_t c_before, c_after=0;
    c_before=std::clock();
    std::vector<unsigned int> vec(1000000);
    for(uint64_t i=0; i<1000000000000llu; ++i) {
        result = a+b+c+d;
        ++op_per_sec;
        c_after = std::clock();
        if((double(c_after - c_before)/CLOCKS_PER_SEC)>=1.0){
            std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
            std::cout.flush();
            c_before = std::clock();
            op_per_sec = 0;
        }
    }
    return result;
} 


pzdr
bartekltg

On Thursday, April 12, 2018 at 3:42:13 PM UTC+2, bartekltg wrote:
> On Thursday, April 12, 2018 at 9:56:05 AM UTC+2, Maciek wrote:
> > W dniu środa, 11 kwietnia 2018 21:53:29 UTC+2 użytkownik Wojciech Muła napisał:
> > > On Wednesday, April 11, 2018 at 6:50:09 PM UTC+2, Maciek wrote:
> > > > Cześć. Chciałem zapytać dlaczego poniższy test nie działa:
> > > > 
> > > > std::cout<<((double)(c_after - c_before)/CLOCKS_PER_SEC>=1.0)<<" \r";
> > > > 
> > > > Chodzi o to e chce coś zrobić kiedy ten test będzie true c_after - c_before mają wynik funkcji clock().
> > > > 
> > > > To tyle w dużym skrócie. Dzięki cześć.
> > > 
> > > Wyrażenie wygląda OK, wyświetl sobie c_after oraz c_before
> > > i zobacz co tam masz.
> > > 
> > > BTW skoro używasz C++, to zainteresuj się nagłówkiem chrono,
> > > bardzo porządnie zrobiony -- http://en.cppreference.com/w/cpp/header/chrono.
> > > 
> > > w.
> > 
> > To jesteś mi w stanie wytumaczyć dlaczego poniższa funkcja nie działa:
> > 
> >             unsigned int a=0, b=0, c=0, d=0, result=0;
> >             unsigned int op_per_sec;
> >             std::clock_t c_before, c_after=0;
> >             c_before=std::clock();
> >             std::vector<unsigned int> vec(1000000);
> >             for(unsigned int i=0; i<100000000; ++i) {
> >                 result = a+b+c+d;
> >                 ++op_per_sec;
> >                 c_after = std::clock();
> >                 if((double(c_after - c_before)/CLOCKS_PER_SEC)>=1.0)
> >                 std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
> >                 std::cout.flush();
> >                 c_before = std::clock();
> >                 op_per_sec = 0;
> >             }
> >         }
> > 
> > konkretnie linia                 std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
> > 
> > nic mi nie wypisuje.
> 
> Popatrz na ten program dobrze. Nadmiar pythona;p
> 
> >                 std::cout.flush();
> >                 c_before = std::clock();
> >                 op_per_sec = 0;
> 
> robisz w _każdej_ pętli, więc c_before zawsze
> jest aktualne, ma wartość z poprzedniej pętli,
> mierzysz więc czas wykonania pojedyńczej pętli, nie
> od początku/od resetu.
> 
> Wstaw klamerki
> 
> unsigned int bar(){
>     uint64_t  a=0, b=0, c=0, d=0, result=0;
>     uint64_t  op_per_sec;
>     std::clock_t c_before, c_after=0;
>     c_before=std::clock();
>     std::vector<unsigned int> vec(1000000);
>     for(uint64_t i=0; i<1000000000000llu; ++i) {
>         result = a+b+c+d;
>         ++op_per_sec;
>         c_after = std::clock();
>         if((double(c_after - c_before)/CLOCKS_PER_SEC)>=1.0){
>             std::cout<<"IN FUNCTION "<<__func__<<"OP PER SEC IS : "<<op_per_sec<<"    \r";
>             std::cout.flush();
>             c_before = std::clock();
>             op_per_sec = 0;
>         }
>     }
>     return result;
> } 
> 


BTW, jeśli chesz w ten sposób mierzyć wydajność, to to jest
kiespki pomysł, bo patrzenie na zegar i porównywanie zajmuje
więcej czasu niż właściwe operacje. 
Zadań blok operacji (możesz w trakcie dobierać jego wielkość)
i mierz czas w jakim wykona się k operacji. 

pzdr
bartekltg