From 510e13675e73fd6312d1a276b95a6af3b4502d81 Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Sun, 24 Jan 2021 23:14:23 +0000
Subject: [PATCH 01/12] Enable subclass to access base members

---
 worker/include/manager_service.h | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/worker/include/manager_service.h b/worker/include/manager_service.h
index 35a3fa96..87ae77a1 100644
--- a/worker/include/manager_service.h
+++ b/worker/include/manager_service.h
@@ -27,7 +27,14 @@ class ManagerServiceServerBase {
   void HandleAccept(std::unique_ptr<boost::asio::ip::tcp::socket> socket,
       std::unique_ptr<boost::asio::ip::tcp::endpoint> endpoint);
 
+  boost::asio::io_service io_service_;
+  std::unique_ptr<boost::asio::ip::tcp::acceptor> acceptor_;
+  std::unique_ptr<boost::asio::ip::tcp::socket> socket_;
+  std::unique_ptr<boost::asio::ip::tcp::endpoint> endpoint_;
+
   virtual ava_proto::WorkerAssignReply HandleRequest(const ava_proto::WorkerAssignRequest& request);
+
+protected:
   virtual pid_t SpawnWorker(const std::vector<std::string>& environments,
       const std::vector<std::string>& parameters);
 
@@ -37,11 +44,6 @@ class ManagerServiceServerBase {
 
   std::atomic<uint32_t> worker_id_;
   std::map<pid_t, std::shared_ptr<std::thread>> worker_monitor_map_;
-
-  boost::asio::io_service io_service_;
-  std::unique_ptr<boost::asio::ip::tcp::acceptor> acceptor_;
-  std::unique_ptr<boost::asio::ip::tcp::socket> socket_;
-  std::unique_ptr<boost::asio::ip::tcp::endpoint> endpoint_;
 };
 
 }  // namespace ava_manager

From ce6863c75476b4492fcf181ed33ded880bc38296 Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Sun, 24 Jan 2021 23:15:31 +0000
Subject: [PATCH 02/12] Port from r1.0 TCP manager

---
 CMakeLists.txt               |  3 ++
 worker/CMakeLists.txt        |  4 ++
 worker/legacy/CMakeLists.txt | 24 +++++++++
 worker/legacy/manager.cpp    | 96 ++++++++++++++++++++++++++++++++++++
 4 files changed, 127 insertions(+)
 create mode 100644 worker/legacy/CMakeLists.txt
 create mode 100644 worker/legacy/manager.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b6be5279..1bd43d8e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -41,6 +41,7 @@ set(AVA_GEN_DEMO_SPEC OFF CACHE BOOL "Enable demo specification")
 
 set(AVA_MANAGER_GALVANIC OFF CACHE BOOL "Build Galvanic manager")
 set(AVA_MANAGER_KATANA OFF CACHE BOOL  "Build Katana manager")
+set(AVA_MANAGER_LEGACY OFF CACHE BOOL  "Build legacy (r1.0) manager")
 set(AVA_MANAGER_DEMO OFF CACHE BOOL  "Build demo manager")
 
 message(STATUS "Build TensorFlow CUDA specification:   ${AVA_GEN_TF_SPEC}")
@@ -58,6 +59,7 @@ message(STATUS "Build test (libtrivial) specification: ${AVA_GEN_TEST_SPEC}")
 message(STATUS "Build demo specification:              ${AVA_GEN_DEMO_SPEC}")
 message(STATUS "Build Galvanic manager:                ${AVA_MANAGER_GALVANIC}")
 message(STATUS "Build Katana manager:                  ${AVA_MANAGER_KATANA}")
+message(STATUS "Build legacy (r1.0) manager:           ${AVA_MANAGER_LEGACY}")
 message(STATUS "Build demo manager:                    ${AVA_MANAGER_DEMO}")
 
 set(AVA_INSTALL_DIR "${CMAKE_CURRENT_BINARY_DIR}/install" CACHE PATH "Installation path of AvA")
@@ -136,6 +138,7 @@ ExternalProject_Add(ava-manager
   CMAKE_CACHE_ARGS
         -DAVA_MANAGER_GALVANIC:BOOL=${AVA_MANAGER_GALVANIC}
         -DAVA_MANAGER_KATANA:BOOL=${AVA_MANAGER_KATANA}
+        -DAVA_MANAGER_LEGACY:BOOL=${AVA_MANAGER_LEGACY}
         -DAVA_MANAGER_DEMO:BOOL=${AVA_MANAGER_DEMO}
         -DCMAKE_TOOLCHAIN_FILE:STRING=${CMAKE_TOOLCHAIN_FILE}
         -DCMAKE_INSTALL_PREFIX:PATH=${AVA_INSTALL_DIR}
diff --git a/worker/CMakeLists.txt b/worker/CMakeLists.txt
index 96a62142..cff28676 100644
--- a/worker/CMakeLists.txt
+++ b/worker/CMakeLists.txt
@@ -32,6 +32,10 @@ if(AVA_MANAGER_KATANA)
   add_subdirectory(katana)
 endif()
 
+if(AVA_MANAGER_LEGACY)
+  add_subdirectory(legacy)
+endif()
+
 if(AVA_MANAGER_DEMO)
   add_subdirectory(demo)
 endif()
diff --git a/worker/legacy/CMakeLists.txt b/worker/legacy/CMakeLists.txt
new file mode 100644
index 00000000..24a91a21
--- /dev/null
+++ b/worker/legacy/CMakeLists.txt
@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.13)
+
+project(legacy-manager C CXX CUDA)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_compile_options(-Wall -Wextra -pedantic -Wno-write-strings -g)
+
+add_executable(legacy-manager
+  manager.cpp
+  ${manager_service_pb_srcs}
+  ${manager_service_ava_srcs}
+)
+target_link_libraries(legacy-manager
+  ${manager_service_libraries}
+)
+set_target_properties(legacy-manager
+  PROPERTIES OUTPUT_NAME manager
+)
+
+install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/manager
+  TYPE BIN
+  RENAME legacy_manager
+)
diff --git a/worker/legacy/manager.cpp b/worker/legacy/manager.cpp
new file mode 100644
index 00000000..1f41917d
--- /dev/null
+++ b/worker/legacy/manager.cpp
@@ -0,0 +1,96 @@
+#include <algorithm>
+#include <future>
+#include <iostream>
+#include <thread>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/lockfree/queue.hpp>
+#include <sys/wait.h>
+
+#include "manager_service.h"
+#include "manager_service.pb.h"
+
+using ava_manager::ManagerServiceServerBase;
+
+const uint32_t kDefaultManagerPort    = 3333;
+const uint32_t kDefaultWorkerPortBase = 4000;
+const bool kDefaultWorkerPoolEnabled  = true;
+const uint32_t kDefaultWorkerPoolSize = 3;
+
+class DemoManager : public ManagerServiceServerBase {
+public:
+  DemoManager(uint32_t port, uint32_t worker_port_base, std::string worker_path) :
+    ManagerServiceServerBase(port, worker_port_base, worker_path) {
+    // Spawn worker pool with default environment variables
+    if (kDefaultWorkerPoolEnabled) {
+      for (uint32_t i = 0; i < kDefaultWorkerPoolSize; i++) {
+        auto worker_address = SpawnWorkerWrapper();
+        worker_pool_.push(worker_address);
+      }
+    }
+  }
+
+private:
+  uint32_t SpawnWorkerWrapper() {
+    // Let API server use TCP channel
+    std::vector<std::string> environments;
+    environments.push_back("AVA_CHANNEL=TCP");
+
+    // Pass only port to API server
+    auto port = worker_port_base_ +
+      worker_id_.fetch_add(1, std::memory_order_relaxed);
+    std::vector<std::string> parameters;
+    parameters.push_back(std::to_string(port));
+
+    std::cerr << "Spawn API server at 0.0.0.0:" << port << "(cmdline=\\\\"
+              << boost::algorithm::join(environments, " ") << " " << worker_path_ << " "
+              << boost::algorithm::join(parameters, " ") << "\\\\)" << std::endl;
+
+    auto child_pid = SpawnWorker(environments, parameters);
+
+    auto child_monitor = std::make_shared<std::thread>(
+        [](pid_t child_pid,
+           uint32_t port,
+           std::map<pid_t, std::shared_ptr<std::thread>> *worker_monitor_map) {
+          pid_t ret = waitpid(child_pid, NULL, 0);
+          std::cerr << "[pid=" << child_pid << "] API server at ::" << port
+                    << " has exit (waitpid=" << ret << ")" << std::endl;
+          worker_monitor_map->erase(port);
+        },
+        child_pid, port, &worker_monitor_map_);
+    child_monitor->detach();
+    worker_monitor_map_.insert({port, child_monitor});
+
+    return port;
+  }
+
+  ava_proto::WorkerAssignReply HandleRequest(
+      const ava_proto::WorkerAssignRequest& request) {
+    ava_proto::WorkerAssignReply reply;
+    uint32_t worker_port;
+
+    if (worker_pool_.pop(worker_port)) {
+      worker_pool_.push(SpawnWorkerWrapper());
+    }
+    else {
+      worker_port = SpawnWorkerWrapper();
+    }
+    reply.add_worker_address("0.0.0.0:" + std::to_string(worker_port));
+
+    return reply;
+  }
+
+  boost::lockfree::queue<uint32_t, boost::lockfree::capacity<128>> worker_pool_;
+};
+
+int main(int argc, char* argv[]) {
+  if (argc <= 1) {
+    fprintf(stderr, "Usage: %s <worker_path>\n"
+           "Example: %s generated/cudadrv_nw/worker\n",
+           argv[0], argv[0]);
+    exit(0);
+  }
+  ava_manager::setupSignalHandlers();
+  DemoManager manager(kDefaultManagerPort, kDefaultWorkerPortBase, argv[1]);
+  manager.RunServer();
+  return 0;
+}

From 531444603463ea92ad4c2d84a6ce08c2c4a30994 Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 06:07:09 +0000
Subject: [PATCH 03/12] Fix protobuf dependency

---
 cava/nightwatch/generator/c/cmakelists.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/cava/nightwatch/generator/c/cmakelists.py b/cava/nightwatch/generator/c/cmakelists.py
index f6cd3638..782888d0 100644
--- a/cava/nightwatch/generator/c/cmakelists.py
+++ b/cava/nightwatch/generator/c/cmakelists.py
@@ -37,7 +37,8 @@ def source(api: API, errors):
 find_package(Boost REQUIRED COMPONENTS system)
 find_library(Config++ NAMES libconfig++ config++ REQUIRED)
 
-###### Set generated files ######
+set(protobuf_MODULE_COMPATIBLE TRUE)
+find_package(Protobuf REQUIRED QUIET)
 
 ###### Compile ######
 
@@ -95,12 +96,14 @@ def source(api: API, errors):
   ${{CMAKE_SOURCE_DIR}}/../../common/cmd_channel_socket_utilities.cpp
   ${{CMAKE_SOURCE_DIR}}/../../common/cmd_channel_socket_tcp.cpp
   ${{CMAKE_SOURCE_DIR}}/../../common/cmd_channel_socket_vsock.cpp
