Milisekundy i mikrosekundy do logu

[Borneq]

Mam
struct tm
{
int tm_sec; // seconds after the minute - [0, 60] including leap
second
int tm_min; // minutes after the hour - [0, 59]
int tm_hour; // hours since midnight - [0, 23]
int tm_mday; // day of the month - [1, 31]
int tm_mon; // months since January - [0, 11]
int tm_year; // years since 1900
int tm_wday; // days since Sunday - [0, 6]
int tm_yday; // days since January 1 - [0, 365]
int tm_isdst; // daylight savings time flag
};
time_t t = time(0); // get time now
struct tm* now = localtime(&t);
fp << now->tm_year + 1900 << "-" << now->tm_mon + 1 << "-" <<
now->tm_mday << " "
<< now->tm_hour << ":" << now->tm_min << ":" << now->tm_sec << " ";
fp << str;

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

[Piotr Gałka]

Post by Borneq
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.

[Borneq]

Post by Piotr Gałka

Post by Borneq
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 !

[bartekltg]

Post by Borneq
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

[Borneq]

Post by bartekltg
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 ?

[bartekltg]

Post by Borneq

Post by bartekltg
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;

Post by Borneq
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

[Borneq]

Post by bartekltg
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);
}
}

[bartekltg]

Post by bartekltg

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

#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