Generated from commit 45d1372867b560f3974e069fe02588d46ad193f9

ANLAB-KAIST · Jan 7, 2022 · 6131eca · 6131eca
1 parent 1ed7db9
commit 6131eca
Show file tree

Hide file tree

Showing 18 changed files with 180 additions and 1,113 deletions.
diff --git a/.gitignore b/.gitignore
@@ -4,6 +4,7 @@
 *.xml
 clang-format.diff
 build/
+app2/
 
 # End of KENS
 

diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,13 +1,18 @@
 cmake_minimum_required(VERSION 3.11)
 
-project(e VERSION 3.1)
+project(e VERSION 3.3.0)
+
+if(WIN32)
+  message(FATAL_ERROR "WIN32 target is obsolete. Please use Windows Subsystems for Linux")
+endif(WIN32)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_C_STANDARD 11)
 
 option(SANITIZER "enable clang sanitzer (default: OFF)")
+option(SOLUTION_PATH "custom solution path (default: OFF)")
 
 if("${SANITIZER}" STREQUAL "address")
   message(STATUS "Sanitizer Selected: address")
@@ -112,22 +117,17 @@ file(GLOB_RECURSE e_SOURCES "src/*.cpp")
 
 file(GLOB_RECURSE e_HEADERS "include/*.hpp")
 
-add_library(e STATIC ${e_SOURCES} ${e_HEADERS})
+add_library(e SHARED ${e_SOURCES} ${e_HEADERS})
 target_include_directories(e PUBLIC ${PROJECT_SOURCE_DIR}/include)
+find_package(Threads REQUIRED)
+target_link_libraries(e PUBLIC Threads::Threads)
 
-if(NOT WIN32)
-  target_compile_options(e PRIVATE -g -O0 -Wall)
-endif()
+if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+set_target_properties(e PROPERTIES OSX_ARCHITECTURES
+                                                 "arm64;x86_64")
 
-if(WIN32)
-  add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
-  add_subdirectory(musl)
-  target_link_libraries(e PUBLIC musl_compat)
-
-  set(gtest_force_shared_crt
-      ON
-      CACHE BOOL "" FORCE)
-endif(WIN32)
+endif()
+target_compile_options(e PRIVATE -g -O0 -Wall)
 
 # Get Library: GTest
 
@@ -171,8 +171,7 @@ function(get_solution_name TARGET)
   endif()
 endfunction()
 
-# Build Solutions
-
+# Build Solutions (If exists)
 file(GLOB_RECURSE e_solution_CMAKELISTS
      "${PROJECT_SOURCE_DIR}/solution/*/CMakeLists.txt")
 
@@ -186,41 +185,46 @@ endforeach()
 
 include(FetchContent)
 function(get_solution)
-  set(SOLUTION_REPO "https://anlab-kaist.github.io/KENSv3/solution")
+  set(SOLUTION_REPO "https://anlab-kaist.github.io/KENSv3/solution/${CMAKE_PROJECT_VERSION}")
   foreach(arg IN LISTS ARGN)
-    if(NOT TARGET ${arg}_solution)
-
-      get_solution_name(${arg}_solution)
 
-      include(FetchContent)
+    # Find Solution
+    if(NOT TARGET ${arg}_solution)
+    find_library(${arg}_solution_path ${arg}_solution PATH ${SOLUTION_PATH} EXACT)
 
-      FetchContent_Declare(
-        ${arg}_solution URL "${SOLUTION_REPO}/${${arg}_solution_SOLUTION_NAME}")
-      FetchContent_GetProperties(${arg}_solution)
-      if(NOT (${arg}_solution_POPULATED))
-        FetchContent_Populate(${arg}_solution)
-      endif()
 
