🚀 go-pugleaf

W dniu 14-01-2017 o 18:11, Borneq pisze:
>
> Do logu wypisuję czas, chciałbym mieć dokładność lepsza niż sekunda
> zarówno pod Windows jak i Linuxa

Kiedyś stosowałem ftime() pobierającą czas do struktury timeb.
Składowa millitm to _niby_ milisekundy.
W okolicy 1990 millitim przyrastał (DOS) skokowo co 50ms lub 60ms.
Później pod Windows na niektórych komputerach było jak dawniej, a na 
innych przyrastał co kilkanaście ms. Jak jest obecnie to nie wiem.
Windows to nie jest system czasu rzeczywistego. Sądzę, że nawet jak z 
eksperymentów by wyszło, że mamy czas z dokładnością do kilkunastu ms to 
nie można być pewnym czy w jakichś sytuacjach nie ma większych wyrw.
Kiedyś spotkałem info, że jak się dyskietkę włoży to wszystko staje na 
kilka sekund. Dziś już nie ma dyskietek, ale są inne rzeczy 
podłączane/wkładane.
P.G.

W dniu 16.01.2017 o 11:57, Piotr Gałka pisze:
> W dniu 14-01-2017 o 18:11, Borneq pisze:
>>
>> Do logu wypisuję czas, chciałbym mieć dokładność lepsza niż sekunda
>> zarówno pod Windows jak i Linuxa
>
> Kiedyś stosowałem ftime() pobierającą czas do struktury timeb.
> Składowa millitm to _niby_ milisekundy.
> W okolicy 1990 millitim przyrastał (DOS) skokowo co 50ms lub 60ms.
> Później pod Windows na niektórych komputerach było jak dawniej, a na
> innych przyrastał co kilkanaście ms. Jak jest obecnie to nie wiem.

Czyli chodzi o tick systemu operacyjnego, dla Dos było to 18/s dla 
Windows 64/s a dla Linuxa 100/s. Ale nie wiem ,czy przypadkiem dla 
nowych Windows 8,10 nie jest to już 1000/s !

On 14.01.2017 18:11, Borneq wrote:

> Do logu wypisuję czas, chciałbym mieć dokładność lepsza niż sekunda
> zarówno pod Windows jak i Linuxa


Użyj c++ ;-)

#include <vector>
#include <chrono>

int main(int argc, char *argv[])
{


     auto start= std::chrono::high_resolution_clock::now();

     vector <decltype( start)> stop;

     for (int i=0;i<30;i++)
         stop.push_back (std::chrono::high_resolution_clock::now());

     for (auto s : stop)
         std::cout << 
std::chrono::duration_cast<std::chrono::nanoseconds>(s-start).count() << 
"ns" << std::endl;

}




Wyniki (linux)


    489
     3422
     7822
     8311
     9289
    10267
    10755
    11244
    12222
    13200
    13689
    14667
    15155
    15644
    16622
    17111
    18089
    19067
    20044
    20533
    21511
    22000
    22489
    23467
    23955
    24933
    25422
    26400
    26889
    27867


Robimy diffa:


    2933
    4400
     489
     978
     978
     488
     489
     978
     978
     489
     978
     488
     489
     978
     489
     978
     978
     977
     489
     978
     489
     489
     978
     488
     978
     489
     978
     489
     978


Wygląda, że tyka co mniej niż 1 us.

To powinien być zegar o najmniejszym okresie dostępny na kompie.
Być mozę do niektórych zastosowań lepszy bedzie steady_clock.
Godzin,ę wyciagasz tak
http://en.cppreference.com/w/cpp/chrono/time_point/time_since_epoch


pzdr
bartekltg

W dniu 16.01.2017 o 14:00, bartekltg pisze:
> Godzin,ę wyciagasz tak
> http://en.cppreference.com/w/cpp/chrono/time_point/time_since_epoch

std::time_t today_time = std::chrono::system_clock::to_time_t(p2);
std::cout << "today: " << std::ctime(&today_time);

fajne, jest czas, ale jak określić ile mikrosekund końcówki?
chrono jest w nanosekundach, więc trzeba wartość chrono % 1000000000
a sekunda to chrono / 1000000000 ?

On 16.01.2017 14:19, Borneq wrote:
> W dniu 16.01.2017 o 14:00, bartekltg pisze:
>> Godzin,ę wyciagasz tak
>> http://en.cppreference.com/w/cpp/chrono/time_point/time_since_epoch
>
> std::time_t today_time = std::chrono::system_clock::to_time_t(p2);
> std::cout << "today: " << std::ctime(&today_time);
>
> fajne, jest czas, ale jak określić ile mikrosekund końcówki?

