Iyokan NT: Next Generation of Iyokan

.gitmodules

@@ -28,3 +28,6 @@
 [submodule "fmt"]
 	path = thirdparty/fmt
 	url = https://github.com/fmtlib/fmt.git
+[submodule "thirdparty/loguru"]
+	path = thirdparty/loguru
+	url = https://github.com/emilk/loguru.git

CMakeLists.txt

@@ -34,6 +34,8 @@ if (IYOKAN_ENABLE_CUDA)
 else()
     add_subdirectory(thirdparty/cuFHE/thirdparties/TFHEpp)
 endif(IYOKAN_ENABLE_CUDA)
+
+add_subdirectory(thirdparty/fmt)
 add_subdirectory(thirdparty/spdlog)
 
 set(IYOKAN_CXXFLAGS -Wall -Wextra -Wno-sign-compare)
@@ -47,13 +49,13 @@ set(IYOKAN_INCLUDE_DIRS
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/ELFIO>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/toml11>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/spdlog/include>
-    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/fmt/include>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/cuFHE/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/loguru>
 )
 if (IYOKAN_ENABLE_CUDA)
     list(APPEND IYOKAN_INCLUDE_DIRS ${CMAKE_CUDA_TOOLKIT_INCLUDE_DIRECTORIES})
 endif(IYOKAN_ENABLE_CUDA)
-set(IYOKAN_LIBS tfhe++ Threads::Threads OpenMP::OpenMP_CXX Backward::Backward stdc++fs)
+set(IYOKAN_LIBS tfhe++ Threads::Threads OpenMP::OpenMP_CXX Backward::Backward stdc++fs fmt::fmt)
 if (IYOKAN_80BIT_SECURITY)
     # For TFHEpp headers
     list(APPEND IYOKAN_COMPILE_DEFINITIONS USE_80BIT_SECURITY)

src/CMakeLists.txt

@@ -31,7 +31,10 @@ endif(IYOKAN_ENABLE_CUDA)
 
 ##### test0
 add_executable(test0
-    test0.cpp iyokan.cpp iyokan_plain.cpp iyokan_tfhepp.cpp error.cpp
+    test0.cpp
+    iyokan_nt.cpp iyokan_nt_plain.cpp iyokan_nt_tfhepp.cpp
+    error_nt.cpp packet_nt.cpp dataholder_nt.cpp
+    network_reader.cpp blueprint.cpp label.cpp allocator.cpp snapshot.cpp
     ${CMAKE_CURRENT_BINARY_DIR}/mux-ram-8-8-8.o
     ${CMAKE_CURRENT_BINARY_DIR}/mux-ram-8-16-16.o
     ${CMAKE_CURRENT_BINARY_DIR}/mux-ram-9-16-16.o)
@@ -41,11 +44,11 @@ target_compile_options(test0 PUBLIC "$<$<CONFIG:RELEASE>:${IYOKAN_CXXFLAGS_RELEA
 target_link_libraries(test0 ${IYOKAN_LIBS})
 target_include_directories(test0 PRIVATE ${IYOKAN_INCLUDE_DIRS})
 target_compile_definitions(test0 PRIVATE ${IYOKAN_COMPILE_DEFINITIONS})
-if (IYOKAN_ENABLE_CUDA)
-    target_sources(test0 PRIVATE iyokan_cufhe.cpp)
-    target_link_libraries(test0 cufhe_gpu ${CUDA_LIBRARIES})
-    target_compile_definitions(test0 PRIVATE IYOKAN_CUDA_ENABLED)
-endif(IYOKAN_ENABLE_CUDA)
+#if (IYOKAN_ENABLE_CUDA)
+#    target_sources(test0 PRIVATE iyokan_cufhe.cpp)
+#    target_link_libraries(test0 cufhe_gpu ${CUDA_LIBRARIES})
+#    target_compile_definitions(test0 PRIVATE IYOKAN_CUDA_ENABLED)
+#endif(IYOKAN_ENABLE_CUDA)
 
 ##### iyokan-packet
 add_executable(iyokan-packet iyokan-packet.cpp error.cpp)

src/allocator.cpp

@@ -0,0 +1,120 @@
+#include "dataholder_nt.hpp"
+#include "iyokan_nt.hpp"
+#include "packet_nt.hpp"
+
+#include <cereal/archives/portable_binary.hpp>
+#include <cereal/cereal.hpp>
+#include <cereal/types/variant.hpp>
+
+#include <functional>
+#include <typeindex>
+#include <variant>
+
+namespace {
+
+using namespace nt;
+
+template <class Archive>
+void save(Archive& ar, const Bit& b, const std::uint32_t version)
+{
+    assert(version == 1);
+
+    ar(static_cast<bool>(b));
+}
+
+template <class Archive>
+void load(Archive& ar, Bit& b, const std::uint32_t version)
+{
+    assert(version == 1);
+
+    bool bl;
+    ar(bl);
+    b = static_cast<Bit>(b);
+}
+
+struct Serializable {
+    std::variant<Bit, TLWELvl0> data;
+
+    template <class Archive>
+    void serialize(Archive& ar, const std::uint32_t version)
+    {
+        assert(version == 1);
+
+        ar(data);
+    }
+};
+
+}  // namespace
+
+CEREAL_CLASS_VERSION(Serializable, 1);
+
+namespace nt {
+
+/* class Allocator */
+
+Allocator::Allocator()
+    : hasLoadedFromIStream_(false), indexToBeMade_(0), data_()
+{
+}
+
+Allocator::Allocator(cereal::PortableBinaryInputArchive& ar)
+    : hasLoadedFromIStream_(true), indexToBeMade_(0), data_()
+{
+    // Read and de-serialize data from the snapshot file
+    size_t size;
+    Serializable buf;
+
+    ar(size);
+    for (size_t i = 0; i < size; i++) {
+        ar(buf);
+        switch (buf.data.index()) {
+        case 0: {  // Bit
+            Bit b = std::get<0>(buf.data);
+            data_.emplace_back(b);
+            break;
+        }
+
+        case 1: {  // TLWELvl0
+            const TLWELvl0& tlwe = std::get<1>(buf.data);
+            data_.emplace_back(tlwe);
+            break;
+        }
+
+        default:
+            ERR_UNREACHABLE;
+        }
+    }
+}
+
+void Allocator::dumpAllocatedData(cereal::PortableBinaryOutputArchive& ar) const
+{
+    // FIXME: WE KNOW the code in this function is TREMENDOUSLY UGLY (and
+    // inefficient). We need to find some more sophisticated ways to do this.
+
+    Serializable buf;
+
+    // Serialization process for each type
+    std::unordered_map<std::type_index, std::function<void(const std::any&)>>
+        tyHandlers;
+    tyHandlers[typeid(Bit)] = [&](const std::any& any) {
+        const Bit* src = std::any_cast<Bit>(&any);
+        buf.data = *src;
+        ar(buf);
+    };
+    tyHandlers[typeid(TLWELvl0)] = [&](const std::any& any) {
+        const TLWELvl0* src = std::any_cast<TLWELvl0>(&any);
+        buf.data = *src;
+        ar(buf);
+    };
+
+    // First serialize the size of the entries
+    ar(static_cast<size_t>(data_.size()));
+
+    // Dispatch
+    for (size_t i = 0; i < data_.size(); i++) {
+        const std::any& src = data_.at(i);
+        tyHandlers.at(src.type())(src);
+    }
+}
+
+}  // namespace nt