+  ${{CMAKE_BINARY_DIR}}/../../proto/manager_service.pb.cc
 )
 target_link_libraries(guestlib
   ${{GLIB2_LIBRARIES}}
   ${{Boost_LIBRARIES}}
   Threads::Threads
   ${{Config++}}
+  ${{Protobuf_LIBRARIES}}
 )
 target_compile_options(guestlib
   PUBLIC -fvisibility=hidden

From c33e8855a7a353805778c193b694040c177576db Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 06:07:38 +0000
Subject: [PATCH 04/12] Link to proper CUDA libraries

---
 cava/samples/tensorflow/CMakeLists.txt | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/cava/samples/tensorflow/CMakeLists.txt b/cava/samples/tensorflow/CMakeLists.txt
index ac6f15b7..9df81cb3 100644
--- a/cava/samples/tensorflow/CMakeLists.txt
+++ b/cava/samples/tensorflow/CMakeLists.txt
@@ -32,8 +32,12 @@ ExternalProject_Add_Step(cava tf_dump-link
           mkdir -p ${tf_dump_install}/lib &&
           ln -f -s ${CMAKE_CURRENT_SOURCE_DIR}/headers ${CMAKE_CURRENT_BINARY_DIR}/headers        &&
           ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcuda.so.1      &&
+          ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcuda.so        &&
           ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcublas.so.10   &&
           ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcublasLt.so.10 &&
+          ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcudart.so.10.0 &&
+          ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcudart.so.10.1 &&
+          ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcudart.so.10.2 &&
           ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcudart.so.10   &&
           ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcudnn.so.7     &&
           ln -f -s ${tf_dump_install}/lib/libguestlib.so ${tf_dump_install}/lib/libcufft.so.10    &&
@@ -75,11 +79,17 @@ ExternalProject_Add_Step(cava tf_opt-link
           mkdir -p ${tf_opt_install}/lib &&
           ln -f -s ${CMAKE_CURRENT_SOURCE_DIR}/headers ${CMAKE_CURRENT_BINARY_DIR}/headers      &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcuda.so.1      &&
+          ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcuda.so        &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcublas.so.10   &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcublasLt.so.10 &&
+          ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcudart.so.10.0 &&
+          ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcudart.so.10.1 &&
+          ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcudart.so.10.2 &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcudart.so.10   &&
+          ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcudart.so      &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcudnn.so.7     &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcufft.so.10    &&
+          ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcufft.so.10    &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcurand.so.10   &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcusolver.so.10 &&
           ln -f -s ${tf_opt_install}/lib/libguestlib.so ${tf_opt_install}/lib/libcusparse.so.10

From 9b71ab437dab49dcd599cddc50640accce2b484a Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 08:15:22 +0000
Subject: [PATCH 05/12] Import a serializer library

---
 include/import/serializer.h | 2297 +++++++++++++++++++++++++++++++++++
 1 file changed, 2297 insertions(+)
 create mode 100644 include/import/serializer.h

diff --git a/include/import/serializer.h b/include/import/serializer.h
new file mode 100644
index 00000000..9f4cb93c
--- /dev/null
+++ b/include/import/serializer.h
@@ -0,0 +1,2297 @@
+#ifndef __zpp_serializer_h__
+#define __zpp_serializer_h__
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <initializer_list>
+#include <memory>
+#include <mutex>
+#include <new>
+#include <shared_mutex>
+#include <stdexcept>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+#if __cplusplus >= 201703L
+#include <optional>
+#include <variant>
+#endif
+
+namespace zpp
+{
+/**
+ * Supports serialization of objects and polymorphic objects.
+ * Example of non polymorphic serialization:
+ * ~~~
+ * class point
+ * {
+ * public:
+ *     point() = default;
+ *     point(int x, int y) noexcept :
+ *           m_x(x),
+ *           m_y(y)
+ *       {
+ *       }
+ *
+ *     friend zpp::serializer::access;
+ *     template <typename Archive, typename Self>
+ *     static void serialize(Archive & archive, Self & self)
+ *     {
+ *         archive(self.m_x, self.m_y);
+ *     }
+ *
+ *     int get_x() const noexcept
+ *     {
+ *           return m_x;
+ *       }
+ *
+ *       int get_y() const noexcept
+ *       {
+ *           return m_y;
+ *       }
+ *
+ * private:
+ *     int m_x = 0;
+ *     int m_y = 0;
+ * };
+ *
+ * static void foo()
+ * {
+ *     std::vector<unsigned char> data;
+ *     zpp::serializer::memory_input_archive in(data);
+ *     zpp::serializer::memory_output_archive out(data);
+ *
+ *     out(point(1337, 1338));
+ *
+ *     point my_point;
+ *     in(my_point);
+ *
+ *     std::cout << my_point.get_x() << ' ' << my_point.get_y() << '\n';
+ * }
+ * ~~~
+ *
+ * Example of polymorphic serialization:
+ * ~~~
+ * class person : public zpp::serializer::polymorphic
+ * {
+ * public:
+ *     person() = default;
+ *     explicit person(std::string name) noexcept :
+ *           m_name(std::move(name))
+ *       {
+ *       }
+ *
+ *     friend zpp::serializer::access;
+ *     template <typename Archive, typename Self>
+ *     static void serialize(Archive & archive, Self & self)
+ *     {
+ *           archive(self.m_name);
+ *       }
+ *
+ *       const std::string & get_name() const noexcept
+ *       {
+ *           return m_name;
+ *       }
+ *
+ *     virtual void print() const
+ *     {
+ *         std::cout << "person: " << m_name;
+ *     }
+ *
+ * private:
+ *     std::string m_name;
+ * };
+ *
+ * class student : public person
+ * {
+ * public:
+ *     student() = default;
+ *     student(std::string name, std::string university) noexcept :
+ *         person(std::move(name)),
+ *         m_university(std::move(university))
+ *     {
+ *     }
+ *
+ *     friend zpp::serializer::access;
+ *     template <typename Archive, typename Self>
+ *     static void serialize(Archive & archive, Self & self)
+ *     {
+ *         person::serialize(archive, self);
+ *           archive(self.m_university);
+ *       }
+ *
+ *     virtual void print() const
+ *     {
+ *         std::cout << "student: " << person::get_name() << ' ' <<
+ * m_university << '\n';
+ *     }
+ *
+ * private:
+ *     std::string m_university;
+ * };
+ *
+ * namespace
+ * {
+ * zpp::serializer::register_types<
+ *    zpp::serializer::make_type<person,
+ * zpp::serializer::make_id("v1::person")>,
+ *    zpp::serializer::make_type<student,
+ * zpp::serializer::make_id("v1::student")> > _; } // <anynymous namespace>
+ *
+ * static void foo()
+ * {
+ *     std::vector<unsigned char> data;
+ *     zpp::serializer::memory_input_archive in(data);
+ *     zpp::serializer::memory_output_archive out(data);
+ *
+ *     std::unique_ptr<person> my_person =
+ * std::make_unique<student>("1337", "1337University"); out(my_person);
+ *
+ *     my_person = nullptr;
+ *     in(my_person);
+ *
+ *     my_person->print();
+ * }
+ *
+ * static void bar()
+ * {
+ *     std::vector<unsigned char> data;
+ *     zpp::serializer::memory_input_archive in(data);
+ *     zpp::serializer::memory_output_archive out(data);
+ *
+ *     out(zpp::serializer::as_polymorphic(student("1337",
+ * "1337University")));
+ *
+ *     std::unique_ptr<person> my_person;
+ *     in(my_person);
+ *
+ *     my_person->print();
+ * }
+ * ~~~
+ */
+namespace serializer
+{
+namespace detail
+{
+/**
+ * Map any sequence of types to void.
+ */
+template <typename...>
+using void_t = void;
+
+/**
+ * Tests if all conditions are true, empty means true.
+ * Example:
+ * ~~~
+ * all_of<true, false, true>::value == false
+ * all_of<true, true>::value == true
+ * all_of<false, false>::value == false
+ * all_of<>::value == true
+ * ~~~
+ */
+template <bool... bConditions>
+struct all_of : std::true_type
+{
+};
+
+template <bool... bConditions>
+struct all_of<false, bConditions...> : std::false_type
+{
+};
+
+template <bool... bConditions>
+struct all_of<true, bConditions...> : all_of<bConditions...>
+{
+};
+
+template <>
+struct all_of<true> : std::true_type
+{
+};
+
+/**
+ * Remove const of container value_type
+ */
+template <typename Container, typename = void>
+struct container_nonconst_value_type
+{
+    using type = std::remove_const_t<typename Container::value_type>;
+};
+
+/**
+ * Same as above, except in case of std::map and std::unordered_map, and
+ * similar, we also need to remove the const of the key type.
+ */
+template <template <typename...> class Container,
+          typename KeyType,
+          typename MappedType,
+          typename... ExtraTypes>
+struct container_nonconst_value_type<
+    Container<KeyType, MappedType, ExtraTypes...>,
+    void_t<
+        // Require existence of key_type.
+        typename Container<KeyType, MappedType, ExtraTypes...>::key_type,
+
+        // Require existence of mapped_type.
+        typename Container<KeyType, MappedType, ExtraTypes...>::
+            mapped_type,
+
+        // Require that the value type is a pair of const KeyType and
+        // MappedType.
+        std::enable_if_t<std::is_same<
+            std::pair<const KeyType, MappedType>,
+            typename Container<KeyType, MappedType, ExtraTypes...>::
+                value_type>::value>>>
+{
+    using type = std::pair<KeyType, MappedType>;
+};
+
+/**
+ * Alias to the above.
+ */
+template <typename Container>
+using container_nonconst_value_type_t =
+    typename container_nonconst_value_type<Container>::type;
+
+/**
+ * The serializer exception template.
+ */
+template <typename Base, std::size_t Id>
+class exception : public Base
+{
+public:
+    /**
+     * Use the constructors from the base class.
+     */
+    using Base::Base;
+};
+
+/**
+ * A no operation, single byte has same representation in little/big
+ * endian.
+ */
+inline constexpr std::uint8_t swap_byte_order(std::uint8_t value) noexcept
+{
+    return value;
+}
+
+/**
+ * Swaps the byte order of a given integer.
+ */
+inline constexpr std::uint16_t
+swap_byte_order(std::uint16_t value) noexcept
+{
+    return (std::uint16_t(swap_byte_order(std::uint8_t(value))) << 8) |
+           (swap_byte_order(std::uint8_t(value >> 8)));
+}
+
+/**
+ * Swaps the byte order of a given integer.
+ */
+inline constexpr std::uint32_t
+swap_byte_order(std::uint32_t value) noexcept
+{
+    return (std::uint32_t(swap_byte_order(std::uint16_t(value))) << 16) |
+           (swap_byte_order(std::uint16_t(value >> 16)));
+}
+
+/**
+ * Swaps the byte order of a given integer.
+ */
+inline constexpr std::uint64_t
+swap_byte_order(std::uint64_t value) noexcept
+{
+    return (std::uint64_t(swap_byte_order(std::uint32_t(value))) << 32) |
+           (swap_byte_order(std::uint32_t(value >> 32)));
+}
+
+/**
+ * Rotates the given number left by count bits.
+ */
+template <typename Integer>
+constexpr auto rotate_left(Integer number, std::size_t count)
+{
+    return (number << count) | (number >> ((sizeof(number) * 8) - count));
+}
+
+/**
+ * Checks if has 'data()' member function.
+ */
+template <typename Type, typename = void>
+struct has_data_member_function : std::false_type
+{
+};
+
+/**
+ * Checks if has 'data()' member function.
+ */
+template <typename Type>
+struct has_data_member_function<
+    Type,
+    void_t<decltype(std::declval<Type &>().data())>> : std::true_type
+{
+};
+
+} // namespace detail
+
+/**
+ * @name Exceptions
+ * @{
+ */
+using out_of_range = detail::exception<std::out_of_range, 0>;
+using undeclared_polymorphic_type_error =
+    detail::exception<std::runtime_error, 1>;
+using attempt_to_serialize_null_pointer_error =
+    detail::exception<std::logic_error, 2>;
+using polymorphic_type_mismatch_error =
+    detail::exception<std::runtime_error, 3>;
+using attempt_to_serialize_valueless_variant =
+    detail::exception<std::runtime_error, 4>;
+using variant_index_out_of_range = detail::exception<std::out_of_range, 5>;
+/**
+ * @}
+ */
+
+/**
+ * If C++17 or greater, use shared mutex, else, use shared timed mutex.
+ */
+#if __cplusplus >= 201703L
+/**
+ * The shared mutex type, defined to shared mutex when available.
+ */
+using shared_mutex = std::shared_mutex;
+#else
+/**
+ * The shared mutex type, defined to shared timed mutex when shared mutex
+ * is not available.
+ */
+using shared_mutex = std::shared_timed_mutex;
+#endif
+
+/**
+ * The base class for polymorphic serialization.
+ */
+class polymorphic
+{
+public:
+    /**
+     * Pure virtual destructor, in order to become abstract
+     * and make derived classes polymorphic.
+     */
+    virtual ~polymorphic() = 0;
+};
+
+/**
+ * Default implementation for the destructor.
+ */
+inline polymorphic::~polymorphic() = default;
+
+/**
+ * Allow serialization with saving (output) archives, of objects held by
+ * reference, that will be serialized as polymorphic, meaning, with leading
+ * polymorphic serialization id.
+ */
+template <typename Type>
+class polymorphic_wrapper
+{
+public:
+    static_assert(std::is_base_of<polymorphic, Type>::value,
+                  "The given type is not derived from polymorphic");
+
+    /**
+     * Constructs from the given object to be serialized as polymorphic.
+     */
+    explicit polymorphic_wrapper(const Type & object) noexcept :
+        m_object(object)
+    {
+    }
+
+    /**
+     * Returns the object to be serialized as polymorphic.
+     */
+    const Type & operator*() const noexcept
+    {
+        return m_object;
+    }
+
+private:
+    /**
+     * The object to be serialized as polymorphic.
+     */
+    const Type & m_object;
+}; // polymorphic_wrapper
+
+/**
+ * A facility to save object with leading polymorphic serialization id.
+ */
+template <typename Type>
+auto as_polymorphic(const Type & object) noexcept
+{
+    return polymorphic_wrapper<Type>(object);
+}
+
+/**
+ * The size type of the serializer.
+ * It is used to indicate the size for containers.
+ */
+using size_type = std::uint32_t;
+
+/**
+ * The serialization id type,
+ */
+using id_type = std::uint64_t;
+
+/**
+ * This class grants the serializer access to the serialized types.
+ */
+class access
+{
+public:
+    /**
+     * Allows placement construction of types.
+     */
+    template <typename Item, typename... Arguments>
+    static auto
+    placement_new(void * pAddress, Arguments &&... arguments) noexcept(
+        noexcept(Item(std::forward<Arguments>(arguments)...)))
+    {
+        return ::new (pAddress)
+            Item(std::forward<Arguments>(arguments)...);
+    }
+
+    /**
+     * Allows dynamic construction of types.
+     * This overload is for non polymorphic serialization.
+     */
+    template <typename Item,
+              typename... Arguments,
+              typename = std::enable_if_t<
+                  !std::is_base_of<polymorphic, Item>::value>>
+    static auto make_unique(Arguments &&... arguments)
+    {
+        // Construct the requested type, using new since constructor might
+        // be private.
+        return std::unique_ptr<Item>(
+            new Item(std::forward<Arguments>(arguments)...));
+    }
+
+    /**
+     * Allows dynamic construction of types.
+     * This overload is for polymorphic serialization.
+     */
+    template <typename Item,
+              typename... Arguments,
+              typename = std::enable_if_t<
+                  std::is_base_of<polymorphic, Item>::value>,
+              typename = void>
+    static auto make_unique(Arguments &&... arguments)
+    {
+        // We create a deleter that will delete using the base class
+        // polymorphic which, as we declared, has a public virtual
+        // destructor.
+        struct deleter
+        {
+            void operator()(Item * item) noexcept
+            {
+                delete static_cast<polymorphic *>(item);
+            }
+        };
+
+        // Construct the requested type, using new since constructor might
+        // be private.
+        return std::unique_ptr<Item, deleter>(
+            new Item(std::forward<Arguments>(arguments)...));
+    }
+
+    /**
+     * Allows destruction of types.
+     */
+    template <typename Item>
+    static void destruct(Item & item) noexcept
+    {
+        item.~Item();
+    }
+}; // access
+
+/**
+ * Enables serialization of arbitrary binary data.
+ * Use only with care.
+ */
+template <typename Item>
+class binary
+{
+public:
+    /**
+     * Constructs the binary wrapper from pointer and count of items.
+     */
+    binary(Item * items, size_type count) : m_items(items), m_count(count)
+    {
+    }
+
+    /**
+     * Returns a pointer to the first item.
+     */
+    Item * data() const noexcept
+    {
+        return m_items;
+    }
+
+    /**
+     * Returns the size in bytes of the binary data.
+     */
+    size_type size_in_bytes() const noexcept
+    {
+        return m_count * sizeof(Item);
+    }
+
+    /**
+     * Returns the count of items in the binary wrapper.
+     */
+    size_type count() const noexcept
+    {
+        return m_count;
+    }
+
+private:
+    /**
+     * Pointer to the items.
+     */
+    Item * m_items = nullptr;
+
+    /**
+     * The number of items.
+     */
+    size_type m_count{};
+};
+
+/**
+ * Allows serialization as binary data.
+ * Use only with care.
+ */
+template <typename Item>
+binary<Item> as_binary(Item * item, size_type count)
+{
+    static_assert(std::is_trivially_copyable<Item>::value,
+                  "Must be trivially copyable");
+
+    return {item, count};
+}
+
+/**
+ * Allows serialization as binary data.
+ * Use only with care.
+ */
+inline binary<unsigned char> as_binary(void * data, size_type size)
+{
+    return {static_cast<unsigned char *>(data), size};
+}
+
+/**
+ * Allows serialization as binary data.
+ */
+inline binary<const unsigned char> as_binary(const void * data,
+                                             size_type size)
+{
+    return {static_cast<const unsigned char *>(data), size};
+}
+
+/**
+ * The serialization method type.
+ */
+template <typename Archive, typename = void>
+struct serialization_method;
+
+/**
+ * The serialization method type exporter, for loading (input) archives.
+ */
+template <typename Archive>
+struct serialization_method<Archive, typename Archive::loading>
+{
+    /**
+     * Disabled default constructor.
+     */
+    serialization_method() = delete;
+
+    /**
+     * The exported type.
+     */
+    using type = void (*)(Archive &, std::unique_ptr<polymorphic> &);
+}; // serialization_method
+
+/**
+ * The serialization method type exporter, for saving (output) archives.
+ */
+template <typename Archive>
+struct serialization_method<Archive, typename Archive::saving>
+{
+    /**
+     * Disabled default constructor.
+     */
+    serialization_method() = delete;
+
+    /**
+     * The exported type.
+     */
+    using type = void (*)(Archive &, const polymorphic &);
+}; // serialization_method
+
+/**
+ * The serialization method type.
+ */
+template <typename Archive>
+using serialization_method_t =
+    typename serialization_method<Archive>::type;
+
+/**
+ * Make a serialization method from type and a loading (input) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::loading>
+serialization_method_t<Archive> make_serialization_method() noexcept
+{
+    return [](Archive & archive, std::unique_ptr<polymorphic> & object) {
+        auto concrete_type = access::make_unique<Type>();
+        archive(*concrete_type);
+        object.reset(concrete_type.release());
+    };
+}
+
+/**
+ * Make a serialization method from type and a saving (output) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::saving,
+          typename = void>
+serialization_method_t<Archive> make_serialization_method() noexcept
+{
+    return [](Archive & archive, const polymorphic & object) {
+        archive(dynamic_cast<const Type &>(object));
+    };
+}
+
+/**
+ * This is the base archive of the serializer.
+ * It enables saving and loading items into/from the archive, via
+ * operator().
+ */
+template <typename ArchiveType>
+class archive
+{
+public:
+    /**
+     * The derived archive type.
+     */
+    using archive_type = ArchiveType;
+
+    /**
+     * Save/Load the given items into/from the archive.
+     */
+    template <typename... Items>
+    void operator()(Items &&... items)
+    {
+        // Disallow serialization of pointer types.
+        static_assert(
+            detail::all_of<!std::is_pointer<
+                std::remove_reference_t<Items>>::value...>::value,
+            "Serialization of pointer types is not allowed");
+
+        // Serialize the items.
+        serialize_items(std::forward<Items>(items)...);
+    }
+
+protected:
+    /**
+     * Constructs the archive.
+     */
+    archive() = default;
+
+    /**
+     * Protected destructor to allow safe public inheritance.
+     */
+    ~archive() = default;
+
+private:
+    /**
+     * Serialize the given items, one by one.
+     */
+    template <typename Item, typename... Items>
+    void serialize_items(Item && first, Items &&... items)
+    {
+        // Invoke serialize_item the first item.
+        serialize_item(std::forward<Item>(first));
+
+        // Serialize the rest of the items.
+        serialize_items(std::forward<Items>(items)...);
+    }
+
+    /**
+     * Serializes zero items.
+     */
+    void serialize_items()
+    {
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for class type items with serialize method.
+     */
+    template <typename Item,
+              typename...,
+              typename = decltype(std::remove_reference_t<Item>::serialize(
+                  std::declval<archive_type &>(), std::declval<Item &>()))>
+    void serialize_item(Item && item)
+    {
+        // Forward as lvalue.
+        std::remove_reference_t<Item>::serialize(concrete_archive(), item);
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for types with outer serialize method.
+     */
+    template <typename Item,
+              typename...,
+              typename = decltype(serialize(std::declval<archive_type &>(),
+                                            std::declval<Item &>())),
+              typename = void>
+    void serialize_item(Item && item)
+    {
+        // Forward as lvalue.
+        serialize(concrete_archive(), item);
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for fundamental types.
+     */
+    template <typename Item,
+              typename...,
+              typename = std::enable_if_t<std::is_fundamental<
+                  std::remove_reference_t<Item>>::value>,
+              typename = void,
+              typename = void>
+    void serialize_item(Item && item)
+    {
+        // Forward as lvalue.
+        concrete_archive().serialize(item);
+    }
+
+    /**
+     * Serialize a single item.
+     * This overload is for enum classes.
+     */
+    template <typename Item,
+              typename...,
+              typename = std::enable_if_t<
+                  std::is_enum<std::remove_reference_t<Item>>::value>,
+              typename = void,
+              typename = void,
+              typename = void>
+    void serialize_item(Item && item)
+    {
+        // If the enum is const, we want the type to be a const type, else
+        // non-const.
+        using integral_type = std::conditional_t<
+            std::is_const<std::remove_reference_t<Item>>::value,
+            const std::underlying_type_t<std::remove_reference_t<Item>>,
+            std::underlying_type_t<std::remove_reference_t<Item>>>;
+
+        // Cast the enum to the underlying type, and forward as lvalue.
+        concrete_archive().serialize(
+            reinterpret_cast<std::add_lvalue_reference_t<integral_type>>(
+                item));
+    }
+
+    /**
+     * Serialize binary data.
+     */
+    template <typename T>
+    void serialize_item(binary<T> && item)
+    {
+        concrete_archive().serialize(item.data(), item.size_in_bytes());
+    }
+
+    /**
+     * Returns the concrete archive.
+     */
+    archive_type & concrete_archive()
+    {
+        return static_cast<archive_type &>(*this);
+    }
+}; // archive
+
+/**
+ * This archive serves as an output archive, which saves data into memory.
+ * Every save operation appends data into the vector.
+ * This archive serves as an optimization around vector, use
+ * 'memory_output_archive' instead.
+ */
+class lazy_vector_memory_output_archive
+    : public archive<lazy_vector_memory_output_archive>
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = archive<lazy_vector_memory_output_archive>;
+
+    /**
+     * Declare base as friend.
+     */
+    friend base;
+
+    /**
+     * saving archive.
+     */
+    using saving = void;
+
+protected:
+    /**
+     * Constructs a memory output archive, that outputs to the given
+     * vector.
+     */
+    explicit lazy_vector_memory_output_archive(
+        std::vector<unsigned char> & output) noexcept :
+        m_output(std::addressof(output))
+    {
+    }
+
+    /**
+     * Serialize a single item - save it to the vector.
+     */
+    template <typename Item>
+    void serialize(Item && item)
+    {
+        // Increase vector size.
+        if (m_size + sizeof(item) > m_output->size()) {
+            m_output->resize((m_size + sizeof(item)) * 3 / 2);
+        }
+
+        // Copy the data to the end of the vector.
+        std::copy_n(
+            reinterpret_cast<const unsigned char *>(std::addressof(item)),
+            sizeof(item),
+            m_output->data() + m_size);
+
+        // Increase the size.
+        m_size += sizeof(item);
+    }
+
+    /**
+     * Serialize binary data - save it to the vector.
+     */
+    void serialize(const void * data, size_type size)
+    {
+        // Increase vector size.
+        if (m_size + size > m_output->size()) {
+            m_output->resize((m_size + size) * 3 / 2);
+        }
+
+        // Copy the data to the end of the vector.
+        std::copy_n(static_cast<const unsigned char *>(data),
+                    size,
+                    m_output->data() + m_size);
+
+        // Increase the size.
+        m_size += size;
+    }
+
+    /**
+     * Resizes the vector to the desired size.
+     */
+    void fit_vector()
+    {
+        m_output->resize(m_size);
+    }
+
+    /**
+     * Set the size to the vector size.
+     */
+    void adjust_size()
+    {
+        m_size = m_output->size();
+    }
+
+private:
+    /**
+     * The output vector.
+     */
+    std::vector<unsigned char> * m_output{};
+
+    /**
+     * The vector size.
+     */
+    std::size_t m_size{};
+}; // lazy_vector_memory_output_archive
+
+/**
+ * This archive serves as an output archive, which saves data into memory.
+ * Every save operation appends data into the vector.
+ */
+class memory_output_archive : private lazy_vector_memory_output_archive
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = lazy_vector_memory_output_archive;
+
+    /**
+     * Constructs a memory output archive, that outputs to the given
+     * vector.
+     */
+    explicit memory_output_archive(
+        std::vector<unsigned char> & output) noexcept :
+        lazy_vector_memory_output_archive(output)
+    {
+    }
+
+    /**
+     * Saves items into the archive.
+     */
+    template <typename... Items>
+    void operator()(Items &&... items)
+    {
+        // Set the size to the vector size.
+        adjust_size();
+
+        try {
+            // Serialize the items.
+            base::operator()(std::forward<Items>(items)...);
+
+            // Fit the vector.
+            fit_vector();
+        } catch (...) {
+            // Fit the vector.
+            fit_vector();
+            throw;
+        }
+    }
+};
+
+/**
+ * This archive serves as the memory view input archive, which loads data
+ * from non owning memory. Every load operation advances an offset to that
+ * the next data may be loaded on the next iteration.
+ */
+class memory_view_input_archive : public archive<memory_view_input_archive>
+{
+public:
+    /**
+     * The base archive.
+     */
+    using base = archive<memory_view_input_archive>;
+
+    /**
+     * Declare base as friend.
+     */
+    friend base;
+
+    /**
+     * Loading archive.
+     */
+    using loading = void;
+
+    /**
+     * Construct a memory view input archive, that loads data from an array
+     * of given pointer and size.
+     */
+    memory_view_input_archive(const unsigned char * input,
+                              std::size_t size) noexcept :
+        m_input(input),
+        m_size(size)
+    {
+    }
+
+    /**
+     * Construct a memory view input archive, that loads data from an array
+     * of given pointer and size.
+     */
+    memory_view_input_archive(const char * input,
+                              std::size_t size) noexcept :
+        m_input(reinterpret_cast<const unsigned char *>(input)),
+        m_size(size)
+    {
+    }
+
+protected:
+    /**
+     * Resets the serialization to offset zero.
+     */
+    void reset() noexcept
+    {
+        m_offset = {};
+    }
+
+    /**
+     * Returns the offset of the serialization.
+     */
+    std::size_t get_offset() const noexcept
+    {
+        return m_offset;
+    }
+
+    /**
+     * Serialize a single item - load it from the vector.
+     */
+    template <typename Item>
+    void serialize(Item && item)
+    {
+        // Verify that the vector is large enough to contain the item.
+        if (m_size < (sizeof(item) + m_offset)) {
+            throw out_of_range("Input vector was not large enough to "
+                               "contain the requested item");
+        }
+
+        // Fetch the item from the vector.
+        std::copy_n(
+            m_input + m_offset,
+            sizeof(item),
+            reinterpret_cast<unsigned char *>(std::addressof(item)));
+
+        // Increase the offset according to item size.
+        m_offset += sizeof(item);
+    }
+
+    /**
+     * Serializes binary data.
+     */
+    void serialize(void * data, size_type size)
+    {
+        // Verify that the vector is large enough to contain the data.
+        if (m_size < (size + m_offset)) {
+            throw out_of_range("Input vector was not large enough to "
+                               "contain the requested item");
+        }
+
+        // Fetch the binary data from the vector.
+        std::copy_n(
+            m_input + m_offset, size, static_cast<unsigned char *>(data));
+
+        // Increase the offset according to data size.
+        m_offset += size;
+    }
+
+private:
+    /**
+     * The input data.
+     */
+    const unsigned char * m_input{};
+
+    /**
+     * The input size.
+     */
+    std::size_t m_size{};
+
+    /**
+     * The next input.
+     */
+    std::size_t m_offset{};
+}; // memory_view_input_archive
+
+/**
+ * This archive serves as the memory input archive, which loads data from
+ * owning memory. Every load operation erases data from the beginning of
+ * the vector.
+ */
+class memory_input_archive : private memory_view_input_archive
+{
+public:
+    /**
+     * Construct a memory input archive from a vector.
+     */
+    memory_input_archive(std::vector<unsigned char> & input) :
+        memory_view_input_archive(input.data(), input.size()),
+        m_input(std::addressof(input))
+    {
+    }
+
+    /**
+     * Load items from the archive.
+     */
+    template <typename... Items>
+    void operator()(Items &&... items)
+    {
+        try {
+            // Update the input archive.
+            static_cast<memory_view_input_archive &>(*this) = {
+                m_input->data(), m_input->size()};
+
+            // Load the items.
+            memory_view_input_archive::operator()(
+                std::forward<Items>(items)...);
+        } catch (...) {
+            // Erase the loaded elements.
+            m_input->erase(m_input->begin(),
+                           m_input->begin() + get_offset());
+
+            // Reset to offset zero.
+            reset();
+            throw;
+        }
+
+        // Erase the loaded elements.
+        m_input->erase(m_input->begin(), m_input->begin() + get_offset());
+
+        // Reset to offset zero.
+        reset();
+    }
+
+private:
+    /**
+     * The input data.
+     */
+    std::vector<unsigned char> * m_input{};
+};
+
+/**
+ * This class manages polymorphic type registration for serialization
+ * process.
+ */
+template <typename Archive>
+class registry
+{
+public:
+    static_assert(!std::is_reference<Archive>::value,
+                  "Disallows reference type for archive in registry");
+
+    /**
+     * Returns the global instance of the registry.
+     */
+    static registry & get_instance() noexcept
+    {
+        static registry registry;
+        return registry;
+    }
+
+    /**
+     * Add a serialization method for a given polymorphic type and id.
+     */
+    template <typename Type, id_type id>
+    void add()
+    {
+        add<Type>(id);
+    }
+
+    /**
+     * Adds a serialization method for a given polymorphic type and id.
+     */
+    template <typename Type>
+    void add(id_type id)
+    {
+        add(id,
+            typeid(Type).name(),
+            make_serialization_method<Archive, Type>());
+    }
+
+    /**
+     * Add a serialization method for a given polymorphic type information
+     * string and id. The behavior is undefined if the type isn't derived
+     * from polymorphic.
+     */
+    void add(id_type id,
+             std::string type_information_string,
+             serialization_method_t<Archive> serialization_method)
+    {
+        // Lock the serialization method maps for write access.
+        std::lock_guard<shared_mutex> lock(m_shared_mutex);
+
+        // Add the serialization id to serialization method mapping.
+        m_serialization_id_to_method.emplace(
+            id, std::move(serialization_method));
+
+        // Add the type information to to serialization id mapping.
+        m_type_information_to_serialization_id.emplace(
+            std::move(type_information_string), id);
+    }
+
+    /**
+     * Serialize a polymorphic type, in case of a loading (input) archive.
+     */
+    template <typename...,
+              typename ArchiveType = Archive,
+              typename = typename ArchiveType::loading>
+    void serialize(Archive & archive,
+                   std::unique_ptr<polymorphic> & object)
+    {
+        id_type id{};
+
+        // Load the serialization id.
+        archive(id);
+
+        // Lock the serialization method maps for read access.
+        std::shared_lock<shared_mutex> lock(m_shared_mutex);
+
+        // Find the serialization method.
+        auto serialization_id_to_method_pair =
+            m_serialization_id_to_method.find(id);
+        if (m_serialization_id_to_method.end() ==
+            serialization_id_to_method_pair) {
+            throw undeclared_polymorphic_type_error(
+                "Undeclared polymorphic serialization type error.");
+        }
+
+        // Fetch the serialization method.
+        auto serialization_method =
+            serialization_id_to_method_pair->second;
+
+        // Unlock the serialization method maps.
+        lock.unlock();
+
+        // Serialize (load) the given object.
+        serialization_method(archive, object);
+    }
+
+    /**
+     * Serialize a polymorphic type, in case of a saving (output) archive.
+     */
+    template <typename...,
+              typename ArchiveType = Archive,
+              typename = typename ArchiveType::saving>
+    void serialize(Archive & archive, const polymorphic & object)
+    {
+        // Lock the serialization method maps for read access.
+        std::shared_lock<shared_mutex> lock(m_shared_mutex);
+
+        // Find the serialization id.
+        auto type_information_to_serialization_id_pair =
+            m_type_information_to_serialization_id.find(
+                typeid(object).name());
+        if (m_type_information_to_serialization_id.end() ==
+            type_information_to_serialization_id_pair) {
+            throw undeclared_polymorphic_type_error(
+                "Undeclared polymorphic serialization type error.");
+        }
+
+        // Fetch the serialization id.
+        auto id = type_information_to_serialization_id_pair->second;
+
+        // Find the serialization method.
+        auto serialization_id_to_method_pair =
+            m_serialization_id_to_method.find(id);
+        if (m_serialization_id_to_method.end() ==
+            serialization_id_to_method_pair) {
+            throw undeclared_polymorphic_type_error(
+                "Undeclared polymorphic serialization type error.");
+        }
+
+        // Fetch the serialization method.
+        auto serialization_method =
+            serialization_id_to_method_pair->second;
+
+        // Unlock the serialization method maps.
+        lock.unlock();
+
+        // Serialize (save) the serialization id.
+        archive(id);
+
+        // Serialize (save) the given object.
+        serialization_method(archive, object);
+    }
+
+private:
+    /**
+     * Default constructor, defaulted.
+     */
+    registry() = default;
+
+private:
+    /**
+     * The shared mutex that protects the maps below.
+     */
+    shared_mutex m_shared_mutex;
+
+    /**
+     * A map between serialization id to method.
+     */
+    std::unordered_map<id_type, serialization_method_t<Archive>>
+        m_serialization_id_to_method;
+
+    /**
+     * A map between type information string to serialization id.
+     */
+    std::unordered_map<std::string, id_type>
+        m_type_information_to_serialization_id;
+}; // registry
+
+/**
+ * Serialize resizable containers, operates on loading (input) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename = decltype(std::declval<Container &>().resize(std::size_t())),
+    typename = std::enable_if_t<
+        std::is_class<typename Container::value_type>::value ||
+        !std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<
+                typename Container::iterator>::iterator_category>::value>,
+    typename = typename Archive::loading,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+void serialize(Archive & archive, Container & container)
+{
+    size_type size{};
+
+    // Fetch the number of items to load.
+    archive(size);
+
+    // Resize the container to match the size.
+    container.resize(size);
+
+    // Serialize all the items.
+    for (auto & item : container) {
+        archive(item);
+    }
+}
+
+/**
+ * Serialize resizable containers, operates on saving (output) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename = decltype(std::declval<Container &>().resize(std::size_t())),
+    typename = std::enable_if_t<
+        std::is_class<typename Container::value_type>::value ||
+        !std::is_base_of<
+            std::random_access_iterator_tag,
+            typename std::iterator_traits<
+                typename Container::iterator>::iterator_category>::value ||
+        !detail::has_data_member_function<Container>::value>,
+    typename = typename Archive::saving,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+void serialize(Archive & archive, const Container & container)
+{
+    // Save the container size.
+    archive(static_cast<size_type>(container.size()));
+
+    // Serialize all the items.
+    for (auto & item : container) {
+        archive(item);
+    }
+}
+
+/**
+ * Serialize resizable, continuous containers, of fundamental or
+ * enumeration types. Operates on loading (input) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename = decltype(std::declval<Container &>().resize(std::size_t())),
+    typename = decltype(std::declval<Container &>().data()),
+    typename = std::enable_if_t<
+        std::is_fundamental<typename Container::value_type>::value ||
+        std::is_enum<typename Container::value_type>::value>,
+    typename = std::enable_if_t<std::is_base_of<
+        std::random_access_iterator_tag,
+        typename std::iterator_traits<
+            typename Container::iterator>::iterator_category>::value>,
+    typename = typename Archive::loading,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+void serialize(Archive & archive, Container & container)
+{
+    size_type size{};
+
+    // Fetch the number of items to load.
+    archive(size);
+
+    // Resize the container to match the size.
+    container.resize(size);
+
+    // If the size is zero, return.
+    if (!size) {
+        return;
+    }
+
+    // Serialize the binary data.
+    archive(as_binary(std::addressof(container[0]),
+                      static_cast<size_type>(container.size())));
+}
+
+/**
+ * Serialize resizable, continuous containers, of fundamental or
+ * enumeration types. Operates on saving (output) archives.
+ */
+template <
+    typename Archive,
+    typename Container,
+    typename...,
+    typename = decltype(std::declval<Container &>().size()),
+    typename = decltype(std::declval<Container &>().begin()),
+    typename = decltype(std::declval<Container &>().end()),
+    typename = decltype(std::declval<Container &>().resize(std::size_t())),
+    typename = decltype(std::declval<Container &>().data()),
+    typename = std::enable_if_t<
+        std::is_fundamental<typename Container::value_type>::value ||
+        std::is_enum<typename Container::value_type>::value>,
+    typename = std::enable_if_t<std::is_base_of<
+        std::random_access_iterator_tag,
+        typename std::iterator_traits<
+            typename Container::iterator>::iterator_category>::value>,
+    typename = typename Archive::saving,
+    typename = void,
+    typename = void,
+    typename = void,
+    typename = void>
+void serialize(Archive & archive, const Container & container)
+{
+    // The container size.
+    auto size = static_cast<size_type>(container.size());
+
+    // Save the container size.
+    archive(size);
+
+    // If the size is zero, return.
+    if (!size) {
+        return;
+    }
+
+    // Serialize the binary data.
+    archive(as_binary(std::addressof(container[0]),
+                      static_cast<size_type>(container.size())));
+}
+
+/**
+ * Serialize Associative and UnorderedAssociative containers, operates on
+ * loading (input) archives.
+ */
+template <typename Archive,
+          typename Container,
+          typename...,
+          typename = decltype(std::declval<Container &>().size()),
+          typename = decltype(std::declval<Container &>().begin()),
+          typename = decltype(std::declval<Container &>().end()),
+          typename = typename Container::value_type,
+          typename = typename Container::key_type,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, Container & container)
+{
+    size_type size{};
+
+    // Fetch the number of items to load.
+    archive(size);
+
+    // Serialize all the items.
+    for (size_type i{}; i < size; ++i) {
+        // Deduce the container item type.
+        using item_type =
+            detail::container_nonconst_value_type_t<Container>;
+
+        // Create just enough storage properly aligned for one item.
+        std::aligned_storage_t<sizeof(item_type), alignof(item_type)>
+            storage;
+
+        // Create the object at the storage.
+        std::unique_ptr<item_type, void (*)(item_type *)> object(
+            access::placement_new<item_type>(std::addressof(storage)),
+            [](auto pointer) { access::destruct(*pointer); });
+
+        // Serialize the object.
+        archive(*object);
+
+        // Insert the item to the container.
+        container.insert(std::move(*object));
+    }
+}
+
+/**
+ * Serialize Associative and UnorderedAssociative containers, operates on
+ * saving (output) archives.
+ */
+template <typename Archive,
+          typename Container,
+          typename...,
+          typename = decltype(std::declval<Container &>().size()),
+          typename = decltype(std::declval<Container &>().begin()),
+          typename = decltype(std::declval<Container &>().end()),
+          typename = typename Container::value_type,
+          typename = typename Container::key_type,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const Container & container)
+{
+    // Save the container size.
+    archive(static_cast<size_type>(container.size()));
+
+    // Serialize every item.
+    for (auto & item : container) {
+        archive(item);
+    }
+}
+
+/**
+ * Serialize arrays, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, Item (&array)[size])
+{
+    // Serialize every item.
+    for (auto & item : array) {
+        archive(item);
+    }
+}
+
+/**
+ * Serialize arrays, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const Item (&array)[size])
+{
+    // Serialize every item.
+    for (auto & item : array) {
+        archive(item);
+    }
+}
+
+/**
+ * Serialize std::array, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, std::array<Item, size> & array)
+{
+    // Serialize every item.
+    for (auto & item : array) {
+        archive(item);
+    }
+}
+
+/**
+ * Serialize std::array, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename Item,
+          std::size_t size,
+          typename...,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const std::array<Item, size> & array)
+{
+    // Serialize every item.
+    for (auto & item : array) {
+        archive(item);
+    }
+}
+
+/**
+ * Serialize std::pair, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename First,
+          typename Second,
+          typename...,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, std::pair<First, Second> & pair)
+{
+    // Serialize first, then second.
+    archive(pair.first, pair.second);
+}
+
+/**
+ * Serialize std::pair, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename First,
+          typename Second,
+          typename...,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const std::pair<First, Second> & pair)
+{
+    // Serialize first, then second.
+    archive(pair.first, pair.second);
+}
+
+/**
+ * Serialize std::tuple, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, std::tuple<TupleItems...> & tuple)
+{
+    // Delegate to a helper function with an index sequence.
+    serialize(
+        archive, tuple, std::make_index_sequence<sizeof...(TupleItems)>());
+}
+
+/**
+ * Serialize std::tuple, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const std::tuple<TupleItems...> & tuple)
+{
+    // Delegate to a helper function with an index sequence.
+    serialize(
+        archive, tuple, std::make_index_sequence<sizeof...(TupleItems)>());
+}
+
+/**
+ * Serialize std::tuple, operates on loading (input) archives.
+ * This overload serves as a helper function that accepts an index
+ * sequence.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          std::size_t... Indices,
+          typename = typename Archive::loading>
+void serialize(Archive & archive,
+               std::tuple<TupleItems...> & tuple,
+               std::index_sequence<Indices...>)
+{
+    archive(std::get<Indices>(tuple)...);
+}
+
+/**
+ * Serialize std::tuple, operates on saving (output) archives.
+ * This overload serves as a helper function that accepts an index
+ * sequence.
+ */
+template <typename Archive,
+          typename... TupleItems,
+          std::size_t... Indices,
+          typename = typename Archive::saving>
+void serialize(Archive & archive,
+               const std::tuple<TupleItems...> & tuple,
+               std::index_sequence<Indices...>)
+{
+    archive(std::get<Indices>(tuple)...);
+}
+
+#if __cplusplus >= 201703L
+/**
+ * Serialize std::optional, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, std::optional<Type> & optional)
+{
+    // Load whether has value.
+    bool has_value{};
+    archive(has_value);
+
+    // If does not have a value.
+    if (!has_value) {
+        optional = std::nullopt;
+        return;
+    }
+
+    // If the type is default constructible.
+    if constexpr (std::is_default_constructible_v<Type>) {
+        // Create the value if does not exist.
+        if (!optional) {
+            optional = Type{};
+        }
+
+        // Load the value.
+        archive(*optional);
+    } else {
+        // The object storage.
+        std::aligned_storage_t<sizeof(Type), alignof(Type)> storage;
+
+        // Create the object at the storage.
+        std::unique_ptr<Type, void (*)(Type *)> object(
+            access::placement_new<Type>(std::addressof(storage)),
+            [](auto pointer) { access::destruct(*pointer); });
+
+        // Load the object.
+        archive(*object);
+
+        // Assign the loaded object.
+        optional = std::move(*object);
+    }
+}
+
+/**
+ * Serialize std::optional, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const std::optional<Type> & optional)
+{
+    // Save has value.
+    bool has_value = optional.has_value();
+
+    // If has value, save it.
+    if (has_value) {
+        archive(has_value, *optional);
+    } else {
+        archive(has_value);
+    }
+}
+
+/**
+ * Serialize std::variant, operates on loading (input) archives.
+ */
+template <typename Archive,
+          typename... Types,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, std::variant<Types...> & variant)
+{
+    // Test for maximum number of types.
+    static_assert(sizeof...(Types) < 0xff, "Max variant types reached.");
+
+    // The variant index.
+    unsigned char index{};
+
+    // Load the index.
+    archive(index);
+
+    // Check that loaded index is inside bounds.
+    if (index >= sizeof...(Types)) {
+        throw variant_index_out_of_range("Variant index out of range");
+    }
+
+    // The variant type.
+    using variant_type = std::variant<Types...>;
+
+    // Loader type.
+    using loader_type =
+        void (*)(Archive & archive, variant_type & variant);
+
+    // Loaders per variant index.
+    static constexpr loader_type loaders[] = {[](auto & archive,
+                                                 auto & variant) {
+        // If the type is default constructible.
+        if constexpr (std::is_default_constructible_v<Types>) {
+            // If does not have the needed type, assign it.
+            if (!std::get_if<Types>(&variant)) {
+                variant = Types{};
+            }
+
+            // Load the value.
+            archive(*std::get_if<Types>(&variant));
+        } else {
+            // The object storage.
+            std::aligned_storage_t<sizeof(Types), alignof(Types)> storage;
+
+            // Create the object at the storage.
+            std::unique_ptr<Types, void (*)(Types *)> object(
+                access::placement_new<Types>(std::addressof(storage)),
+                [](auto pointer) { access::destruct(*pointer); });
+
+            // Load the object.
+            archive(*object);
+
+            // Assign the loaded object.
+            variant = std::move(*object);
+        }
+    }...};
+
+    // Execute the appropriate loader.
+    loaders[index](archive, variant);
+}
+
+/**
+ * Serialize std::variant, operates on saving (output) archives.
+ */
+template <typename Archive,
+          typename... Types,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const std::variant<Types...> & variant)
+{
+    // Test for maximum number of types.
+    static_assert(sizeof...(Types) < 0xff, "Max variant types reached.");
+
+    // The variant index.
+    auto variant_index = variant.index();
+
+    // Disallow serializations of valueless variant.
+    if (std::variant_npos == variant_index) {
+        throw attempt_to_serialize_valueless_variant(
+            "Cannot serialize a valueless variant.");
+    }
+
+    // The index to save.
+    auto index = static_cast<unsigned char>(variant_index & 0xff);
+
+    // Save the variant object.
+    std::visit(
+        [index, &archive](auto & object) { archive(index, object); },
+        variant);
+}
+#endif
+
+/**
+ * Serialize std::unique_ptr of non polymorphic, in case of a loading
+ * (input) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, std::unique_ptr<Type> & object)
+{
+    // Construct a new object.
+    auto loaded_object = access::make_unique<Type>();
+
+    // Serialize the object.
+    archive(*loaded_object);
+
+    // Transfer the object.
+    object.reset(loaded_object.release());
+}
+
+/**
+ * Serialize std::unique_ptr of non polymorphic, in case of a saving
+ * (output) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const std::unique_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+    }
+
+    // Serialize the object.
+    archive(*object);
+}
+
+/**
+ * Serialize std::unique_ptr of polymorphic, in case of a loading (input)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::loading,
+    typename = void>
+void serialize(Archive & archive, std::unique_ptr<Type> & object)
+{
+    std::unique_ptr<polymorphic> loaded_type;
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, loaded_type);
+
+    try {
+        // Check if the loaded type is convertible to Type.
+        object.reset(&dynamic_cast<Type &>(*loaded_type));
+
+        // Release the object.
+        loaded_type.release();
+    } catch (const std::bad_cast &) {
+        // The loaded type was not convertible to Type.
+        throw polymorphic_type_mismatch_error(
+            "Polymorphic serialization type mismatch.");
+    }
+}
+
+/**
+ * Serialize std::unique_ptr of polymorphic, in case of a saving (output)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::saving,
+    typename = void>
+void serialize(Archive & archive, const std::unique_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+    }
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, *object);
+}
+
+/**
+ * Serialize std::shared_ptr of non polymorphic, in case of a loading
+ * (input) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::loading>
+void serialize(Archive & archive, std::shared_ptr<Type> & object)
+{
+    // Construct a new object.
+    auto loaded_object = access::make_unique<Type>();
+
+    // Serialize the object.
+    archive(*loaded_object);
+
+    // Transfer the object.
+    object.reset(loaded_object.release());
+}
+
+/**
+ * Serialize std::shared_ptr of non polymorphic, in case of a saving
+ * (output) archive.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename =
+              std::enable_if_t<!std::is_base_of<polymorphic, Type>::value>,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const std::shared_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+    }
+
+    // Serialize the object.
+    archive(*object);
+}
+
+/**
+ * Serialize std::shared_ptr of polymorphic, in case of a loading (input)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::loading,
+    typename = void>
+void serialize(Archive & archive, std::shared_ptr<Type> & object)
+{
+    std::unique_ptr<polymorphic> loaded_type;
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, loaded_type);
+
+    try {
+        // Check if the loaded type is convertible to Type.
+        object.reset(&dynamic_cast<Type &>(*loaded_type));
+
+        // Release the object.
+        loaded_type.release();
+    } catch (const std::bad_cast &) {
+        // The loaded type was not convertible to Type.
+        throw polymorphic_type_mismatch_error(
+            "Polymorphic serialization type mismatch.");
+    }
+}
+
+/**
+ * Serialize std::shared_ptr of polymorphic, in case of a saving (output)
+ * archive.
+ */
+template <
+    typename Archive,
+    typename Type,
+    typename...,
+    typename = std::enable_if_t<std::is_base_of<polymorphic, Type>::value>,
+    typename = typename Archive::saving,
+    typename = void>
+void serialize(Archive & archive, const std::shared_ptr<Type> & object)
+{
+    // Prevent serialization of null pointers.
+    if (nullptr == object) {
+        throw attempt_to_serialize_null_pointer_error(
+            "Attempt to serialize null pointer.");
+    }
+
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize the object using the registry.
+    registry_instance.serialize(archive, *object);
+}
+
+/**
+ * Serialize types wrapped with polymorphic_wrapper,
+ * which is supported only for saving (output) archives.
+ * Usually used with the as_polymorphic facility.
+ */
+template <typename Archive,
+          typename Type,
+          typename...,
+          typename = typename Archive::saving>
+void serialize(Archive & archive, const polymorphic_wrapper<Type> & object)
+{
+    // Get the instance of the polymorphic registry.
+    auto & registry_instance = registry<Archive>::get_instance();
+
+    // Serialize using the registry.
+    registry_instance.serialize(archive, *object);
+}
+
+/**
+ * A meta container that holds a sequence of archives.
+ */
+template <typename... Archives>
+struct archive_sequence
+{
+};
+
+/**
+ * The built in archives.
+ */
+using builtin_archives =
+    archive_sequence<memory_view_input_archive,
+                     lazy_vector_memory_output_archive>;
+
+/**
+ * Makes a meta pair of type and id.
+ */
+template <typename Type, id_type id>
+struct make_type;
+
+/**
+ * Registers user defined polymorphic types to serialization registry.
+ */
+template <typename... ExtraTypes>
+class register_types;
+
+/**
+ * A no operation class, registers an empty list of types.
+ */
+template <>
+class register_types<>
+{
+};
+
+/**
+ * Registers user defined polymorphic types to serialization registry.
+ */
+template <typename Type, id_type id, typename... ExtraTypes>
+class register_types<make_type<Type, id>, ExtraTypes...>
+    : private register_types<ExtraTypes...>
+{
+public:
+    /**
+     * Registers the type to the built in archives of the serializer.
+     */
+    register_types() noexcept : register_types(builtin_archives())
+    {
+    }
+
+    /**
+     * Registers the type to every archive in the given archive sequence.
+     */
+    template <typename... Archives>
+    register_types(archive_sequence<Archives...> archives) noexcept
+    {
+        register_type_to_archives(archives);
+    }
+
+private:
+    /**
+     * Registers the type to every archive in the given archive sequence.
+     */
+    template <typename Archive, typename... Archives>
+    void register_type_to_archives(
+        archive_sequence<Archive, Archives...>) noexcept
+    {
+        // Register the type to the first archive.
+        register_type_to_archive<Archive>();
+
+        // Register the type to the other archives.
+        register_type_to_archives(archive_sequence<Archives...>());
+    }
+
+    /**
+     * Registers the type to an empty archive sequence - does nothing.
+     */
+    void register_type_to_archives(archive_sequence<>) noexcept
+    {
+    }
+
+    /**
+     * Registers the type to the given archive.
+     * Must throw no exceptions since this will most likely execute
+     * during static construction.
+     * The effect of failure is that the type will not be registered,
+     * it will be detected during runtime.
+     */
+    template <typename Archive>
+    void register_type_to_archive() noexcept
+    {
+        try {
+            registry<Archive>::get_instance().template add<Type, id>();
+        } catch (...) {
+        }
+    }
+}; // register_types
+
+/**
+ * Accepts a name and returns its serialization id.
+ * We return the first 8 bytes of the sha1 on the given name.
+ */
+template <std::size_t size>
+constexpr id_type make_id(const char (&name)[size])
+{
+    // Initialize constants.
+    std::uint32_t h0 = 0x67452301u;
+    std::uint32_t h1 = 0xEFCDAB89u;
+    std::uint32_t h2 = 0x98BADCFEu;
+    std::uint32_t h3 = 0x10325476u;
+    std::uint32_t h4 = 0xC3D2E1F0u;
+
+    // Initialize the message size in bits.
+    std::uint64_t message_size = (size - 1) * 8;
+
+    // Calculate the size aligned to 64 bytes (512 bits).
+    constexpr std::size_t aligned_message_size =
+        (((size + sizeof(std::uint64_t)) + 63) / 64) * 64;
+
+    // Construct the pre-processed message.
+    std::uint32_t preprocessed_message[aligned_message_size /
+                                       sizeof(std::uint32_t)] = {};
+    for (std::size_t i{}; i < size - 1; ++i) {
+        preprocessed_message[i / 4] |= detail::swap_byte_order(
+            std::uint32_t(name[i])
+            << ((sizeof(std::uint32_t) - 1 - (i % 4)) * 8));
+    }
+
+    // Append the byte 0x80.
+    preprocessed_message[(size - 1) / 4] |= detail::swap_byte_order(
+        std::uint32_t(0x80)
+        << ((sizeof(std::uint32_t) - 1 - ((size - 1) % 4)) * 8));
+
+    // Append the length in bits, in 64 bit, big endian.
+    preprocessed_message[(aligned_message_size / sizeof(std::uint32_t)) -
+                         2] =
+        detail::swap_byte_order(std::uint32_t(message_size >> 32));
+    preprocessed_message[(aligned_message_size / sizeof(std::uint32_t)) -
+                         1] =
+        detail::swap_byte_order(std::uint32_t(message_size));
+
+    // Process the message in successive 512-bit chunks.
+    for (std::size_t i{};
+         i < (aligned_message_size / sizeof(std::uint32_t));
+         i += 16) {
+        std::uint32_t w[80] = {};
+
+        // Set the value of w.
+        for (std::size_t j{}; j < 16; ++j) {
+            w[j] = preprocessed_message[i + j];
+        }
+
+        // Extend the sixteen 32-bit words into eighty 32-bit words.
+        for (std::size_t j = 16; j < 80; ++j) {
+            w[j] = detail::swap_byte_order(detail::rotate_left(
+                detail::swap_byte_order(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^
+                                        w[j - 16]),
+                1));
+        }
+
+        // Initialize hash values for this chunk.
+        auto a = h0;
+        auto b = h1;
+        auto c = h2;
+        auto d = h3;
+        auto e = h4;
+
+        // Main loop.
+        for (std::size_t j{}; j < 80; ++j) {
+            std::uint32_t f{};
+            std::uint32_t k{};
+            if (j <= 19) {
+                f = (b & c) | ((~b) & d);
+                k = 0x5A827999u;
+            } else if (j <= 39) {
+                f = b ^ c ^ d;
+                k = 0x6ED9EBA1u;
+            } else if (j <= 59) {
+                f = (b & c) | (b & d) | (c & d);
+                k = 0x8F1BBCDCu;
+            } else {
+                f = b ^ c ^ d;
+                k = 0xCA62C1D6u;
+            }
+
+            auto temp = detail::rotate_left(a, 5) + f + e + k +
+                        detail::swap_byte_order(w[j]);
+            e = d;
+            d = c;
+            c = detail::rotate_left(b, 30);
+            b = a;
+            a = temp;
+        }
+
+        // Add this chunk's hash to result so far.
+        h0 += a;
+        h1 += b;
+        h2 += c;
+        h3 += d;
+        h4 += e;
+    }
+
+    // Produce the first 8 bytes of the hash in little endian.
+    return detail::swap_byte_order((std::uint64_t(h0) << 32) | h1);
+} // make_id
+
+} // namespace serializer
+} // namespace zpp
+
+#endif

