纳秒和计时 C++

Question

2018-10-01 00:06:16.700000000

我有一个带有上述时间戳的时间序列数据文件。 我需要将其转换为从纪元开始的纳秒，然后我需要将毫秒、微米或纳秒添加到时间戳（移位）。最后，对于选择记录，将其恢复为上述格式。

我在创建时间点时遇到问题 - 以及如何表示纳秒......它适用于微秒。

我能否就下面的代码片段请求一些帮助......以及一旦我从纪元获得纳秒 - 我如何回到上面的时间戳。

std::string ts("23 01 2020 20:59:59.123456789");

XXXX (ts);

void XXXXX (string timestamp)
{
     stringstream temp_ss(timestamp);

     tm temp_time_object = {};

     temp_ss >> get_time (&temp_time_object, "%Y/%m/%d %H:%M:%S");

     chrono::system_clock::time_point temp_time_point = system_clock::from_time_t(mktime(&temp_time_object));
    // chrono::high_resolution_clock::time_point temp_time_point1 = temp_time_point;

    auto  nsecs           =  stol (timestamp.substr (timestamp.find_first_of('.')+1,9));

// +++ This is where I GET stuck forming the time_point....
// I've tried this so many different ways .... 
// Is it that the system_clock cannot accept nanos? 


    temp_time_point += nanoseconds (nsecs);

     auto micro_from_epoch = duration_cast<nanoseconds> (temp_time_point.time_since_epoch()).count();

     cout << micro_from_epoch << endl;

}

Answer 1

我在创建时间点时遇到问题 - 以及如何表示纳秒......它适用于微秒。

这告诉我你的system_clock::time_point 的精度比纳秒还粗（在 llvm 上是微秒，在 Windows 上是 1/10 微秒）。将纳秒添加到这样的time_point 的最简单方法是：

auto tp = temp_time_point + nanoseconds (nsecs);

这形成了一个time_point，它仍然基于system_clock，但具有system_clock::duration 和nanoseconds 的“通用类型”的精度，实际上，它只是nanoseconds。

假设所有时间戳都是 GMT、UTC + 0

现在的问题是 mktime 从 local tm 转换为 UTC time_t。但是您想从 UTC 字段类型转换为 UTC 序列类型。

这在 C++20 中很容易实现（我知道你还没有，听我说）：

#include <chrono>
#include <iostream>
#include <sstream>

std::chrono::sys_time<std::chrono::nanoseconds>
XXXXX(std::string const& timestamp)
{
    using namespace std;
    using namespace std::chrono;
    istringstream temp_ss{timestamp};
    sys_time<nanoseconds> tp;
    temp_ss >> parse("%F %T", tp);
    return tp;
}

int
main()
{
    auto tp = XXXXX("2018-10-01 00:06:16.700000000");
    std::cout << tp.time_since_epoch().count() << "ns\n";
    std::string s = std::format("{:%F %T}", tp);
    std::cout << s << '\n';
}

这会将string 转换为chrono::time_point<system_clock, nanoseconds>，这与您的system_clock::time_point 明显不同，只是您的system_clock::time_point 的精度比nanoseconds 更粗。

然后format 用于将time_point 转换回string。

输出：

1538352376700000000ns
2018-10-01 00:06:16.700000000

现在我知道，如今完全符合 C++20 <chrono> 的东西很少见（即将推出）。在它到达这里之前，有一个 C++20 <chrono> preview library 与 C++11 兼容。它是免费和开源的。并且只需要很少的句法更改：

#include "date/date.h"
#include <chrono>
#include <iostream>
#include <sstream>

date::sys_time<std::chrono::nanoseconds>
XXXXX(std::string const& timestamp)
{
    using namespace date;
    using namespace std;
    using namespace std::chrono;
    istringstream temp_ss{timestamp};
    sys_time<nanoseconds> tp;
    temp_ss >> parse("%F %T", tp);
    return tp;
}

int
main()
{
    using namespace date;
    auto tp = XXXXX("2018-10-01 00:06:16.700000000");
    std::cout << tp.time_since_epoch().count() << "ns\n";
    std::string s = format("%F %T", tp);
    std::cout << s << '\n';
}

