Add support for std::chrono::steady_clock and high_resolution_clock

[LuisAyuso]

It seems that only std::chrono::system_clock is implemented.
Is there any reason why the other clocks have no implementation?

[redboltz]

There is no special reason. So we can add them.
Adding std::chrono::steady_clock is easy.
However, I noticed that high_resolution_clock has alias problem.

See https://wandbox.org/permlink/csWEsHFF3XKDnX2Q

https://en.cppreference.com/w/cpp/chrono/high_resolution_clock

Class std::chrono::high_resolution_clock represents the clock with the smallest tick period provided by the implementation. It may be an alias of std::chrono::system_clock or std::chrono::steady_clock, or a third, independent clock.

I think that some hack is required to implement high_resolution_clock specialization.

[LuisAyuso]

In my platform steady_clock and high_resolution_clock are aliases (x64 linux). I believe that only one implementation is in that case necessary.
I do not know if any other platform implements a difference between the clocks, but maybe it could be detected using enable_if or other tooling.

I would like to help here, I will prepare a PR.

[redboltz]

I asked at https://stackoverflow.com/questions/62344047/how-to-write-stdchronohigh-resolution-clock-class-template-specialization-on and got answer.
Then I applied to msgpack-c. See #887 .

[redboltz]

Is steady_clock an alias ?
I think that steady_clock should have strong type (shouldn't be alias).
There is no alias description https://en.cppreference.com/w/cpp/chrono/steady_clock

[redboltz]

Do you mean steady_clock and high_resolution_clock have the same type on your environment ?
If it does, no problem. According to the document, in this case, high_resolution_clock is an alias of steady_clock.

[redboltz]

Implemented by #877

[LuisAyuso]

Hi again,
I think this issue may have been closed by mistake, I can not see any std::chrono related changes in #877

First of all, I would like to say that you are right, there is no type alias.

I worked out some changes in chrono.hpp header that allows for all the clocks to work:

• use template <typename clock_t> instead of template <>
• use std::chrono::time_point<clock_t>
• use std::chrono::time_point<clock_t>::duration

My change compiles correctly, I even wrote an example that uses the 3 clocks on a single structure. Nevertheless, I found an issue:
Clock resolution: I am a little concerned that serialization may lose resolution because of the duration cast to nanoseconds. I guess it is a good practice that serialization preserves data resolution, in this case, it could be a good idea not to serialize these structures using the same proxy data type, but I presume this is done to allow cross-language serialization.
What is the priority here? maybe only clocks with nanoseconds resolution should be serialized.
Maybe it makes sense, after all, not to serialize all clocks.

Test code:

namespace chrono = std::chrono;

struct my {

    chrono::system_clock::time_point t1;
    chrono::steady_clock::time_point t2;
    chrono::high_resolution_clock::time_point t3;

    MSGPACK_DEFINE(t1,t2,t3);
};


int main() {
    my m1{chrono::system_clock::now() ,
          chrono::steady_clock::now() , 
          chrono::high_resolution_clock::now() };
    msgpack::zone z;
    msgpack::object obj(m1, z);

    std::cout << obj << std::endl;
    assert(m1.t1 == obj.as<my>().t1);
    assert(m1.t2 == obj.as<my>().t2);
    assert(m1.t3 == obj.as<my>().t3);
}

Change:

//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2017 KONDO Takatoshi
//
//    Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//    http://www.boost.org/LICENSE_1_0.txt)
//

#ifndef MSGPACK_V1_TYPE_CPP11_CHRONO_HPP
#define MSGPACK_V1_TYPE_CPP11_CHRONO_HPP

#include "msgpack/versioning.hpp"
#include "msgpack/adaptor/adaptor_base.hpp"
#include "msgpack/adaptor/check_container_size.hpp"

#include <chrono>

namespace msgpack {

/// @cond
MSGPACK_API_VERSION_NAMESPACE(v1) {
/// @endcond

namespace adaptor {

template <typename clock_t>
struct as<std::chrono::time_point<clock_t>> {
    typename std::chrono::time_point<clock_t> operator()(msgpack::object const& o) const {
        using duration_t = typename std::chrono::time_point<clock_t>::duration;
        if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
        if(o.via.ext.type() != -1) { throw msgpack::type_error(); }
        std::chrono::time_point<clock_t> tp;
        switch(o.via.ext.size) {
        case 4: {
            uint32_t sec;
            _msgpack_load32(uint32_t, o.via.ext.data(), &sec);
            tp += std::chrono::seconds(sec);
        } break;
        case 8: {
            uint64_t value;
            _msgpack_load64(uint64_t, o.via.ext.data(), &value);
            uint32_t nanosec = static_cast<uint32_t>(value >> 34);
            uint64_t sec = value & 0x00000003ffffffffLL;
            tp += std::chrono::duration_cast<duration_t>(
                std::chrono::nanoseconds(nanosec));
            tp += std::chrono::seconds(sec);
        } break;
        case 12: {
            uint32_t nanosec;
            _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec);
            int64_t sec;
            _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec);
            tp += std::chrono::duration_cast<duration_t>(
                std::chrono::nanoseconds(nanosec));
            tp += std::chrono::seconds(sec);
        } break;
        default:
            throw msgpack::type_error();
        }
        return tp;
    }
};

template <typename clock_t>
struct convert<std::chrono::time_point<clock_t>> {
    msgpack::object const& operator()(msgpack::object const& o, std::chrono::system_clock::time_point& v) const {
        using duration_t = typename std::chrono::time_point<clock_t>::duration;
        if(o.type != msgpack::type::EXT) { throw msgpack::type_error(); }
        if(o.via.ext.type() != -1) { throw msgpack::type_error(); }
        std::chrono::time_point<clock_t> tp;
        switch(o.via.ext.size) {
        case 4: {
            uint32_t sec;
            _msgpack_load32(uint32_t, o.via.ext.data(), &sec);
            tp += std::chrono::seconds(sec);
            v = tp;
        } break;
        case 8: {
            uint64_t value;
            _msgpack_load64(uint64_t, o.via.ext.data(), &value);
            uint32_t nanosec = static_cast<uint32_t>(value >> 34);
            uint64_t sec = value & 0x00000003ffffffffLL;
            tp += std::chrono::duration_cast<duration_t>(
                std::chrono::nanoseconds(nanosec));
            tp += std::chrono::seconds(sec);
            v = tp;
        } break;
        case 12: {
            uint32_t nanosec;
            _msgpack_load32(uint32_t, o.via.ext.data(), &nanosec);
            int64_t sec;
            _msgpack_load64(int64_t, o.via.ext.data() + 4, &sec);
            tp += std::chrono::duration_cast<duration_t>(
                std::chrono::nanoseconds(nanosec));
            tp += std::chrono::seconds(sec);
            v = tp;
        } break;
        default:
            throw msgpack::type_error();
        }
        return o;
    }
};

template <typename clock_t>
struct pack<std::chrono::time_point<clock_t>> {
    template <typename Stream>
    msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::system_clock::time_point& v) const {
        using duration_t = typename std::chrono::time_point<clock_t>::duration;
        int64_t count = static_cast<int64_t>(v.time_since_epoch().count());

        int64_t nano_num =
            duration_t::period::ratio::num *
            (1000000000 / duration_t::period::ratio::den);

        int64_t nanosec = count % (1000000000 / nano_num) * nano_num;
        int64_t sec = 0;
        if (nanosec < 0) {
            nanosec = 1000000000 + nanosec;
            --sec;
        }
        sec += count
            * duration_t::period::ratio::num
            / duration_t::period::ratio::den;
        if ((sec >> 34) == 0) {
            uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
            if ((data64 & 0xffffffff00000000L) == 0) {
                // timestamp 32
                o.pack_ext(4, -1);
                uint32_t data32 = static_cast<uint32_t>(data64);
                char buf[4];
                _msgpack_store32(buf, data32);
                o.pack_ext_body(buf, 4);
            }
            else {
                // timestamp 64
                o.pack_ext(8, -1);
                char buf[8];
                _msgpack_store64(buf, data64);
                o.pack_ext_body(buf, 8);
            }
        }
        else {
            // timestamp 96
            o.pack_ext(12, -1);
            char buf[12];
            _msgpack_store32(&buf[0], static_cast<uint32_t>(nanosec));
            _msgpack_store64(&buf[4], sec);
            o.pack_ext_body(buf, 12);
        }
        return o;
    }
};

template <typename clock_t>
struct object_with_zone<std::chrono::time_point<clock_t>> {
    void operator()(msgpack::object::with_zone& o, const std::chrono::time_point<clock_t>& v) const {
        using duration_t = typename std::chrono::time_point<clock_t>::duration;
        int64_t count = static_cast<int64_t>(v.time_since_epoch().count());

        int64_t nano_num =
            duration_t::period::ratio::num *
            (1000000000 / duration_t::period::ratio::den);

        int64_t nanosec = count % (1000000000 / nano_num) * nano_num;
        int64_t sec = 0;
        if (nanosec < 0) {
            nanosec = 1000000000 + nanosec;
            --sec;
        }
        sec += count
            * duration_t::period::ratio::num
            / duration_t::period::ratio::den;
        if ((sec >> 34) == 0) {
            uint64_t data64 = (static_cast<uint64_t>(nanosec) << 34) | static_cast<uint64_t>(sec);
            if ((data64 & 0xffffffff00000000L) == 0) {
                // timestamp 32
                o.type = msgpack::type::EXT;
                o.via.ext.size = 4;
                char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
                p[0] = static_cast<char>(-1);
                uint32_t data32 = static_cast<uint32_t>(data64);
                _msgpack_store32(&p[1], data32);
                o.via.ext.ptr = p;
            }
            else {
                // timestamp 64
                o.type = msgpack::type::EXT;
                o.via.ext.size = 8;
                char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
                p[0] = static_cast<char>(-1);
                _msgpack_store64(&p[1], data64);
                o.via.ext.ptr = p;
            }
        }
        else {
            // timestamp 96
            o.type = msgpack::type::EXT;
            o.via.ext.size = 12;
            char* p = static_cast<char*>(o.zone.allocate_no_align(o.via.ext.size + 1));
            p[0] = static_cast<char>(-1);
            _msgpack_store32(&p[1], static_cast<uint32_t>(nanosec));
            _msgpack_store64(&p[1 + 4], sec);
            o.via.ext.ptr = p;
        }
    }
};

} // namespace adaptor