From 34278c380e5fd320d02964d902978176a5c9099a Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 08:16:38 +0000
Subject: [PATCH 06/12] Implement protocol with serializer library

---
 proto/manager_service.proto.cpp | 11 ++++++
 proto/manager_service.proto.h   | 68 +++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+)
 create mode 100644 proto/manager_service.proto.cpp
 create mode 100644 proto/manager_service.proto.h

diff --git a/proto/manager_service.proto.cpp b/proto/manager_service.proto.cpp
new file mode 100644
index 00000000..5e921dd7
--- /dev/null
+++ b/proto/manager_service.proto.cpp
@@ -0,0 +1,11 @@
+#include "manager_service.proto.h"
+
+namespace {
+
+zpp::serializer::register_types<
+   zpp::serializer::make_type<ava_proto::WorkerAssignRequest, zpp::serializer::make_id("v1::ava_proto::WorkerAssignRequest")>,
+   zpp::serializer::make_type<ava_proto::WorkerAssignReply, zpp::serializer::make_id("v1::ava_proto::WorkerAssignReply")>
+> _;
+
+}  // namespace ava_proto
+
diff --git a/proto/manager_service.proto.h b/proto/manager_service.proto.h
new file mode 100644
index 00000000..d9d12b22
--- /dev/null
+++ b/proto/manager_service.proto.h
@@ -0,0 +1,68 @@
+#ifndef AVA_PROTO_MANAGER_SERVICE_H_
+#define AVA_PROTO_MANAGER_SERVICE_H_
+
+#include <vector>
+#include <string>
+#include "import/serializer.h"
+
+namespace ava_proto {
+
+/**
+ * During the creation of the command channel in Guestlib, the channel requests
+ * Manager to assign an API server to the application, and then connects the API
+ * server directly to execute APIs.
+ *
+ * The request object can be extended based on supported resources. For example,
+ * `gpu_count` is the number of requested GPUs, and `gpu_mem` is a `gpu_count`-
+ * sized vector containing the memory required for each GPU. `worker_count` should
+ * be equal to or less than `gpu_count` in this case.
+ */
+class WorkerAssignRequest : public zpp::serializer::polymorphic {
+public:
+  WorkerAssignRequest() = default;
+
+  friend zpp::serializer::access;
+  template <typename Archive, typename Self>
+  static void serialize(Archive & archive, Self & self) {
+      archive(self.worker_count_, self.gpu_count_, self.gpu_mem_);
+  }
+
+  uint32_t& worker_count() { return worker_count_; }
+  const uint32_t& worker_count() const { return worker_count_; }
+  uint32_t& gpu_count() { return gpu_count_; }
+  const uint32_t& gpu_count() const { return gpu_count_; }
+  std::vector<uint64_t>& gpu_mem() { return gpu_mem_; }
+  const std::vector<uint64_t>& gpu_mem() const { return gpu_mem_; }
+
+private:
+  uint32_t worker_count_;          /* Number of requested API servers. Must be 1 */
+  uint32_t gpu_count_;             /* Number of requested GPUs */
+  std::vector<uint64_t> gpu_mem_;  /* Available memory required for each GPU */
+};
+
+
+/**
+ * Manager replies with a list of API server addresses. The length of `worker_address`
+ * must equal `worker_count` in the request.
+ * The returned address must follow the format of `IP:PORT`.
+ */
+class WorkerAssignReply : public zpp::serializer::polymorphic {
+public:
+  WorkerAssignReply() = default;
+
+  friend zpp::serializer::access;
+  template <typename Archive, typename Self>
+  static void serialize(Archive & archive, Self & self) {
+      archive(self.worker_address_);
+  }
+
+  std::vector<std::string>& worker_address() { return worker_address_; }
+  const std::vector<std::string>& worker_address() const { return worker_address_; }
+
+private:
+  std::vector<std::string> worker_address_;
+};
+
+}  // namespace ava_proto
+
+#endif  // AVA_PROTO_MANAGER_SERVICE_H_