-      if(WIN32)
-        file(GLOB ${arg}_solution_static "${${arg}_solution_SOURCE_DIR}/*.lib")
-      else()
-        file(GLOB ${arg}_solution_static "${${arg}_solution_SOURCE_DIR}/*.a")
-      endif()
+    if (NOT ${arg}_solution_path)
+    # Download Solution
+    message(STATUS "Donwloading ${arg}_solution")
+    get_solution_name(${arg}_solution)
 
-      add_library(${arg}_solution STATIC IMPORTED GLOBAL)
-      set_property(TARGET ${arg}_solution PROPERTY IMPORTED_LOCATION
-                                                   ${${arg}_solution_static})
+    include(FetchContent)
 
-      target_link_libraries(${arg}_solution INTERFACE e)
+    FetchContent_Declare(
+      ${arg}_solution URL "${SOLUTION_REPO}/${${arg}_solution_SOLUTION_NAME}")
+    FetchContent_GetProperties(${arg}_solution)
+    if(NOT (${arg}_solution_POPULATED))
+      FetchContent_Populate(${arg}_solution)
+    endif()
 
+    find_library(${arg}_solution_path ${arg}_solution PATH ${${arg}_solution_SOURCE_DIR} EXACT)
     endif()
+    add_library(${arg}_solution SHARED IMPORTED GLOBAL)
+    set_property(TARGET ${arg}_solution PROPERTY IMPORTED_LOCATION ${${arg}_solution_path})
 
+    target_link_libraries(${arg}_solution INTERFACE e)
+    endif()
   endforeach()
 endfunction()
 
 # Build Apps
 
+include(cmake/app-ref.cmake OPTIONAL)
+if (e_apps_CMAKELISTS)
+else()
 file(GLOB e_apps_CMAKELISTS "${PROJECT_SOURCE_DIR}/app/*/CMakeLists.txt")
+endif()
+
 list(FILTER e_apps_CMAKELISTS EXCLUDE REGEX ".*/scheduling/.*")
 
 
@@ -242,4 +246,4 @@ if(DOXYGEN_FOUND)
 
 endif(DOXYGEN_FOUND)
 
-include(cmake/kens-dist.cmake OPTIONAL)
+include(cmake/kens-dist.cmake OPTIONAL)
diff --git a/app/kens/CMakeLists.txt b/app/kens/CMakeLists.txt
@@ -4,19 +4,12 @@ project(kens)
 
 set(kens_SOURCES TCPAssignment.cpp TCPAssignment.hpp)
 
-add_library(kens ${kens_SOURCES})
-
-if(NOT WIN32)
-  target_compile_options(kens PUBLIC -g -O0 -Wall)
-endif()
+add_library(kens SHARED ${kens_SOURCES})
 
 target_link_libraries(kens PUBLIC e)
 
 get_solution(kens)
 
-target_link_libraries(kens PUBLIC kens_solution)
-target_link_libraries(kens PUBLIC gtest_main)
-
 # Tests
 
 set(kens_part1_SOURCES testopen.cpp testbind.cpp)
@@ -26,29 +19,39 @@ set(kens_part4_SOURCES testcongestion.cpp)
 set(kens_all_SOURCES ${kens_part1_SOURCES} ${kens_part2_SOURCES}
                      ${kens_part3_SOURCES} ${kens_part4_SOURCES})
 