输出：

1538352376700000000ns
2018-10-01 00:06:16.700000000

Answer 2

您可以将文本直接转换为纳秒级分辨率。基本上有两个关键库：

• CCTZ 由一些 Google 工程师提供，但（与许多项目一样）不是正式发布的 Google 产品

• date，作者是 Howard Hinnant，他可能会在我完成打字之前在这里回答；他的库是 C++20 中此内容的基础

我已经为 R（通过 Rcpp）包装了这两个文件，并且有很多例子。但是这两个 repos 中也有示例，所以也许从那里开始？

因此，由于缺乏更好的直接 CCTZ 示例，这里是使用 R 包的示例；你会看到输入：

R> library(RcppCCTZ)
R> example(parseDatetime)

prsDttR> ds <- getOption("digits.secs")

prsDttR> options(digits.secs=6) # max value

prsDttR> parseDatetime("2016-12-07 10:11:12",        "%Y-%m-%d %H:%M:%S")   # full seconds
[1] "2016-12-07 10:11:12 UTC"

prsDttR> parseDatetime("2016-12-07 10:11:12.123456", "%Y-%m-%d %H:%M:%E*S") # fractional seconds
[1] "2016-12-07 10:11:12.123456 UTC"

prsDttR> parseDatetime("2016-12-07T10:11:12.123456-00:00")  ## default RFC3339 format
[1] "2016-12-07 10:11:12.123456 UTC"

prsDttR> now <- trunc(Sys.time())

prsDttR> parseDatetime(formatDatetime(now + 0:4))               # vectorised
[1] "2020-05-01 02:16:27 UTC" "2020-05-01 02:16:28 UTC"
[3] "2020-05-01 02:16:29 UTC" "2020-05-01 02:16:30 UTC"
[5] "2020-05-01 02:16:31 UTC"

prsDttR> options(digits.secs=ds)
R> 

调用的解析器函数是（并忽略与 R 相关的位）

Rcpp::DatetimeVector parseDatetime(Rcpp::CharacterVector svec,
                                   std::string fmt = "%Y-%m-%dT%H:%M:%E*S%Ez",
                                   std::string tzstr = "UTC") {
    cctz::time_zone tz;
    load_time_zone(tzstr, &tz);
    sc::system_clock::time_point tp;
    cctz::time_point<cctz::sys_seconds> unix_epoch =
        sc::time_point_cast<cctz::sys_seconds>(sc::system_clock::from_time_t(0));

    // if we wanted a 'start' timer
    //sc::system_clock::time_point start = sc::high_resolution_clock::now();

    auto n = svec.size();
    Rcpp::DatetimeVector dv(n, tzstr.c_str());
    for (auto i=0; i<n; i++) {
        std::string txt(svec(i));

        if (!cctz::parse(fmt, txt, tz, &tp)) Rcpp::stop("Parse error on %s", txt);

        // time since epoch, with fractional seconds added back in
        // only microseconds guaranteed to be present
        double dt = sc::duration_cast<sc::microseconds>(tp - unix_epoch).count() * 1.0e-6;

        // Rcpp::Rcout << "tp: " << cctz::format(fmt, tp, tz) << "\n"
        //             << "unix epoch: " << cctz::format(fmt, unix_epoch, tz) << "\n"
        //             << "(tp - unix.epoch).count(): " << (tp - unix_epoch).count() << "\n"
        //             << "dt: " << dt << std::endl;

        dv(i) = Rcpp::Datetime(dt);
    }

    return dv;
}

它查看传入的字符串向量svec 并转换每个字符串。

编辑：这是另一个使用我们的 nanotime 包的示例，它利用并使用了 CCTZ 解析器：

R> library(nanotime)
R> as.nanotime("2020-01-29 13:12:00.000000001 America/New_York")
[1] 2020-01-29T18:12:00.000000001+00:00
R> 

完整的 9 + 9 位精度，使用自纪元以来的底层纳秒，可与 std::chrono 完全互操作。