From 95c4b033aa82c8af1ff93c9e5c6d94a5c414b760 Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 08:17:27 +0000
Subject: [PATCH 07/12] Guestlib uses imported serializer installed protobuf

---
 cava/nightwatch/generator/c/cmakelists.py |  4 ++--
 common/cmd_channel_socket_tcp.cpp         | 21 ++++++++++++---------
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/cava/nightwatch/generator/c/cmakelists.py b/cava/nightwatch/generator/c/cmakelists.py
index 782888d0..e8552955 100644
--- a/cava/nightwatch/generator/c/cmakelists.py
+++ b/cava/nightwatch/generator/c/cmakelists.py
@@ -14,7 +14,7 @@ def source(api: API, errors):
 
 list(APPEND CMAKE_MODULE_PATH "${{CMAKE_CURRENT_BINARY_DIR}}/../..")
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 14)
 
 set(c_flags {api.cflags})
 set(cxx_flags {api.cxxflags})
@@ -96,7 +96,7 @@ def source(api: API, errors):
   ${{CMAKE_SOURCE_DIR}}/../../common/cmd_channel_socket_utilities.cpp
   ${{CMAKE_SOURCE_DIR}}/../../common/cmd_channel_socket_tcp.cpp
   ${{CMAKE_SOURCE_DIR}}/../../common/cmd_channel_socket_vsock.cpp
