Format

src/include/migraphx/functional.hpp

@@ -98,6 +98,9 @@ constexpr auto sequence_c_impl(F&& f, seq<Ns...>)
     return f(std::integral_constant<std::size_t, Ns>{}...);
 }
 
+template<class... Ts>
+struct overloaded : Ts... { using Ts::operator()...; };
+
 } // namespace detail
 
 template <std::size_t N, class F>
@@ -135,6 +138,12 @@ auto unpack(F f, T&& x)
     return sequence(tuple_size(x), [&](auto... is) { f(std::get<is>(static_cast<T&&>(x))...); });
 }
 
+template<class... Ts>
+detail::overloaded<Ts...> overload(Ts... xs)
+{
+    return {xs...};
+}
+
 /// Implements a fix-point combinator
 template <class R, class F>
 detail::fix_f<R, F> fix(F f)

src/msgpack.cpp

@@ -24,6 +24,43 @@
 #include <migraphx/msgpack.hpp>
 #include <migraphx/serialize.hpp>
 #include <msgpack.hpp>
+#include <variant>
+
+namespace migraphx {
+inline namespace MIGRAPHX_INLINE_NS {
+
+struct msgpack_chunk
+{
+    std::vector<value> chunks;
+
+    value as_value() const
+    {
+        if(chunks.empty())
+            return {};
+        const value& v = chunks.front();
+        if(v.is_array() or v.is_object())
+        {
+            std::vector<value> values = v.is_array() ? v.get_array() : v.get_object();
+            std::for_each(chunks.begin()+1, chunks.end(), [&](const auto& chunk) {
+                values.insert(values.end(), chunk.begin(), chunk.end());
+            });
+            return values;
+        }
+        else if(v.is_binary())
+        {
+            value::binary data = v.get_binary();
+            std::for_each(chunks.begin()+1, chunks.end(), [&](const auto& chunk) {
+                const value::binary& b = chunk.get_binary();
+                data.insert(data.end(), b.begin(), b.end());
+            });
+            return data;
+        }
+        MIGRAPHX_THROW("Incorrect chunking");
+    }
+};
+
+} // namespace MIGRAPHX_INLINE_NS
+} // namespace migraphx
 
 namespace msgpack {
 MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
@@ -62,27 +99,55 @@ MSGPACK_API_VERSION_NAMESPACE(MSGPACK_DEFAULT_API_NS)
                 v = o.as<std::string>();
                 break;
             }
-            case msgpack::type::BIN: {
-                v = migraphx::value::binary{o.via.bin.ptr, o.via.bin.size};
-                break;
-            }
             case msgpack::type::ARRAY: {
-                migraphx::value r = migraphx::value::array{};
+                if(o.via.array.size == 0)
+                {
+                    v = migraphx::value::array{};
+                    break;
+                }
+                std::variant<migraphx::value::array, migraphx::value::binary, migraphx::value::object> r;
+                switch (o.via.array.ptr->type) {
+                    case msgpack::type::BIN: {
+                        r = migraphx::value::binary{};
+                        break;
+                    }
+                    case msgpack::type::ARRAY: {
+                        r = migraphx::value::array{};
+                        break;
+                    }
+                    case msgpack::type::MAP: {
+                        r = migraphx::value::object{};
+                        break;
+                    }
+                    default:
+                        MIGRAPHX_THROW("Incorrect chunking");
+                    }
+                }
                 std::for_each(
                     o.via.array.ptr,
                     o.via.array.ptr + o.via.array.size,
-                    [&](const msgpack::object& so) { r.push_back(so.as<migraphx::value>()); });
-                v = r;
-                break;
+                    [&](const msgpack::object& sa) { 
+                        std::visit(overload([&](migraphx::value::binary& bin) {
+                            bin.insert(bin.end(), o.via.bin.ptr, o.via.bin.ptr+o.via.bin.size);
+                        }, [&](migraphx::value::array& arr) {
+                            std::for_each(
+                                sa.via.array.ptr,
+                                sa.via.array.ptr + sa.via.array.size,
+                                [&](const msgpack::object& so) { arr.push_back(so.as<migraphx::value>()); });
+                        }, [&](migraphx::value::object& obj) {
+                            std::for_each(sa.via.map.ptr,
+                                          sa.via.map.ptr + sa.via.map.size,
+                                          [&](const msgpack::object_kv& p) {
+                                              obj[p.key.as<std::string>()] = p.val.as<migraphx::value>();
+                                          });
+                        }), r);
+                    });
+                    std::visit([&](const auto& x) { v = x; }, r);
+                    break;
             }
-            case msgpack::type::MAP: {
-                migraphx::value r = migraphx::value::object{};
-                std::for_each(o.via.map.ptr,
-                              o.via.map.ptr + o.via.map.size,
-                              [&](const msgpack::object_kv& p) {
-                                  r[p.key.as<std::string>()] = p.val.as<migraphx::value>();
-                              });
-                v = r;
+            case msgpack::type::MAP:
+            case msgpack::type::BIN: {
+                MIGRAPHX_THROW("Unexpected msgpack type");
                 break;
             }
             case msgpack::type::EXT: {