/// @cond
} // MSGPACK_API_VERSION_NAMESPACE(v1)
/// @endcond

} // namespace msgpack

#endif // MSGPACK_V1_TYPE_CPP11_CHRONO_HPP

[redboltz]

I think this issue may have been closed by mistake, I can not see any std::chrono related changes in #877

Sorry it's typo. #887 is right.

I've already merge it.

I will take a look your approach and issue later.

[redboltz]

I've checked your approach.

Your approach is more elegant than I implemented and merged.
So I will update the code based on your approach.

It seems that your approach is incomplete. system_clock is remained.

msgpack::packer<Stream>& operator()(msgpack::packer<Stream>& o, const std::chrono::system_clock::time_point& v) const {

I will fix them.

Clock resolution: I am a little concerned that serialization may lose resolution because of the duration cast to nanoseconds. I guess it is a good practice that serialization preserves data resolution, in this case, it could be a good idea not to serialize these structures using the same proxy data type, but I presume this is done to allow cross-language serialization.
What is the priority here? maybe only clocks with nanoseconds resolution should be serialized.
Maybe it makes sense, after all, not to serialize all clocks.

I think that msgpack-c is a kind of coverter.
It packs C++ types to MessagePack formatted bytes and vice versa.
The target MessagePack type is https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type

I think that your approach is good converting way for default conversion.
If user want to specific convert depends on the specific clock, user can write their own converter.

[redboltz]

See #888

[LuisAyuso]

fantastic, thanks for such a fast response!
cheers!