-  ${{CMAKE_BINARY_DIR}}/../../proto/manager_service.pb.cc
+  ${{CMAKE_SOURCE_DIR}}/../../proto/manager_service.proto.cpp
 )
 target_link_libraries(guestlib
   ${{GLIB2_LIBRARIES}}
diff --git a/common/cmd_channel_socket_tcp.cpp b/common/cmd_channel_socket_tcp.cpp
index 7324c2fb..54a312bc 100644
--- a/common/cmd_channel_socket_tcp.cpp
+++ b/common/cmd_channel_socket_tcp.cpp
@@ -24,7 +24,7 @@
 #include "common/cmd_handler.h"
 #include "cmd_channel_socket_utilities.h"
 #include "guest_config.h"
-#include "manager_service.pb.h"
+#include "manager_service.proto.h"
 
 using boost::asio::ip::tcp;
 
@@ -53,22 +53,25 @@ std::vector<struct command_channel*> command_channel_socket_tcp_guest_new()
 
     // Serialize configurations
     ava_proto::WorkerAssignRequest request;
-    request.set_gpu_count(guestconfig::config->gpu_memory_.size());
+    request.gpu_count() = guestconfig::config->gpu_memory_.size();
     for (auto m : guestconfig::config->gpu_memory_) {
-      request.add_gpu_mem(m << 20);
+      request.gpu_mem().push_back(m << 20);
     }
-    std::string request_buf(request.SerializeAsString());
-    uint32_t request_length = static_cast<uint32_t>(request_buf.length() + 1);
+    std::vector<unsigned char> request_buf;
+    zpp::serializer::memory_input_archive out(request_buf);
+    out(request);
+    uint32_t request_length = static_cast<uint32_t>(request_buf.size());
     boost::asio::write(manager_sock, boost::asio::buffer(&request_length, sizeof(uint32_t)));
-    boost::asio::write(manager_sock, boost::asio::buffer(request_buf.c_str(), request_length));
+    boost::asio::write(manager_sock, boost::asio::buffer(request_buf.data(), request_length));
 
     // De-serialize API server addresses
     uint32_t reply_length;
     boost::asio::read(manager_sock, boost::asio::buffer(&reply_length, sizeof(uint32_t)));
-    char reply_str[reply_length];
-    boost::asio::read(manager_sock, boost::asio::buffer(reply_str, reply_length));
+    std::vector<unsigned char> reply_buf(reply_length);
+    zpp::serializer::memory_input_archive in(reply_buf);
+    boost::asio::read(manager_sock, boost::asio::buffer(reply_buf.data(), reply_length));
     ava_proto::WorkerAssignReply reply;
-    reply.ParseFromString(reply_str);
+    in(reply);
     std::vector<std::string> worker_address;
     for (auto& wa : reply.worker_address()) {
         worker_address.push_back(wa);

From 0a7fc8de8dbe84549b8a1628abd98a890d75e07d Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 08:59:31 +0000
Subject: [PATCH 08/12] Fix guestlib out serialization

---
 common/cmd_channel_socket_tcp.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/cmd_channel_socket_tcp.cpp b/common/cmd_channel_socket_tcp.cpp
index 54a312bc..f121b9f5 100644
--- a/common/cmd_channel_socket_tcp.cpp
+++ b/common/cmd_channel_socket_tcp.cpp
@@ -58,7 +58,7 @@ std::vector<struct command_channel*> command_channel_socket_tcp_guest_new()
       request.gpu_mem().push_back(m << 20);
     }
     std::vector<unsigned char> request_buf;
-    zpp::serializer::memory_input_archive out(request_buf);
+    zpp::serializer::memory_output_archive out(request_buf);
     out(request);
     uint32_t request_length = static_cast<uint32_t>(request_buf.size());
     boost::asio::write(manager_sock, boost::asio::buffer(&request_length, sizeof(uint32_t)));

From 11e715655eef4e60ba00a103e6c864d1b9df6214 Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 09:06:05 +0000
Subject: [PATCH 09/12] Port legacy manager

---
 docs/build_and_setup.md          | 13 +++++++------
 worker/CMakeLists.txt            |  8 +++++---
 worker/include/manager_service.h |  2 +-
 worker/legacy/CMakeLists.txt     |  4 ++--
 worker/legacy/README.md          | 27 +++++++++++++++++++++++++++
 worker/legacy/manager.cpp        |  4 ++--
 worker/manager_service.cpp       | 20 +++++++++++---------
 7 files changed, 55 insertions(+), 23 deletions(-)
 create mode 100644 worker/legacy/README.md

diff --git a/docs/build_and_setup.md b/docs/build_and_setup.md
index 7c80e7d4..c962e150 100644
--- a/docs/build_and_setup.md
+++ b/docs/build_and_setup.md
@@ -53,12 +53,13 @@ old codes into the new build system (v2.0) is still ongoing.
 
 > \* Upstream changes ([ava-serverless](https://github.com/photoszzt/ava-serverless)) have not been merged.
 
-| AvA manager | Status |
-| ----------- | ------ |
-| Demo        | TESTED |
-| Galvanic    | NO |
-| Katana      | NO |
-| Nvidia GPU  | NO |
+| AvA manager   | Status |
+| ------------- | ------ |
+| Demo          | NO |
+| Galvanic      | NO |
+| Katana        | NO |
+| Legacy (r1.0) | TESTED |
+| Nvidia GPU    | NO |
 
 This tutorial shows how to configure and build the minimal AvA demo API
 remoting system. To build and use other supported virtualized APIs, please
diff --git a/worker/CMakeLists.txt b/worker/CMakeLists.txt
index cff28676..b454847a 100644
--- a/worker/CMakeLists.txt
+++ b/worker/CMakeLists.txt
@@ -18,11 +18,13 @@ set(manager_service_libraries Threads::Threads
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/../include
   ${CMAKE_CURRENT_SOURCE_DIR}/include
+  ${CMAKE_CURRENT_SOURCE_DIR}/../proto
   ${CMAKE_CURRENT_BINARY_DIR}/../proto
 )
-set(manager_service_pb_srcs  "${CMAKE_CURRENT_BINARY_DIR}/../proto/manager_service.pb.cc")
-set(manager_service_ava_srcs "${CMAKE_CURRENT_SOURCE_DIR}/manager_service.cpp"
-                             "${CMAKE_CURRENT_SOURCE_DIR}/signal_handler.cpp")
+set(manager_service_pb_srcs    "${CMAKE_CURRENT_BINARY_DIR}/../proto/manager_service.pb.cc")
+set(manager_service_proto_srcs "${CMAKE_CURRENT_SOURCE_DIR}/../proto/manager_service.proto.cpp")
+set(manager_service_ava_srcs   "${CMAKE_CURRENT_SOURCE_DIR}/manager_service.cpp"
+                               "${CMAKE_CURRENT_SOURCE_DIR}/signal_handler.cpp")
 
 if(AVA_MANAGER_GALVANIC)
   add_subdirectory(galvanic)
diff --git a/worker/include/manager_service.h b/worker/include/manager_service.h
index 87ae77a1..f30c2fb7 100644
--- a/worker/include/manager_service.h
+++ b/worker/include/manager_service.h
@@ -7,7 +7,7 @@
 #include <thread>
 #include <vector>
 
-#include "manager_service.pb.h"
+#include "manager_service.proto.h"
 #include "signal_handler.h"
 
 namespace ava_manager {
diff --git a/worker/legacy/CMakeLists.txt b/worker/legacy/CMakeLists.txt
index 24a91a21..be80c2c1 100644
--- a/worker/legacy/CMakeLists.txt
+++ b/worker/legacy/CMakeLists.txt
@@ -2,13 +2,13 @@ cmake_minimum_required(VERSION 3.13)
 
 project(legacy-manager C CXX CUDA)
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 14)
 
 add_compile_options(-Wall -Wextra -pedantic -Wno-write-strings -g)
 
 add_executable(legacy-manager
   manager.cpp
-  ${manager_service_pb_srcs}
+  ${manager_service_proto_srcs}
   ${manager_service_ava_srcs}
 )
 target_link_libraries(legacy-manager
diff --git a/worker/legacy/README.md b/worker/legacy/README.md
new file mode 100644
index 00000000..6ce19dec
--- /dev/null
+++ b/worker/legacy/README.md
@@ -0,0 +1,27 @@
+Demo AvA Manager
+===================
+
+This demo manager shows an example of a minimal AvA manager running on localhost:3333.
+The demo manager runs a RPC service which receives `WorkerAssignRequest` from a guestlib,
+spawns an API server every time and returns the API server's address back to the guestlib.
+
+Start Manager
+=============
+
+Assume we are at `${AVA_BUILD_DIR}` and use CUDA API remoting as an example.
+
+```Shell
+cmake ../ava -DAVA_GEN_CUDA_SPEC=ON -DAVA_MANAGER_LEGACY=ON
+make
+./install/bin/demo_manager generated/cudadrv_nw/worker
+```
+
+The manager will start and listen at `0.0.0.0:3333`. It will spawn API servers
+from the provided API server binary.
+
+Then link the application to `libguestlib.so`.
+The application will start with AvA's generated CUDA library loaded.
+
+```Shell
+LD_LIBRARY_PATH=${AVA_BUILD_DIR}/generated/cudadrv_nw ./cuda_program
+```
diff --git a/worker/legacy/manager.cpp b/worker/legacy/manager.cpp
index 1f41917d..64edc3be 100644
--- a/worker/legacy/manager.cpp
+++ b/worker/legacy/manager.cpp
@@ -7,7 +7,7 @@
 #include <sys/wait.h>
 
 #include "manager_service.h"
-#include "manager_service.pb.h"
+#include "manager_service.proto.h"
 
 using ava_manager::ManagerServiceServerBase;
 
@@ -74,7 +74,7 @@ class DemoManager : public ManagerServiceServerBase {
     else {
       worker_port = SpawnWorkerWrapper();
     }
-    reply.add_worker_address("0.0.0.0:" + std::to_string(worker_port));
+    reply.worker_address().push_back("0.0.0.0:" + std::to_string(worker_port));
 
     return reply;
   }
diff --git a/worker/manager_service.cpp b/worker/manager_service.cpp
index 62e6dcf6..db4f5d91 100644
--- a/worker/manager_service.cpp
+++ b/worker/manager_service.cpp
@@ -60,22 +60,24 @@ void ManagerServiceServerBase::HandleAccept(
   // De-serialize request from guestlib
   uint32_t request_length;
   asio::read(*socket, asio::buffer(&request_length, sizeof(uint32_t)));
-  auto request_str = new char[request_length];
-  asio::read(*socket, asio::buffer(request_str, request_length));
+  std::vector<unsigned char> request_buf(request_length);
+  asio::read(*socket, asio::buffer(request_buf.data(), request_length));
 
   ava_proto::WorkerAssignRequest request;
-  request.ParseFromString(request_str);
-  delete request_str;
+  zpp::serializer::memory_input_archive in(request_buf);
+  in(request);
   std::cout << "[from " << endpoint->address() << ":" << endpoint->port()
             << "] Request " << request.gpu_count() << " GPUs" << std::endl;
 
   auto reply = HandleRequest(request);
 
   // Serialize reply to guestlib
-  std::string reply_buf(reply.SerializeAsString());
-  uint32_t reply_length = static_cast<uint32_t>(reply_buf.length() + 1);
+  std::vector<unsigned char> reply_buf;
+  zpp::serializer::memory_output_archive out(reply_buf);
+  out(reply);
+  uint32_t reply_length = static_cast<uint32_t>(reply_buf.size());
   asio::write(*socket, asio::buffer(&reply_length, sizeof(uint32_t)));
-  asio::write(*socket, asio::buffer(reply_buf.c_str(), reply_length));
+  asio::write(*socket, asio::buffer(reply_buf.data(), reply_length));
 }
 
 ava_proto::WorkerAssignReply ManagerServiceServerBase::HandleRequest(
@@ -86,7 +88,7 @@ ava_proto::WorkerAssignReply ManagerServiceServerBase::HandleRequest(
   std::vector<std::string> environments;
   if (request.gpu_count() > 0) {
     std::string visible_devices = "CUDA_VISIBLE_DEVICES=";
-    for (int i = 0; i < request.gpu_count() - 1; ++i) {
+    for (uint32_t i = 0; i < request.gpu_count() - 1; ++i) {
       visible_devices += std::to_string(i) + ",";
     }
     visible_devices += std::to_string(request.gpu_count() - 1);
@@ -120,7 +122,7 @@ ava_proto::WorkerAssignReply ManagerServiceServerBase::HandleRequest(
   child_monitor->detach();
   worker_monitor_map_.insert({port, child_monitor});
 
-  reply.add_worker_address("0.0.0.0:" + std::to_string(port));
+  reply.worker_address().push_back("0.0.0.0:" + std::to_string(port));
 
   return reply;
 }

From ee1aafb60f08db11a6d69753d4f69349e44a3b80 Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 09:48:54 +0000
Subject: [PATCH 10/12] Update TensorFlow spec

---
 cava/samples/tensorflow/README.md | 42 +++++++++++++++++++++++++++++++
 cava/samples/tensorflow/tf_dump.c | 31 ++++++++++++++++++++---
 cava/samples/tensorflow/tf_opt.c  | 31 ++++++++++++++++++++---
 3 files changed, 96 insertions(+), 8 deletions(-)

diff --git a/cava/samples/tensorflow/README.md b/cava/samples/tensorflow/README.md
index f00093ac..538cee18 100644
--- a/cava/samples/tensorflow/README.md
+++ b/cava/samples/tensorflow/README.md
@@ -1 +1,43 @@
+Install TensorFlow
+==================
+
 Install TensorFlow 1.14 from [yuhc/tensorflow-cudart-dynam](https://github.com/yuhc/tensorflow-cudart-dynam).
+Check out [BUILD.md](https://github.com/yuhc/tensorflow-cudart-dynam/blob/r1.14/BUILD.md) for build
+instructions.
+
+Build specification
+===================
+
+Configure AvA in `~/ava-build` with
+
+```shell
+cmake -DAVA_GEN_TF_SPEC=ON -DAVA_MANAGER_LEGACY=ON ../ava
+make
+```
+
+Run benchmark
+=============
+
+Dump CUDA binaries for the benchmark (Generally speaking, in most cases, CUDA
+binaries generated from a large TensorFlow benchmark can be used for most other
+benchmarks):
+
+```shell
+./install/bin/legacy_manager install/tf_dump/bin/worker
+LD_LIBRARY_PATH=~/ava-build/install/tf_dump/lib/ python3 your_tensorflow_benchmark.py
+sudo mkdir /cuda_dumps
+sudo cp /tmp/*.ava /cuda_dumps
+```
+
+> CUDA version: search `10.1` in `tf_dump.c` and `tf_opt.c`.
+> Dump path: search `cuda_dumps` in `tf_opt.c`.
+
+The CUDA dumps should be copied to both local (where benchmarks run) and remote
+(where API servers run) servers.
+
+Finally restart AvA manager and run the benchmark:
+
+```shell
+./install/bin/legacy_manager install/tf_opt/bin/worker
+LD_LIBRARY_PATH=~/ava-build/install/tf_opt/lib/ python3 your_tensorflow_benchmark.py
+```
diff --git a/cava/samples/tensorflow/tf_dump.c b/cava/samples/tensorflow/tf_dump.c
index a1f6397a..f16a0784 100644
--- a/cava/samples/tensorflow/tf_dump.c
+++ b/cava/samples/tensorflow/tf_dump.c
@@ -7565,8 +7565,13 @@ cudnnGetConvolutionBackwardDataWorkspaceSize(cudnnHandle_t handle,
                                              cudnnConvolutionBwdDataAlgo_t algo,
                                              size_t *sizeInBytes)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_argument(wDesc) ava_handle;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(sizeInBytes) {
+     ava_out; ava_buffer(1);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI
@@ -7584,8 +7589,26 @@ cudnnConvolutionBackwardData(cudnnHandle_t handle,
                              const cudnnTensorDescriptor_t dxDesc,
                              void *dx)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_async;
+   ava_argument(handle) ava_handle;
+   ava_argument(alpha) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(beta) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(dx) ava_opaque;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(wDesc) ava_handle;
+   ava_argument(w) ava_opaque;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(dy) ava_opaque;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(workSpace) {
+     ava_in; ava_buffer(workSpaceSizeInBytes);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI
diff --git a/cava/samples/tensorflow/tf_opt.c b/cava/samples/tensorflow/tf_opt.c
index 0f60fb50..29b3be1e 100644
--- a/cava/samples/tensorflow/tf_opt.c
+++ b/cava/samples/tensorflow/tf_opt.c
@@ -8158,8 +8158,13 @@ cudnnGetConvolutionBackwardDataWorkspaceSize(cudnnHandle_t handle,
                                              cudnnConvolutionBwdDataAlgo_t algo,
                                              size_t *sizeInBytes)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_argument(wDesc) ava_handle;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(sizeInBytes) {
+     ava_out; ava_buffer(1);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI
@@ -8177,8 +8182,26 @@ cudnnConvolutionBackwardData(cudnnHandle_t handle,
                              const cudnnTensorDescriptor_t dxDesc,
                              void *dx)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_async;
+   ava_argument(handle) ava_handle;
+   ava_argument(alpha) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(beta) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(dx) ava_opaque;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(wDesc) ava_handle;
+   ava_argument(w) ava_opaque;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(dy) ava_opaque;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(workSpace) {
+     ava_in; ava_buffer(workSpaceSizeInBytes);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI

From 631024eea89b0f01c86fdfb82aeab23ad8c24eec Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 09:49:06 +0000
Subject: [PATCH 11/12] Update ONNXruntime spec

---
 cava/samples/onnxruntime/onnx_dump.c | 31 ++++++++++++++++++++++++----
 cava/samples/onnxruntime/onnx_opt.c  | 31 ++++++++++++++++++++++++----
 2 files changed, 54 insertions(+), 8 deletions(-)

diff --git a/cava/samples/onnxruntime/onnx_dump.c b/cava/samples/onnxruntime/onnx_dump.c
index 7aabb8b2..e606d72a 100644
--- a/cava/samples/onnxruntime/onnx_dump.c
+++ b/cava/samples/onnxruntime/onnx_dump.c
@@ -7557,8 +7557,13 @@ cudnnGetConvolutionBackwardDataWorkspaceSize(cudnnHandle_t handle,
                                              cudnnConvolutionBwdDataAlgo_t algo,
                                              size_t *sizeInBytes)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_argument(wDesc) ava_handle;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(sizeInBytes) {
+     ava_out; ava_buffer(1);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI
@@ -7576,8 +7581,26 @@ cudnnConvolutionBackwardData(cudnnHandle_t handle,
                              const cudnnTensorDescriptor_t dxDesc,
                              void *dx)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_async;
+   ava_argument(handle) ava_handle;
+   ava_argument(alpha) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(beta) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(dx) ava_opaque;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(wDesc) ava_handle;
+   ava_argument(w) ava_opaque;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(dy) ava_opaque;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(workSpace) {
+     ava_in; ava_buffer(workSpaceSizeInBytes);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI
diff --git a/cava/samples/onnxruntime/onnx_opt.c b/cava/samples/onnxruntime/onnx_opt.c
index 1986f28e..c642bc37 100644
--- a/cava/samples/onnxruntime/onnx_opt.c
+++ b/cava/samples/onnxruntime/onnx_opt.c
@@ -8169,8 +8169,13 @@ cudnnGetConvolutionBackwardDataWorkspaceSize(cudnnHandle_t handle,
                                              cudnnConvolutionBwdDataAlgo_t algo,
                                              size_t *sizeInBytes)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_argument(wDesc) ava_handle;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(sizeInBytes) {
+     ava_out; ava_buffer(1);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI
@@ -8188,8 +8193,26 @@ cudnnConvolutionBackwardData(cudnnHandle_t handle,
                              const cudnnTensorDescriptor_t dxDesc,
                              void *dx)
 {
-    fprintf(stderr, "%s is not implemented\n", __func__);
-    abort();
+   ava_async;
+   ava_argument(handle) ava_handle;
+   ava_argument(alpha) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(beta) {
+      ava_type_cast(const double *);
+      ava_in; ava_buffer(1);
+   }
+   ava_argument(dx) ava_opaque;
+   ava_argument(dxDesc) ava_handle;
+   ava_argument(wDesc) ava_handle;
+   ava_argument(w) ava_opaque;
+   ava_argument(dyDesc) ava_handle;
+   ava_argument(dy) ava_opaque;
+   ava_argument(convDesc) ava_handle;
+   ava_argument(workSpace) {
+     ava_in; ava_buffer(workSpaceSizeInBytes);
+   }
 }
 
 cudnnStatus_t CUDNNWINAPI

From a97d93677fa9747dbc0e540888e86d7e374a0539 Mon Sep 17 00:00:00 2001
From: Hangchen Yu <hyu@cs.utexas.edu>
Date: Mon, 25 Jan 2021 10:27:06 +0000
Subject: [PATCH 12/12] Apply a fix that I can remember

---
 cava/samples/tensorflow/tf_opt.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cava/samples/tensorflow/tf_opt.c b/cava/samples/tensorflow/tf_opt.c
index 29b3be1e..7d47ab63 100644
--- a/cava/samples/tensorflow/tf_opt.c
+++ b/cava/samples/tensorflow/tf_opt.c
@@ -1168,7 +1168,7 @@ cudaLaunchKernel(const void *func, dim3 gridDim, dim3 blockDim, void **args,
         size_t sharedMem, cudaStream_t stream)
 {
     /* Cannot be ava_async, may lead to TensorFlow internal race condition */
-    ava_async;
+    // ava_async;
     ava_disable_native_call;
 
     ava_implicit_argument