sq_detailed_metrics 0.1.0

data/include/xxhash.h

@@ -0,0 +1,328 @@
+/*
+   xxHash - Extremely Fast Hash algorithm
+   Header File
+   Copyright (C) 2012-2016, Yann Collet.
+
+   BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+
+       * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+       * Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following disclaimer
+   in the documentation and/or other materials provided with the
+   distribution.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+   You can contact the author at :
+   - xxHash source repository : https://github.com/Cyan4973/xxHash
+*/
+
+/* Notice extracted from xxHash homepage :
+
+xxHash is an extremely fast Hash algorithm, running at RAM speed limits.
+It also successfully passes all tests from the SMHasher suite.
+
+Comparison (single thread, Windows Seven 32 bits, using SMHasher on a Core 2 Duo @3GHz)
+
+Name            Speed       Q.Score   Author
+xxHash          5.4 GB/s     10
+CrapWow         3.2 GB/s      2       Andrew
+MumurHash 3a    2.7 GB/s     10       Austin Appleby
+SpookyHash      2.0 GB/s     10       Bob Jenkins
+SBox            1.4 GB/s      9       Bret Mulvey
+Lookup3         1.2 GB/s      9       Bob Jenkins
+SuperFastHash   1.2 GB/s      1       Paul Hsieh
+CityHash64      1.05 GB/s    10       Pike & Alakuijala
+FNV             0.55 GB/s     5       Fowler, Noll, Vo
+CRC32           0.43 GB/s     9
+MD5-32          0.33 GB/s    10       Ronald L. Rivest
+SHA1-32         0.28 GB/s    10
+
+Q.Score is a measure of quality of the hash function.
+It depends on successfully passing SMHasher test set.
+10 is a perfect score.
+
+A 64-bit version, named XXH64, is available since r35.
+It offers much better speed, but for 64-bit applications only.
+Name     Speed on 64 bits    Speed on 32 bits
+XXH64       13.8 GB/s            1.9 GB/s
+XXH32        6.8 GB/s            6.0 GB/s
+*/
+
+#ifndef XXHASH_H_5627135585666179
+#define XXHASH_H_5627135585666179 1
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+/* ****************************
+*  Definitions
+******************************/
+#include <stddef.h>   /* size_t */
+typedef enum { XXH_OK=0, XXH_ERROR } XXH_errorcode;
+
+
+/* ****************************
+ *  API modifier
+ ******************************/
+/** XXH_INLINE_ALL (and XXH_PRIVATE_API)
+ *  This is useful to include xxhash functions in `static` mode
+ *  in order to inline them, and remove their symbol from the public list.
+ *  Inlining can offer dramatic performance improvement on small keys.
+ *  Methodology :
+ *     #define XXH_INLINE_ALL
+ *     #include "xxhash.h"
+ * `xxhash.c` is automatically included.
+ *  It's not useful to compile and link it as a separate module.
+ */
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  ifndef XXH_STATIC_LINKING_ONLY
+#    define XXH_STATIC_LINKING_ONLY
+#  endif
+#  if defined(__GNUC__)
+#    define XXH_PUBLIC_API static __inline __attribute__((unused))
+#  elif defined (__cplusplus) || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */)
+#    define XXH_PUBLIC_API static inline
+#  elif defined(_MSC_VER)
+#    define XXH_PUBLIC_API static __inline
+#  else
+     /* this version may generate warnings for unused static functions */
+#    define XXH_PUBLIC_API static
+#  endif
+#else
+#  define XXH_PUBLIC_API   /* do nothing */
+#endif /* XXH_INLINE_ALL || XXH_PRIVATE_API */
+
+/*! XXH_NAMESPACE, aka Namespace Emulation :
+ *
+ * If you want to include _and expose_ xxHash functions from within your own library,
+ * but also want to avoid symbol collisions with other libraries which may also include xxHash,
+ *
+ * you can use XXH_NAMESPACE, to automatically prefix any public symbol from xxhash library
+ * with the value of XXH_NAMESPACE (therefore, avoid NULL and numeric values).
+ *
+ * Note that no change is required within the calling program as long as it includes `xxhash.h` :
+ * regular symbol name will be automatically translated by this header.
+ */
+#ifdef XXH_NAMESPACE
+#  define XXH_CAT(A,B) A##B
+#  define XXH_NAME2(A,B) XXH_CAT(A,B)
+#  define XXH_versionNumber XXH_NAME2(XXH_NAMESPACE, XXH_versionNumber)
+#  define XXH32 XXH_NAME2(XXH_NAMESPACE, XXH32)
+#  define XXH32_createState XXH_NAME2(XXH_NAMESPACE, XXH32_createState)
+#  define XXH32_freeState XXH_NAME2(XXH_NAMESPACE, XXH32_freeState)
+#  define XXH32_reset XXH_NAME2(XXH_NAMESPACE, XXH32_reset)
+#  define XXH32_update XXH_NAME2(XXH_NAMESPACE, XXH32_update)
+#  define XXH32_digest XXH_NAME2(XXH_NAMESPACE, XXH32_digest)
+#  define XXH32_copyState XXH_NAME2(XXH_NAMESPACE, XXH32_copyState)
+#  define XXH32_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH32_canonicalFromHash)
+#  define XXH32_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH32_hashFromCanonical)
+#  define XXH64 XXH_NAME2(XXH_NAMESPACE, XXH64)
+#  define XXH64_createState XXH_NAME2(XXH_NAMESPACE, XXH64_createState)
+#  define XXH64_freeState XXH_NAME2(XXH_NAMESPACE, XXH64_freeState)
+#  define XXH64_reset XXH_NAME2(XXH_NAMESPACE, XXH64_reset)
+#  define XXH64_update XXH_NAME2(XXH_NAMESPACE, XXH64_update)
+#  define XXH64_digest XXH_NAME2(XXH_NAMESPACE, XXH64_digest)
+#  define XXH64_copyState XXH_NAME2(XXH_NAMESPACE, XXH64_copyState)
+#  define XXH64_canonicalFromHash XXH_NAME2(XXH_NAMESPACE, XXH64_canonicalFromHash)
+#  define XXH64_hashFromCanonical XXH_NAME2(XXH_NAMESPACE, XXH64_hashFromCanonical)
+#endif
+
+
+/* *************************************
+*  Version
+***************************************/
+#define XXH_VERSION_MAJOR    0
+#define XXH_VERSION_MINOR    6
+#define XXH_VERSION_RELEASE  5
+#define XXH_VERSION_NUMBER  (XXH_VERSION_MAJOR *100*100 + XXH_VERSION_MINOR *100 + XXH_VERSION_RELEASE)
+XXH_PUBLIC_API unsigned XXH_versionNumber (void);
+
+
+/*-**********************************************************************
+*  32-bit hash
+************************************************************************/
+typedef unsigned int XXH32_hash_t;
+
+/*! XXH32() :
+    Calculate the 32-bit hash of sequence "length" bytes stored at memory address "input".
+    The memory between input & input+length must be valid (allocated and read-accessible).
+    "seed" can be used to alter the result predictably.
+    Speed on Core 2 Duo @ 3 GHz (single thread, SMHasher benchmark) : 5.4 GB/s */
+XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, unsigned int seed);
+
+/*======   Streaming   ======*/
+typedef struct XXH32_state_s XXH32_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH32_state_t* XXH32_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH32_freeState(XXH32_state_t* statePtr);
+XXH_PUBLIC_API void XXH32_copyState(XXH32_state_t* dst_state, const XXH32_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH32_reset  (XXH32_state_t* statePtr, unsigned int seed);
+XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH32_hash_t  XXH32_digest (const XXH32_state_t* statePtr);
+
+/*
+ * Streaming functions generate the xxHash of an input provided in multiple segments.
+ * Note that, for small input, they are slower than single-call functions, due to state management.
+ * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
+ *
+ * XXH state must first be allocated, using XXH*_createState() .
+ *
+ * Start a new hash by initializing state with a seed, using XXH*_reset().
+ *
+ * Then, feed the hash state by calling XXH*_update() as many times as necessary.
+ * The function returns an error code, with 0 meaning OK, and any other value meaning there is an error.
+ *
+ * Finally, a hash value can be produced anytime, by using XXH*_digest().
+ * This function returns the nn-bits hash as an int or long long.
+ *
+ * It's still possible to continue inserting input into the hash state after a digest,
+ * and generate some new hashes later on, by calling again XXH*_digest().
+ *
+ * When done, free XXH state space if it was allocated dynamically.
+ */
+
+/*======   Canonical representation   ======*/
+
+typedef struct { unsigned char digest[4]; } XXH32_canonical_t;
+XXH_PUBLIC_API void XXH32_canonicalFromHash(XXH32_canonical_t* dst, XXH32_hash_t hash);
+XXH_PUBLIC_API XXH32_hash_t XXH32_hashFromCanonical(const XXH32_canonical_t* src);
+
+/* Default result type for XXH functions are primitive unsigned 32 and 64 bits.
+ * The canonical representation uses human-readable write convention, aka big-endian (large digits first).
+ * These functions allow transformation of hash result into and from its canonical format.
+ * This way, hash values can be written into a file / memory, and remain comparable on different systems and programs.
+ */
+
+
+#ifndef XXH_NO_LONG_LONG
+/*-**********************************************************************
+*  64-bit hash
+************************************************************************/
+typedef unsigned long long XXH64_hash_t;
+
+/*! XXH64() :
+    Calculate the 64-bit hash of sequence of length "len" stored at memory address "input".
+    "seed" can be used to alter the result predictably.
+    This function runs faster on 64-bit systems, but slower on 32-bit systems (see benchmark).
+*/
+XXH_PUBLIC_API XXH64_hash_t XXH64 (const void* input, size_t length, unsigned long long seed);
+
+/*======   Streaming   ======*/
+typedef struct XXH64_state_s XXH64_state_t;   /* incomplete type */
+XXH_PUBLIC_API XXH64_state_t* XXH64_createState(void);
+XXH_PUBLIC_API XXH_errorcode  XXH64_freeState(XXH64_state_t* statePtr);
+XXH_PUBLIC_API void XXH64_copyState(XXH64_state_t* dst_state, const XXH64_state_t* src_state);
+
+XXH_PUBLIC_API XXH_errorcode XXH64_reset  (XXH64_state_t* statePtr, unsigned long long seed);
+XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* statePtr, const void* input, size_t length);
+XXH_PUBLIC_API XXH64_hash_t  XXH64_digest (const XXH64_state_t* statePtr);
+
+/*======   Canonical representation   ======*/
+typedef struct { unsigned char digest[8]; } XXH64_canonical_t;
+XXH_PUBLIC_API void XXH64_canonicalFromHash(XXH64_canonical_t* dst, XXH64_hash_t hash);
+XXH_PUBLIC_API XXH64_hash_t XXH64_hashFromCanonical(const XXH64_canonical_t* src);
+#endif  /* XXH_NO_LONG_LONG */
+
+
+
+#ifdef XXH_STATIC_LINKING_ONLY
+
+/* ================================================================================================
+   This section contains declarations which are not guaranteed to remain stable.
+   They may change in future versions, becoming incompatible with a different version of the library.
+   These declarations should only be used with static linking.
+   Never use them in association with dynamic linking !
+=================================================================================================== */
+
+/* These definitions are only present to allow
+ * static allocation of XXH state, on stack or in a struct for example.
+ * Never **ever** use members directly. */
+
+#if !defined (__VMS) \
+  && (defined (__cplusplus) \
+  || (defined (__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) /* C99 */) )
+#   include <stdint.h>
+
+struct XXH32_state_s {
+   uint32_t total_len_32;
+   uint32_t large_len;
+   uint32_t v1;
+   uint32_t v2;
+   uint32_t v3;
+   uint32_t v4;
+   uint32_t mem32[4];
+   uint32_t memsize;
+   uint32_t reserved;   /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH32_state_t */
+
+struct XXH64_state_s {
+   uint64_t total_len;
+   uint64_t v1;
+   uint64_t v2;
+   uint64_t v3;
+   uint64_t v4;
+   uint64_t mem64[4];
+   uint32_t memsize;
+   uint32_t reserved[2];          /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH64_state_t */
+
+# else
+
+struct XXH32_state_s {
+   unsigned total_len_32;
+   unsigned large_len;
+   unsigned v1;
+   unsigned v2;
+   unsigned v3;
+   unsigned v4;
+   unsigned mem32[4];
+   unsigned memsize;
+   unsigned reserved;   /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH32_state_t */
+
+#   ifndef XXH_NO_LONG_LONG  /* remove 64-bit support */
+struct XXH64_state_s {
+   unsigned long long total_len;
+   unsigned long long v1;
+   unsigned long long v2;
+   unsigned long long v3;
+   unsigned long long v4;
+   unsigned long long mem64[4];
+   unsigned memsize;
+   unsigned reserved[2];     /* never read nor write, might be removed in a future version */
+};   /* typedef'd to XXH64_state_t */
+#    endif
+
+# endif
+
+
+#if defined(XXH_INLINE_ALL) || defined(XXH_PRIVATE_API)
+#  include "xxhash.c"   /* include xxhash function bodies as `static`, for inlining */
+#endif
+
+#endif /* XXH_STATIC_LINKING_ONLY */
+
+
+#if defined (__cplusplus)
+}
+#endif
+
+#endif /* XXHASH_H_5627135585666179 */

data/json_conv.cpp

@@ -0,0 +1,284 @@
+#include "json_conv.hpp"
+#include <msgpack.h>
+#include <map>
+#include <vector>
+#include <memory>
+#include <sstream>
+#include <iomanip>
+#define RAPIDJSON_NO_SIZETYPEDEFINE 1
+namespace rapidjson { typedef std::size_t SizeType; }
+#include <rapidjson/writer.h>
+#include <rapidjson/ostreamwrapper.h>
+#include "metrics.hpp"
+
+namespace sq_detailed_metrics
+{
+using namespace half_float::literal;
+
+class UnexpectedData : public std::exception {
+    std::string what_v;
+
+public:
+    UnexpectedData(std::string what_) : what_v(what_) {}
+    virtual ~UnexpectedData() = default;
+    virtual const char *what() const noexcept;
+};
+const char *UnexpectedData::what() const noexcept {
+    return what_v.c_str();
+}
+
+struct ReadRequest {
+    std::string route;
+    index_t overtime_cb_idx;
+    std::vector<meas_entry_t> measurements;
+};
+
+class Unpacker {
+    using unpacker_ptr = std::unique_ptr<msgpack_unpacker, decltype(&msgpack_unpacker_free)>;
+    unpacker_ptr unp{msgpack_unpacker_new(1024), msgpack_unpacker_free};
+
+    msgpack_unpacked unpacked{};
+
+    const msgpack_object_array& root_array() {
+        if (unpacked.data.type != MSGPACK_OBJECT_ARRAY) {
+            throw UnexpectedData("Expected array at root, got type " +
+                                 std::to_string(unpacked.data.type));
+        }
+        msgpack_object_array& obj = unpacked.data.via.array;
+        if (obj.size != 2) {
+            throw UnexpectedData("Expected root array to have size 2");
+        }
+
+        return obj;
+    }
+
+public:
+
+    static void print_hex(const char *s, size_t size)
+    {
+        for (size_t i = 0; i < size; i++)
+            std::cout << std::hex << std::setfill('0') << std::setw(2) <<
+                         std::uppercase << (int)(unsigned char)s[i];
+    }
+
+    Unpacker(const char *src, size_t size) {
+        print_hex(src, size);
+        bool result = msgpack_unpacker_reserve_buffer(unp.get(), size);
+        if (!result) {
+            throw std::bad_alloc{};
+        }
+
+        std::memcpy(msgpack_unpacker_buffer(unp.get()), src, size);
+        msgpack_unpacker_buffer_consumed(unp.get(), size);
+    }
+
+    ~Unpacker() {
+        msgpack_unpacked_destroy(&unpacked);
+    }
+
+    bool unpack() {
+        if (unpacked.zone) {
+            return false;
+        }
+
+        msgpack_unpacked_init(&unpacked);
+        msgpack_unpack_return ret = msgpack_unpacker_next(unp.get(), &unpacked);
+
+        return ret == MSGPACK_UNPACK_SUCCESS;
+    }
+
+    std::map<index_t, std::string> meas_types() {
+        std::map<index_t, std::string> ret;
+
+        auto& route_array = root_array();
+
+        if (route_array.ptr[0].type != MSGPACK_OBJECT_MAP) {
+            throw UnexpectedData("Expected first element of root array "
+                                 "to be a map");
+        }
+        msgpack_object_map& map = route_array.ptr[0].via.map;
+
+        for (uint32_t i = 0; i < map.size; i++) {
+            auto& key = map.ptr[i].key;
+            auto& val = map.ptr[i].val;
+
+            if (key.type != MSGPACK_OBJECT_POSITIVE_INTEGER) {
+                throw UnexpectedData("Expected keys of map first element "
+                                     "of root array to be positive numbers");
+            }
+            if (val.type != MSGPACK_OBJECT_STR) {
+                throw UnexpectedData("Expected values of map first element "
+                                     "of root array to be strings");
+            }
+
+            ret[static_cast<index_t>(key.via.u64)] =
+                std::string{val.via.str.ptr, val.via.str.size};
+        }
+
+        return ret;
+    }
+
+    std::vector<ReadRequest> requests() {
+        std::vector<ReadRequest> ret;
+
+        auto& route_array = root_array();
+
+        if (route_array.ptr[1].type != MSGPACK_OBJECT_ARRAY) {
+            throw UnexpectedData("Expected second element of root array "
+                                 "to be an array, the type is instead " +
+                                 std::to_string(route_array.ptr[1].type));
+        }
+        msgpack_object_array& reqs = route_array.ptr[1].via.array;
+        ret.resize(reqs.size);
+
+        for (uint32_t i = 0; i < reqs.size; i++) {
+            msgpack_object& obj = reqs.ptr[i];
+
+            if (obj.type != MSGPACK_OBJECT_ARRAY ||
+                    obj.via.array.size != 3) {
+                std::string msg = "Expected root > #2 > #" + std::to_string(i)
+                        + " to be an array of size 3";
+                throw UnexpectedData(msg);
+            }
+
+            msgpack_object_array& arr = obj.via.array;
+            to_req(ret[i], i, ret, arr.ptr[0], arr.ptr[1], arr.ptr[2]);
+        }
+
+        return ret;
+    }
+
+    static void to_req(ReadRequest& req,
+                       uint32_t req_num,
+                       const std::vector<ReadRequest>& prev_reqs,
+                       msgpack_object& route,
+                       msgpack_object& overtime_cb_object,
+                       msgpack_object& measurements) {
+        if (overtime_cb_object.type != MSGPACK_OBJECT_POSITIVE_INTEGER) {
+            throw UnexpectedData("Request " + std::to_string(req_num) +
+                                 " has no positive number on #2");
+        }
+        if (measurements.type != MSGPACK_OBJECT_BIN) {
+            throw UnexpectedData("Request " + std::to_string(req_num) +
+                                 " has no binary data on #3");
+        }
+
+        if (route.type == MSGPACK_OBJECT_STR) {
+            req.route = {route.via.str.ptr, route.via.str.size};
+        } else if (route.type == MSGPACK_OBJECT_POSITIVE_INTEGER) {
+            req_index_t i = static_cast<req_index_t>(route.via.u64);
+            if (i >= prev_reqs.size()) {
+                throw UnexpectedData("Request " + std::to_string(req_num) +
+                                     " points to req " + std::to_string(req_num) +
+                                     ", which is ahead");
+            }
+            const ReadRequest& prev_r = prev_reqs[i];
+            req.route = prev_r.route;
+        } else {
+            throw UnexpectedData("Request " + std::to_string(req_num) +
+                                 " has no string or positive integer on #1");
+        }
+
+        req.overtime_cb_idx = static_cast<index_t>(overtime_cb_object.via.u64);
+
+        msgpack_object_bin& bin = measurements.via.bin;
+        if (bin.size % 3 != 0) {
+            throw UnexpectedData("Request " + std::to_string(req_num) +
+                                 " has binary data on #3 with size "
+                                 "not a multiple of 3");
+        }
+        uint32_t num_meas = bin.size / 3;
+        req.measurements.resize(num_meas);
+        for (uint32_t i = 0; i < num_meas; i++) {
+            const unsigned char *p = reinterpret_cast<const unsigned char*>(
+                        &bin.ptr[i *3]);
+            half_float::half half;
+            std::memcpy(&half, p + 1, sizeof(half));
+            req.measurements[i] = {
+                *reinterpret_cast<const index_t*>(p),
+                half
+            };
+        }
+    }
+};
+
+class WriterConv : public rapidjson::Writer<rapidjson::OStreamWrapper> {
+public:
+    WriterConv(rapidjson::OStreamWrapper &wrapper) :
+        rapidjson::Writer<rapidjson::OStreamWrapper>(wrapper) {
+    }
+
+    bool StdString(const std::string& str) {
+        return String(&str[0], str.size());
+    }
+
+    bool HalfFloat(const half_float::half half) {
+        std::stringstream ss;
+        ss << std::setprecision(4) << float{half};
+        auto str = ss.str();
+        Prefix(rapidjson::kNumberType);
+        return EndValue(WriteRawValue(&str[0], str.size()));
+    }
+};
+
+void JsonConv::parse(const char *src, size_t size) {
+    std::map<index_t, std::string> meas_types;
+    std::vector<ReadRequest> requests;
+
+    {
+        Unpacker unpacker{src, size};
+        if (!unpacker.unpack()) {
+            throw UnexpectedData{"Error unpacking"};
+        }
+        meas_types = unpacker.meas_types();
+        meas_types[max_index_t] = "other";
+        requests = unpacker.requests();
+    }
+
+    rapidjson::OStreamWrapper osw{os};
+    WriterConv writer(osw);
+
+    writer.StartArray();
+    for (ReadRequest& r: requests) {
+        writer.StartObject();
+        if (r.route.size() > 0) {
+            writer.Key("route");
+            writer.StdString(r.route);
+        }
+        if (r.overtime_cb_idx != undef_index_t) {
+            writer.Key("overtime_cb");
+            writer.StdString(meas_types[r.overtime_cb_idx]);
+        }
+        writer.Key("measurements");
+        writer.StartArray();
+        for (const meas_entry_t& e: r.measurements) {
+            writer.StartArray();
+
+            writer.StdString(meas_types[e.first]);
+
+            half_float::half f = e.second * 8.0_h;
+
+            bool conditions_passed = false;
+            // doesn't work on older compilers
+//            if (std::signbit(f)) { // negative
+            if ((*reinterpret_cast<uint16_t*>(&f) & 0x8000U) == 0x8000U) {
+                conditions_passed = true;
+                f *= -1.0_h;
+            }
+            if (!std::isinf(f)) {
+                writer.HalfFloat(f);
+            } else {
+                static float max_val =
+                        std::numeric_limits<half_float::half>::max() * 8.0f;
+                writer.Double(static_cast<double>(max_val));
+            }
+            writer.Bool(conditions_passed);
+
+            writer.EndArray();
+        }
+        writer.EndArray();
+        writer.EndObject();
+    }
+    writer.EndArray();
+}
+}