-foreach(part part1 part2 part3 part4 all)
-  add_executable(kens-${part} testenv.hpp ${kens_${part}_SOURCES})
-  target_link_libraries(kens-${part} kens)
-  add_executable(kens-${part}-unreliable testenv.hpp ${kens_${part}_SOURCES})
-  target_link_libraries(kens-${part}-unreliable kens)
-  add_executable(kens-${part}-run-solution testenv.hpp ${kens_${part}_SOURCES})
-  target_link_libraries(kens-${part}-run-solution kens)
-  add_executable(kens-${part}-unreliable-run-solution testenv.hpp
-                                                      ${kens_${part}_SOURCES})
-  target_link_libraries(kens-${part}-unreliable-run-solution kens)
-
-  target_compile_definitions(kens-${part}-run-solution PRIVATE RUN_SOLUTION)
-  target_compile_definitions(kens-${part}-unreliable-run-solution
-                             PRIVATE RUN_SOLUTION UNRELIABLE)
-  target_compile_definitions(kens-${part}-unreliable PRIVATE UNRELIABLE)
-
-  if(${CMAKE_VERSION} VERSION_GREATER "3.13.0")
-    set_target_properties(
-      kens-${part} kens-${part}-run-solution kens-${part}-unreliable
-      kens-${part}-unreliable-run-solution PROPERTIES XCODE_GENERATE_SCHEME ON)
-    set_target_properties(
-      kens-${part} kens-${part}-run-solution kens-${part}-unreliable
-      kens-${part}-unreliable-run-solution PROPERTIES XCODE_SCHEME_ENVIRONMENT
-                                                      "GTEST_COLOR=no")
-  endif()
-endforeach(part)
+
+set(kens-targets kens)
+
+if (TARGET kens-ref)
+list(APPEND kens-targets kens-ref)
+endif()
+
+
+foreach(kens-traget ${kens-targets})
+  foreach(part part1 part2 part3 part4 all)
+    add_executable(${kens-traget}-${part} testenv.hpp ${kens_${part}_SOURCES})
+    target_link_libraries(${kens-traget}-${part} ${kens-traget} kens_solution gtest_main)
+    add_executable(${kens-traget}-${part}-unreliable testenv.hpp ${kens_${part}_SOURCES})
+    target_link_libraries(${kens-traget}-${part}-unreliable ${kens-traget} kens_solution gtest_main)
+    add_executable(${kens-traget}-${part}-run-solution testenv.hpp ${kens_${part}_SOURCES})
+    target_link_libraries(${kens-traget}-${part}-run-solution ${kens-traget} kens_solution gtest_main)
+    add_executable(${kens-traget}-${part}-unreliable-run-solution testenv.hpp
+                                                        ${kens_${part}_SOURCES})
+    target_link_libraries(${kens-traget}-${part}-unreliable-run-solution ${kens-traget} kens_solution gtest_main)
+
+    target_compile_definitions(${kens-traget}-${part}-run-solution PRIVATE RUN_SOLUTION)
+    target_compile_definitions(${kens-traget}-${part}-unreliable-run-solution
+                              PRIVATE RUN_SOLUTION UNRELIABLE)
+    target_compile_definitions(${kens-traget}-${part}-unreliable PRIVATE UNRELIABLE)
+
+    if(${CMAKE_VERSION} VERSION_GREATER "3.13.0")
+      set_target_properties(
+        ${kens-traget}-${part} ${kens-traget}-${part}-run-solution ${kens-traget}-${part}-unreliable
+        ${kens-traget}-${part}-unreliable-run-solution PROPERTIES XCODE_GENERATE_SCHEME ON)
+      set_target_properties(
+        ${kens-traget}-${part} ${kens-traget}-${part}-run-solution ${kens-traget}-${part}-unreliable
+        ${kens-traget}-${part}-unreliable-run-solution PROPERTIES XCODE_SCHEME_ENVIRONMENT
+                                                        "GTEST_COLOR=no")
+    endif()
+  endforeach(part)
+endforeach(kens-traget)
diff --git a/app/kens/TCPAssignment.cpp b/app/kens/TCPAssignment.cpp
@@ -35,48 +35,55 @@ void TCPAssignment::systemCallback(UUID syscallUUID, int pid,
 
   switch (param.syscallNumber) {
   case SOCKET:
-    // this->syscall_socket(syscallUUID, pid, param.param1_int,
-    // param.param2_int, param.param3_int);
+    // this->syscall_socket(syscallUUID, pid, std::get<int>(param.params[0]),
+    //                      std::get<int>(param.params[1]));
     break;
   case CLOSE:
-    // this->syscall_close(syscallUUID, pid, param.param1_int);
+    // this->syscall_close(syscallUUID, pid, std::get<int>(param.params[0]));
     break;
   case READ:
-    // this->syscall_read(syscallUUID, pid, param.param1_int, param.param2_ptr,
-    // param.param3_int);
+    // this->syscall_read(syscallUUID, pid, std::get<int>(param.params[0]),
+    //                    std::get<void *>(param.params[1]),
+    //                    std::get<int>(param.params[2]));
     break;
   case WRITE:
-    // this->syscall_write(syscallUUID, pid, param.param1_int, param.param2_ptr,
-    // param.param3_int);
+    // this->syscall_write(syscallUUID, pid, std::get<int>(param.params[0]),
+    //                     std::get<void *>(param.params[1]),
+    //                     std::get<int>(param.params[2]));
     break;
   case CONNECT:
-    // this->syscall_connect(syscallUUID, pid, param.param1_int,
-    //		static_cast<struct sockaddr*>(param.param2_ptr),
-    //(socklen_t)param.param3_int);
+    // this->syscall_connect(
+    //     syscallUUID, pid, std::get<int>(param.params[0]),
+    //     static_cast<struct sockaddr *>(std::get<void *>(param.params[1])),
+    //     (socklen_t)std::get<int>(param.params[2]));
     break;
   case LISTEN:
-    // this->syscall_listen(syscallUUID, pid, param.param1_int,
-    // param.param2_int);
+    // this->syscall_listen(syscallUUID, pid, std::get<int>(param.params[0]),
+    //                      std::get<int>(param.params[1]));
     break;
   case ACCEPT:
-    // this->syscall_accept(syscallUUID, pid, param.param1_int,
-    //		static_cast<struct sockaddr*>(param.param2_ptr),
-    //		static_cast<socklen_t*>(param.param3_ptr));
+    // this->syscall_accept(
+    //     syscallUUID, pid, std::get<int>(param.params[0]),
+    //     static_cast<struct sockaddr *>(std::get<void *>(param.params[1])),
+    //     static_cast<socklen_t *>(std::get<void *>(param.params[2])));
     break;
   case BIND:
-    // this->syscall_bind(syscallUUID, pid, param.param1_int,
-    //		static_cast<struct sockaddr *>(param.param2_ptr),
-    //		(socklen_t) param.param3_int);
+    // this->syscall_bind(
+    //     syscallUUID, pid, std::get<int>(param.params[0]),
+    //     static_cast<struct sockaddr *>(std::get<void *>(param.params[1])),
+    //     (socklen_t)std::get<int>(param.params[2]));
     break;
   case GETSOCKNAME:
-    // this->syscall_getsockname(syscallUUID, pid, param.param1_int,
-    //		static_cast<struct sockaddr *>(param.param2_ptr),
-    //		static_cast<socklen_t*>(param.param3_ptr));
+    // this->syscall_getsockname(
+    //     syscallUUID, pid, std::get<int>(param.params[0]),
+    //     static_cast<struct sockaddr *>(std::get<void *>(param.params[1])),
+    //     static_cast<socklen_t *>(std::get<void *>(param.params[2])));
     break;
   case GETPEERNAME:
-    // this->syscall_getpeername(syscallUUID, pid, param.param1_int,
-    //		static_cast<struct sockaddr *>(param.param2_ptr),
-    //		static_cast<socklen_t*>(param.param3_ptr));
+    // this->syscall_getpeername(
+    //     syscallUUID, pid, std::get<int>(param.params[0]),
+    //     static_cast<struct sockaddr *>(std::get<void *>(param.params[1])),
+    //     static_cast<socklen_t *>(std::get<void *>(param.params[2])));
     break;
   default:
     assert(0);

diff --git a/app/routing/CMakeLists.txt b/app/routing/CMakeLists.txt
@@ -2,21 +2,26 @@ project(routing)
 
 # Build routing
 
-set(routing_SOURCES RoutingAssignment.cpp RoutingAssignment.hpp testrouting.cpp)
+set(routing_SOURCES RoutingAssignment.cpp RoutingAssignment.hpp)
+add_library(routing SHARED ${routing_SOURCES})
+target_link_libraries(routing PUBLIC e)
 
-add_executable(routing-all ${routing_SOURCES})
-target_link_libraries(routing-all PUBLIC gtest_main)
 
-if(NOT WIN32)
-  target_compile_options(routing-all PUBLIC -g -O0 -Wall)
+set(routing-targets routing)
+
+if (TARGET routing-ref)
+list(APPEND routing-targets routing-ref)
 endif()
 
-target_link_libraries(routing-all PUBLIC e)
 
-if(${CMAKE_VERSION} VERSION_GREATER "3.15.0")
-  set_target_properties(routing-all PROPERTIES XCODE_GENERATE_SCHEME ON)
-  set_target_properties(routing-all PROPERTIES XCODE_SCHEME_ARGUMENTS
-                                               "--gtest_color=no")
-  set_target_properties(routing-all PROPERTIES XCODE_SCHEME_ENVIRONMENT
-                                               "GTEST_COLOR=no")
-endif()
+foreach(routing-traget ${routing-targets})
+  add_executable(${routing-traget}-all testrouting.cpp)
+  target_link_libraries(${routing-traget}-all PUBLIC ${routing-traget} gtest_main)
+  if(${CMAKE_VERSION} VERSION_GREATER "3.15.0")
+    set_target_properties(${routing-traget}-all PROPERTIES XCODE_GENERATE_SCHEME ON)
+    set_target_properties(${routing-traget}-all PROPERTIES XCODE_SCHEME_ARGUMENTS
+                                                "--gtest_color=no")
+    set_target_properties(${routing-traget}-all PROPERTIES XCODE_SCHEME_ENVIRONMENT
+                                                "GTEST_COLOR=no")
+  endif()
+endforeach()
diff --git a/entrypoint.sh b/entrypoint.sh
@@ -27,7 +27,7 @@ function grade() {
     for seed in ${RANDOM_SEED//,/ }; do
         for part in "${@:2}"; do
             for test in $("./app/$1/$1-$part" --gtest_list_tests | grep '^  *'); do
-                GTEST_OUTPUT="xml:/xml/${1}_${part}_${seed}_${test}.xml" RANDOM_SEED=$seed timeout ${TIMEOUT} "./app/$1/$1-$part" --gtest_filter="*$test" --gtest_catch_exceptions=0
+                timeout ${TIMEOUT} GTEST_OUTPUT="xml:/xml/${1}_${part}_${seed}_${test}.xml" RANDOM_SEED=$seed "./app/$1/$1-$part" --gtest_filter="*$test"
             done
         done
     done

diff --git a/include/E/Networking/E_Host.hpp b/include/E/Networking/E_Host.hpp
@@ -151,6 +151,8 @@ class SystemCallInterface {
   static constexpr int IPPROTO_TCP = 6;
   static constexpr int IPPROTO_UDP = 17;
 
+  static constexpr int max_param = 3;
+
   enum SystemCall {
     SOCKET,
     CLOSE,
@@ -170,21 +172,10 @@ class SystemCallInterface {
   class SystemCallParameter {
   public:
     enum SystemCall syscallNumber;
-    union {
-      int param1_int;
-      void *param1_ptr;
-      long param1_long;
-    };
-    union {
-      int param2_int;
-      void *param2_ptr;
-      long param2_long;
-    };
-    union {
-      int param3_int;
-      void *param3_ptr;
-      long param3_long;
-    };
+    std::array<std::variant<void *, int8_t, int16_t, int32_t, int64_t, uint8_t,
+                            uint16_t, uint32_t, uint64_t>,
+               max_param>
+        params;
   };
 
 protected: