sq_detailed_metrics 0.1.0

data/json_conv.hpp

@@ -0,0 +1,17 @@
+#ifndef JSON_CONV_HPP
+#define JSON_CONV_HPP
+
+#include <iostream>
+
+namespace sq_detailed_metrics
+{
+class JsonConv {
+    std::ostream& os;
+public:
+    JsonConv(std::ostream& os_) : os(os_) {}
+
+    void parse(const char *src, size_t size);
+};
+}
+
+#endif // JSON_CONV_HPP

data/metrics.cpp

@@ -0,0 +1,239 @@
+#include "metrics.hpp"
+#include <msgpack.h>
+#define LZ4LIB_VISIBILITY
+
+namespace sq_detailed_metrics {
+
+struct MsgpackPacker
+{
+    MsgpackPacker() {
+        msgpack_packer_init(&packer, &output, &MsgpackPacker::std_string_write);
+    }
+
+    void start_map(size_t num_keys) {
+        msgpack_pack_map(&packer, num_keys);
+    }
+
+    void start_array(size_t num_elements) {
+        msgpack_pack_array(&packer, num_elements);
+    }
+
+    void start_bin(size_t size) {
+        msgpack_pack_bin(&packer, size);
+    }
+
+    void add_bin_portion(const char *data, size_t size) {
+        msgpack_pack_bin_body(&packer, data, size);
+    }
+
+    MsgpackPacker& operator<<(const std::string& str) {
+        const char *c_str = str.c_str();
+        msgpack_pack_str_with_body(&packer, c_str, str.size());
+        return *this;
+    }
+
+    MsgpackPacker& operator<<(index_t value) {
+        msgpack_pack_uint8(&packer, value);
+        return *this;
+    }
+
+    MsgpackPacker& operator<<(uint16_t value) {
+        msgpack_pack_uint16(&packer, value);
+        return *this;
+    }
+
+    MsgpackPacker& operator<<(half_float::half& value) {
+        msgpack_pack_fix_uint16(&packer, *reinterpret_cast<uint16_t *>(&value));
+        return *this;
+    }
+
+    std::string move_output() {
+        return std::move(output);
+    }
+
+    MsgpackPacker(const MsgpackPacker&) = delete;
+    MsgpackPacker& operator=(const MsgpackPacker&) = delete;
+private:
+    // must be of type msgpack_packer_write
+    static int std_string_write(void* data, const char* buf, size_t len) {
+        std::string *str = static_cast<std::string*>(data);
+        try {
+            str->append(buf, len);
+        } catch (std::bad_alloc&) {
+            return -1;
+        }
+        return 0;
+    }
+
+    std::string output;
+    msgpack_packer packer;
+};
+
+struct MetricsIndex {
+    index_t index_of(const std::string& meas_type) {
+        lock_guard lock_guard(m);
+
+        index_t& t = meas_type_index[meas_type];
+        if (t == undef_index_t) {
+            t = next;
+            if (next < max_index_t) {
+                next++;
+            }
+        }
+        return t;
+    }
+
+    void serialize(MsgpackPacker& packer, const index_t_set& used_meas) {
+        lock_guard lock_guard(m);
+
+        // indexes 0 (undefined) and 255 (others) are not sent
+        packer.start_map(used_meas.count() -
+                         (used_meas[undef_index_t] ? 1 : 0) -
+                         (used_meas[max_index_t] ? 1 : 0));
+
+        std::for_each(meas_type_index.begin(), meas_type_index.end(),
+                      [&packer, &used_meas](std::pair<std::string, index_t> entry) {
+            index_t i = entry.second;
+            if (i == max_index_t || i == undef_index_t || !used_meas[i]) {
+                return;
+            }
+            packer << i << entry.first; // index, string
+        });
+    }
+
+    MetricsIndex() {}
+    ~MetricsIndex() = default;
+    MetricsIndex(const MetricsIndex&) = delete;
+    MetricsIndex& operator= (const MetricsIndex&) = delete;
+
+private:
+    std::map<std::string, index_t> meas_type_index;
+    index_t next = 1;
+    std::mutex m;
+};
+
+
+void Request::set_overtime_cb(const std::string& cb) {
+    if (cb.size() != 0) {
+        overtime_cb = metrics_index->index_of(cb);
+    } else {
+        overtime_cb = undef_index_t;
+    }
+}
+
+void Request::add(const std::string& meas_type, double value) {
+    index_t t = metrics_index->index_of(meas_type);
+    // the max half float is only 65504. Since we're storing
+    // ms, this is about 65 s. While this is a large quantity,
+    // larger ones have been seen in practice. Extend this range
+    // to almost 9 minutes by diving by 8. The minumum (normal)
+    // value becomes about 0.5 us, which is still good enough
+    float fval = static_cast<float>(value) / 8.0f;
+    half_float::half val{fval};
+
+    measurements.push_back(meas_entry_t{t, val});
+}
+
+void Request::mark_used_meas_types(index_t_set& bitset) const {
+    bitset[this->overtime_cb] = true;
+    for (const meas_entry_t& m: measurements) {
+        index_t i = m.first;
+        bitset[i] = true;
+    }
+}
+
+void Request::serialize(MsgpackPacker& packer,
+                        req_index_t idx,
+                        std::map<std::string, req_index_t>& prev_routes) const {
+    packer.start_array(3);
+
+    auto route_prev_idx_it = prev_routes.find(route);
+    if (route_prev_idx_it == prev_routes.end()) {
+        packer << route;
+        prev_routes[route] = idx;
+    } else {
+        req_index_t prev_idx = route_prev_idx_it->second;
+        packer << prev_idx;
+    }
+
+    packer << overtime_cb;
+
+    // encode as binary to encode pairs in 3 bytes
+    packer.start_bin(measurements.size() *
+                     (sizeof(index_t) + sizeof(half_float::half)));
+    std::for_each(measurements.begin(), measurements.end(),
+                  [&packer](meas_entry_t entry) {
+        packer.add_bin_portion(
+                    reinterpret_cast<const char *>(&entry.first),
+                    sizeof(index_t));
+        packer.add_bin_portion(
+                    reinterpret_cast<const char *>(&entry.second),
+                    sizeof(half_float::half));
+    });
+}
+
+size_t Request::mem_size() const {
+    return sizeof(Request) + route.length() +
+            sizeof(meas_entry_t) * this->measurements.size();
+}
+
+void RequestCollection::operator<<(Request request) {
+    lock_guard lock_guard{m};
+
+    if (completed_requests.size() == max_req_per_coll) {
+        return;
+    }
+
+    completed_requests.push_back(std::move(request));
+}
+
+bool RequestCollection::flush(std::string& out) {
+    std::list<Request> requests;
+    {
+        lock_guard lock_guard{m};
+        std::swap(requests, completed_requests);
+    }
+
+    if (requests.size() == 0) {
+        return false;
+    }
+
+    MsgpackPacker packer;
+
+    packer.start_array(2);
+    index_t_set meas_types_used;
+    for (const Request& req: requests) {
+        req.mark_used_meas_types(meas_types_used);
+    }
+    metrics_index->serialize(packer, meas_types_used);
+
+    packer.start_array(requests.size());
+    {
+        std::map<std::string, req_index_t> seen_routes;
+        req_index_t i = 0;
+        for (const Request &r: requests) {
+            r.serialize(packer, i, seen_routes);
+            i++;
+        }
+    }
+
+    out = packer.move_output(); // should select move assignment
+
+    return true;
+}
+
+size_t RequestCollection::mem_size() const {
+    size_t size = sizeof(RequestCollection);
+    for (const Request& req: completed_requests) {
+        size += req.mem_size();
+    }
+    return size;
+}
+
+MetricsIndex *MetricsIndex_create() {
+    return new MetricsIndex();
+}
+void MetricsIndex_free(MetricsIndex *idx) {
+    delete idx;
+}
+}

data/metrics.hpp

@@ -0,0 +1,84 @@
+#ifndef METRICS_HPP
+#define METRICS_HPP
+
+#include <memory>
+#include <map>
+#include <set>
+#include <string>
+#include <list>
+#include <mutex>
+#include <bitset>
+#include <half.hpp>
+#include <limits>
+
+#include <memory>
+namespace sq_detailed_metrics
+{
+struct MetricsIndex;
+MetricsIndex *MetricsIndex_create();
+void MetricsIndex_free(MetricsIndex *idx);
+
+extern MetricsIndex *metrics_index;
+
+using index_t = uint8_t;
+constexpr index_t max_index_t = std::numeric_limits<index_t>::max();
+constexpr index_t undef_index_t = 0; // must be 0
+using index_t_set = std::bitset<max_index_t - 0 /* min */ + 1>;
+using lock_guard = std::lock_guard<std::mutex>;
+typedef std::pair<index_t, half_float::half> meas_entry_t;
+
+using req_index_t = uint16_t;
+constexpr auto max_req_per_coll = std::numeric_limits<req_index_t>::max();
+
+struct MsgpackPacker;
+
+// XXX: we require here that Request objects be modified only
+// in one thread and that this be the thread that submits them to
+// the request collection. This holds for Ruby, but may not hold
+// e.g. for Java.
+struct Request {
+public:
+    void add(const std::string& meas_type, double value);
+    void set_route(std::string route_arg) {
+        this->route = std::move(route_arg);
+    }
+    void set_overtime_cb(const std::string& cb);
+
+    void mark_used_meas_types(index_t_set& set) const;
+
+    /*
+     * ["route"/<prev req index>, "overtime callback", b"<metric index 1><measurement 1>..."]]
+     */
+    void serialize(MsgpackPacker& packer,
+                   req_index_t idx,
+                   std::map<std::string, req_index_t>& prev_routes) const;
+
+    size_t mem_size() const;
+
+    Request() = default;
+    Request(const Request&) = delete;
+    Request(Request&&) = default;
+    Request& operator=(const Request&) = delete;
+
+private:
+    std::string route;
+    index_t overtime_cb = undef_index_t;
+    std::list<meas_entry_t> measurements;
+};
+
+class RequestCollection {
+public:
+    void operator<<(Request request);
+    bool flush(std::string& out);
+    size_t mem_size() const;
+
+    RequestCollection() = default;
+    RequestCollection(const RequestCollection&) = delete;
+    RequestCollection& operator=(const RequestCollection&) = delete;
+private:
+    std::mutex m;
+    std::list<Request> completed_requests;
+};
+}
+
+#endif // METRICS_HPP