Pewnie gdzieś jest, poczytaj dokumnetjcę.

W najgorszym wypadku weźmiesz sobie w odpowiednich jednostkach
od poczatku świata i sam utneisz koncowkę:


 
cout<<endl<<std::chrono::duration_cast<std::chrono::nanoseconds>(start.time_since_epoch()).count() 
<<endl;


> chrono jest w nanosekundach, więc trzeba wartość chrono % 1000000000
> a sekunda to chrono / 1000000000 ?

Nie zerknąłeś nawet do tego kodu, porawda;> Inaczej zauwałzyłbytś, że
nanosekundy wypluwa, bo tak kazałem ;p

Chrono jest w tym, co chcesz. Mozesz tam zamiast nanosekund wpisać nie 
jesdnostki.

np

std::chrono::duration_cast<std::chrono::milliseconds>(start.time_since_epoch()).count()


pzdr
bartekltg

W dniu 16.01.2017 o 15:06, bartekltg pisze:
> Nie zerknąłeś nawet do tego kodu, porawda;> Inaczej zauwałzyłbytś, że
> nanosekundy wypluwa, bo tak kazałem ;p

Moja propozycja:
#include <vector>
#include <iostream>
#include <chrono>

using namespace std;

void printf_chrono(ostream &fp, 
std::chrono::time_point<std::chrono::system_clock> p)
{
	int64_t usAfterEpoch = 
std::chrono::duration_cast<std::chrono::microseconds>(p.time_since_epoch()).count();
	time_t p_time = std::chrono::system_clock::to_time_t(p);
	struct tm* now = localtime(&p_time);
	fp << now->tm_year + 1900 << "-" << now->tm_mon + 1 << "-" << 
now->tm_mday << " "
		<< now->tm_hour << ":" << now->tm_min << ":" << now->tm_sec;	
	int64_t usAfterSecond = usAfterEpoch % (1000 * 1000);
	char usBuf[10];
	sprintf(usBuf, ".%06d", usAfterSecond);
	cout << usBuf << endl;
}

int main(int argc, char *argv[])
{
	std::chrono::time_point<std::chrono::system_clock> p;
	for (int i = 0; i < 20; i++)
	{
		_sleep(101);
		p = std::chrono::system_clock::now();
		printf_chrono(cout, p);
	}	
}

On 16.01.2017 18:52, Borneq wrote:
> W dniu 16.01.2017 o 15:06, bartekltg pisze:
>> Nie zerknąłeś nawet do tego kodu, porawda;> Inaczej zauwałzyłbytś, że
>> nanosekundy wypluwa, bo tak kazałem ;p
>
> Moja propozycja:
> #include <vector>
> #include <iostream>
> #include <chrono>
>
> using namespace std;
>
> void printf_chrono(ostream &fp,
> std::chrono::time_point<std::chrono::system_clock> p)
> {
>     int64_t usAfterEpoch =
> std::chrono::duration_cast<std::chrono::microseconds>(p.time_since_epoch()).count();
>
>     time_t p_time = std::chrono::system_clock::to_time_t(p);
>     struct tm* now = localtime(&p_time);
>     fp << now->tm_year + 1900 << "-" << now->tm_mon + 1 << "-" <<
> now->tm_mday << " "
>         << now->tm_hour << ":" << now->tm_min << ":" << now->tm_sec;
>     int64_t usAfterSecond = usAfterEpoch % (1000 * 1000);
>     char usBuf[10];
>     sprintf(usBuf, ".%06d", usAfterSecond);
>     cout << usBuf << endl;
> }
>
> int main(int argc, char *argv[])
> {
>     std::chrono::time_point<std::chrono::system_clock> p;
>     for (int i = 0; i < 20; i++)
>     {
>         _sleep(101);
>         p = std::chrono::system_clock::now();
>         printf_chrono(cout, p);
>     }
> }


IMHO ładniej by było użyć:
http://en.cppreference.com/w/cpp/chrono/time_point/time_point_cast

Rzutujesz na sekundy, potem odejmujesz pełnosekundowy
punkt czasu od rzeczywistego. Nie ma wtedy zabawy w ręczne
dzielenia etc. Ale to raczej estetyka niż poprawność:)

pzdr
bartekltg