data/msgpack/objectc.c

@@ -0,0 +1,482 @@
+/*
+ * MessagePack for C dynamic typing routine
+ *
+ * Copyright (C) 2008-2009 FURUHASHI Sadayuki
+ *
+ *    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)
+ */
+#if defined(_KERNEL_MODE)
+#  undef  _NO_CRT_STDIO_INLINE
+#  define _NO_CRT_STDIO_INLINE
+#endif
+
+#include "msgpack/object.h"
+#include "msgpack/pack.h"
+#include <ctype.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#if defined(_MSC_VER)
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+#define PRIu64 "I64u"
+#define PRIi64 "I64i"
+#define PRIi8 "i"
+#endif
+#else
+#include <inttypes.h>
+#endif
+
+#if defined(_KERNEL_MODE)
+#  undef  snprintf
+#  define snprintf _snprintf
+#endif
+
+int msgpack_pack_object(msgpack_packer* pk, msgpack_object d)
+{
+    switch(d.type) {
+    case MSGPACK_OBJECT_NIL:
+        return msgpack_pack_nil(pk);
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        if(d.via.boolean) {
+            return msgpack_pack_true(pk);
+        } else {
+            return msgpack_pack_false(pk);
+        }
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+        return msgpack_pack_uint64(pk, d.via.u64);
+
+    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+        return msgpack_pack_int64(pk, d.via.i64);
+
+    case MSGPACK_OBJECT_FLOAT32:
+        return msgpack_pack_float(pk, (float)d.via.f64);
+
+    case MSGPACK_OBJECT_FLOAT64:
+        return msgpack_pack_double(pk, d.via.f64);
+
+    case MSGPACK_OBJECT_STR:
+        {
+            int ret = msgpack_pack_str(pk, d.via.str.size);
+            if(ret < 0) { return ret; }
+            return msgpack_pack_str_body(pk, d.via.str.ptr, d.via.str.size);
+        }
+
+    case MSGPACK_OBJECT_BIN:
+        {
+            int ret = msgpack_pack_bin(pk, d.via.bin.size);
+            if(ret < 0) { return ret; }
+            return msgpack_pack_bin_body(pk, d.via.bin.ptr, d.via.bin.size);
+        }
+
+    case MSGPACK_OBJECT_EXT:
+        {
+            int ret = msgpack_pack_ext(pk, d.via.ext.size, d.via.ext.type);
+            if(ret < 0) { return ret; }
+            return msgpack_pack_ext_body(pk, d.via.ext.ptr, d.via.ext.size);
+        }
+
+    case MSGPACK_OBJECT_ARRAY:
+        {
+            int ret = msgpack_pack_array(pk, d.via.array.size);
+            if(ret < 0) {
+                return ret;
+            }
+            else {
+                msgpack_object* o = d.via.array.ptr;
+                msgpack_object* const oend = d.via.array.ptr + d.via.array.size;
+                for(; o != oend; ++o) {
+                    ret = msgpack_pack_object(pk, *o);
+                    if(ret < 0) { return ret; }
+                }
+
+                return 0;
+            }
+        }
+
+    case MSGPACK_OBJECT_MAP:
+        {
+            int ret = msgpack_pack_map(pk, d.via.map.size);
+            if(ret < 0) {
+                return ret;
+            }
+            else {
+                msgpack_object_kv* kv = d.via.map.ptr;
+                msgpack_object_kv* const kvend = d.via.map.ptr + d.via.map.size;
+                for(; kv != kvend; ++kv) {
+                    ret = msgpack_pack_object(pk, kv->key);
+                    if(ret < 0) { return ret; }
+                    ret = msgpack_pack_object(pk, kv->val);
+                    if(ret < 0) { return ret; }
+                }
+
+                return 0;
+            }
+        }
+
+    default:
+        return -1;
+    }
+}
+
+#if !defined(_KERNEL_MODE)
+
+static void msgpack_object_bin_print(FILE* out, const char *ptr, size_t size)
+{
+    size_t i;
+    for (i = 0; i < size; ++i) {
+        if (ptr[i] == '"') {
+            fputs("\\\"", out);
+        } else if (isprint((unsigned char)ptr[i])) {
+            fputc(ptr[i], out);
+        } else {
+            fprintf(out, "\\x%02x", (unsigned char)ptr[i]);
+        }
+    }
+}
+
+void msgpack_object_print(FILE* out, msgpack_object o)
+{
+    switch(o.type) {
+    case MSGPACK_OBJECT_NIL:
+        fprintf(out, "nil");
+        break;
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        fprintf(out, (o.via.boolean ? "true" : "false"));
+        break;
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+#if defined(PRIu64)
+        fprintf(out, "%" PRIu64, o.via.u64);
+#else
+        if (o.via.u64 > ULONG_MAX)
+            fprintf(out, "over 4294967295");
+        else
+            fprintf(out, "%lu", (unsigned long)o.via.u64);
+#endif
+        break;
+
+    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+#if defined(PRIi64)
+        fprintf(out, "%" PRIi64, o.via.i64);
+#else
+        if (o.via.i64 > LONG_MAX)
+            fprintf(out, "over +2147483647");
+        else if (o.via.i64 < LONG_MIN)
+            fprintf(out, "under -2147483648");
+        else
+            fprintf(out, "%ld", (signed long)o.via.i64);
+#endif
+        break;
+
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
+        fprintf(out, "%f", o.via.f64);
+        break;
+
+    case MSGPACK_OBJECT_STR:
+        fprintf(out, "\"");
+        fwrite(o.via.str.ptr, o.via.str.size, 1, out);
+        fprintf(out, "\"");
+        break;
+
+    case MSGPACK_OBJECT_BIN:
+        fprintf(out, "\"");
+        msgpack_object_bin_print(out, o.via.bin.ptr, o.via.bin.size);
+        fprintf(out, "\"");
+        break;
+
+    case MSGPACK_OBJECT_EXT:
+#if defined(PRIi8)
+        fprintf(out, "(ext: %" PRIi8 ")", o.via.ext.type);
+#else
+        fprintf(out, "(ext: %d)", (int)o.via.ext.type);
+#endif
+        fprintf(out, "\"");
+        msgpack_object_bin_print(out, o.via.ext.ptr, o.via.ext.size);
+        fprintf(out, "\"");
+        break;
+
+    case MSGPACK_OBJECT_ARRAY:
+        fprintf(out, "[");
+        if(o.via.array.size != 0) {
+            msgpack_object* p = o.via.array.ptr;
+            msgpack_object* const pend = o.via.array.ptr + o.via.array.size;
+            msgpack_object_print(out, *p);
+            ++p;
+            for(; p < pend; ++p) {
+                fprintf(out, ", ");
+                msgpack_object_print(out, *p);
+            }
+        }
+        fprintf(out, "]");
+        break;
+
+    case MSGPACK_OBJECT_MAP:
+        fprintf(out, "{");
+        if(o.via.map.size != 0) {
+            msgpack_object_kv* p = o.via.map.ptr;
+            msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size;
+            msgpack_object_print(out, p->key);
+            fprintf(out, "=>");
+            msgpack_object_print(out, p->val);
+            ++p;
+            for(; p < pend; ++p) {
+                fprintf(out, ", ");
+                msgpack_object_print(out, p->key);
+                fprintf(out, "=>");
+                msgpack_object_print(out, p->val);
+            }
+        }
+        fprintf(out, "}");
+        break;
+
+    default:
+        // FIXME
+#if defined(PRIu64)
+        fprintf(out, "#<UNKNOWN %i %" PRIu64 ">", o.type, o.via.u64);
+#else
+        if (o.via.u64 > ULONG_MAX)
+            fprintf(out, "#<UNKNOWN %i over 4294967295>", o.type);
+        else
+            fprintf(out, "#<UNKNOWN %i %lu>", o.type, (unsigned long)o.via.u64);
+#endif
+
+    }
+}
+
+#endif
+
+#define MSGPACK_CHECKED_CALL(ret, func, aux_buffer, aux_buffer_size, ...) \
+    ret = func(aux_buffer, aux_buffer_size, __VA_ARGS__);                 \
+    if (ret <= 0 || ret >= (int)aux_buffer_size) return 0;                \
+    aux_buffer = aux_buffer + ret;                                        \
+    aux_buffer_size = aux_buffer_size - ret                               \
+
+static int msgpack_object_bin_print_buffer(char *buffer, size_t buffer_size, const char *ptr, size_t size)
+{
+    size_t i;
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = buffer_size;
+    int ret;
+
+    for (i = 0; i < size; ++i) {
+        if (ptr[i] == '"') {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\\"");
+        } else if (isprint((unsigned char)ptr[i])) {
+            if (aux_buffer_size > 0) {
+                memcpy(aux_buffer, ptr + i, 1);
+                aux_buffer = aux_buffer + 1;
+                aux_buffer_size = aux_buffer_size - 1;
+            }
+        } else {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\\x%02x", (unsigned char)ptr[i]);
+        }
+    }
+
+    return (int)(buffer_size - aux_buffer_size);
+}
+
+int msgpack_object_print_buffer(char *buffer, size_t buffer_size, msgpack_object o)
+{
+    char *aux_buffer = buffer;
+    size_t aux_buffer_size = buffer_size;
+    int ret;
+    switch(o.type) {
+    case MSGPACK_OBJECT_NIL:
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "nil");
+        break;
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, (o.via.boolean ? "true" : "false"));
+        break;
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+#if defined(PRIu64)
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIu64, o.via.u64);
+#else
+        if (o.via.u64 > ULONG_MAX) {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over 4294967295");
+        } else {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%lu", (unsigned long)o.via.u64);
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+#if defined(PRIi64)
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%" PRIi64, o.via.i64);
+#else
+        if (o.via.i64 > LONG_MAX) {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "over +2147483647");
+        } else if (o.via.i64 < LONG_MIN) {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "under -2147483648");
+        } else {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%ld", (signed long)o.via.i64);
+        }
+#endif
+        break;
+
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%f", o.via.f64);
+        break;
+
+    case MSGPACK_OBJECT_STR:
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "%.*s", (int)o.via.str.size, o.via.str.ptr);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        break;
+
+    case MSGPACK_OBJECT_BIN:
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.bin.ptr, o.via.bin.size);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        break;
+
+    case MSGPACK_OBJECT_EXT:
+#if defined(PRIi8)
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %" PRIi8 ")", o.via.ext.type);
+#else
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "(ext: %d)", (int)o.via.ext.type);
+#endif
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        MSGPACK_CHECKED_CALL(ret, msgpack_object_bin_print_buffer, aux_buffer, aux_buffer_size, o.via.ext.ptr, o.via.ext.size);
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "\"");
+        break;
+
+    case MSGPACK_OBJECT_ARRAY:
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "[");
+        if(o.via.array.size != 0) {
+            msgpack_object* p = o.via.array.ptr;
+            msgpack_object* const pend = o.via.array.ptr + o.via.array.size;
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p);
+            ++p;
+            for(; p < pend; ++p) {
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", ");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, *p);
+            }
+        }
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "]");
+        break;
+
+    case MSGPACK_OBJECT_MAP:
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "{");
+        if(o.via.map.size != 0) {
+            msgpack_object_kv* p = o.via.map.ptr;
+            msgpack_object_kv* const pend = o.via.map.ptr + o.via.map.size;
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key);
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>");
+            MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val);
+            ++p;
+            for(; p < pend; ++p) {
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, ", ");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->key);
+                MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "=>");
+                MSGPACK_CHECKED_CALL(ret, msgpack_object_print_buffer, aux_buffer, aux_buffer_size, p->val);
+            }
+        }
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "}");
+        break;
+
+    default:
+    // FIXME
+#if defined(PRIu64)
+        MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i %" PRIu64 ">", o.type, o.via.u64);
+#else
+        if (o.via.u64 > ULONG_MAX) {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i over 4294967295>", o.type);
+        } else {
+            MSGPACK_CHECKED_CALL(ret, snprintf, aux_buffer, aux_buffer_size, "#<UNKNOWN %i %lu>", o.type, (unsigned long)o.via.u64);
+        }
+#endif
+    }
+
+    return (int)(buffer_size - aux_buffer_size);
+}
+
+#undef MSGPACK_CHECKED_CALL
+
+bool msgpack_object_equal(const msgpack_object x, const msgpack_object y)
+{
+    if(x.type != y.type) { return false; }
+
+    switch(x.type) {
+    case MSGPACK_OBJECT_NIL:
+        return true;
+
+    case MSGPACK_OBJECT_BOOLEAN:
+        return x.via.boolean == y.via.boolean;
+
+    case MSGPACK_OBJECT_POSITIVE_INTEGER:
+        return x.via.u64 == y.via.u64;
+
+    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
+        return x.via.i64 == y.via.i64;
+
+    case MSGPACK_OBJECT_FLOAT32:
+    case MSGPACK_OBJECT_FLOAT64:
+        return x.via.f64 == y.via.f64;
+
+    case MSGPACK_OBJECT_STR:
+        return x.via.str.size == y.via.str.size &&
+            memcmp(x.via.str.ptr, y.via.str.ptr, x.via.str.size) == 0;
+
+    case MSGPACK_OBJECT_BIN:
+        return x.via.bin.size == y.via.bin.size &&
+            memcmp(x.via.bin.ptr, y.via.bin.ptr, x.via.bin.size) == 0;
+
+    case MSGPACK_OBJECT_EXT:
+        return x.via.ext.size == y.via.ext.size &&
+            x.via.ext.type == y.via.ext.type &&
+            memcmp(x.via.ext.ptr, y.via.ext.ptr, x.via.ext.size) == 0;
+
+    case MSGPACK_OBJECT_ARRAY:
+        if(x.via.array.size != y.via.array.size) {
+            return false;
+        } else if(x.via.array.size == 0) {
+            return true;
+        } else {
+            msgpack_object* px = x.via.array.ptr;
+            msgpack_object* const pxend = x.via.array.ptr + x.via.array.size;
+            msgpack_object* py = y.via.array.ptr;
+            do {
+                if(!msgpack_object_equal(*px, *py)) {
+                    return false;
+                }
+                ++px;
+                ++py;
+            } while(px < pxend);
+            return true;
+        }
+
+    case MSGPACK_OBJECT_MAP:
+        if(x.via.map.size != y.via.map.size) {
+            return false;
+        } else if(x.via.map.size == 0) {
+            return true;
+        } else {
+            msgpack_object_kv* px = x.via.map.ptr;
+            msgpack_object_kv* const pxend = x.via.map.ptr + x.via.map.size;
+            msgpack_object_kv* py = y.via.map.ptr;
+            do {
+                if(!msgpack_object_equal(px->key, py->key) || !msgpack_object_equal(px->val, py->val)) {
+                    return false;
+                }
+                ++px;
+                ++py;
+            } while(px < pxend);
+            return true;
+        }
+
+    default:
+        return false;
+    }
+}