Libfabric refactor with curiously recurring template pattern

.gitignore

@@ -0,0 +1,54 @@
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# CMake
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+bin/
+configuration/
+volumes/
+containers/config/htpasswd
+
+benchmarks/warm_benchmarker
+benchmarks/parallel_invocations
+benchmarks/cold_benchmarker
+benchmarks/cpp_interface

CMakeLists.txt

@@ -62,6 +62,30 @@ else()
   set(RFAAS_WITH_TESTING OFF)
 endif()
 
+###
+# Select the networking support
+###
+option(WITH_LIBFABRIC "Enable libfabric backend instead of ibverbs" Off)
+if(${WITH_LIBFABRIC}) 
+  message(STATUS "Enabling libfabric support")
+  add_definitions(-DUSE_LIBFABRIC)
+endif()
+option(WITH_GNI_AUTH "Enable the GNI authentication backend" Off)
+if(${WITH_GNI_AUTH})
+  message(STATUS "Enabling the GNI authentication backend")
+  add_definitions(-DUSE_GNI_AUTH)
+endif()
+
+###
+# Select whether we should compile the MPI scalability experiment
+###
+option(WITH_SCALABILITY "Compile the scalability experiment" Off)
+if(${WITH_SCALABILITY})
+  message(STATUS "Enabling the compilation of the scalability experiment")
+  add_definitions(-DWITH_SCALABILITY)
+  find_package(MPI REQUIRED)
+endif()
+
 ###
 # Optional: use existing installations
 ###
@@ -81,18 +105,39 @@ endif()
 ###
 # threads
 ###
+set(CMAKE_THREAD_LIBS_INIT "-lpthread")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+set(CMAKE_HAVE_THREADS_LIBRARY 1)
+set(CMAKE_USE_WIN32_THREADS_INIT 0)
+set(CMAKE_USE_PTHREADS_INIT 1)
 set(THREADS_PREFER_PTHREAD_FLAG ON)
-find_package(Threads)
+find_package(Threads REQUIRED)
 
 ###
-# librdmacm
+# Networking
 ###
 find_package(PkgConfig REQUIRED)
-pkg_check_modules(rdmacm REQUIRED IMPORTED_TARGET librdmacm)
-###
-# libibverbs
-###
-pkg_check_modules(ibverbs REQUIRED IMPORTED_TARGET libibverbs)
+if (${WITH_LIBFABRIC})
+  ###
+  # libfabric
+  ###
+  pkg_check_modules(fabric REQUIRED IMPORTED_TARGET libfabric)
+  if (${WITH_GNI_AUTH})
+      ###
+      # cray-drc (aka rmda-credentials)
+      ###
+      pkg_check_modules(drc REQUIRED IMPORTED_TARGET cray-drc)
+  endif()
+else()
+  ###
+  # librdmacm
+  ###
+  pkg_check_modules(rdmacm REQUIRED IMPORTED_TARGET librdmacm)
+  ###
+  # libibverbs
+  ###
+  pkg_check_modules(ibverbs REQUIRED IMPORTED_TARGET libibverbs)
+endif()
 
 ###
 # pistache
@@ -112,14 +157,28 @@ add_library(rdmalib STATIC ${rdmalib_files})
 add_dependencies(rdmalib spdlog)
 add_dependencies(rdmalib cereal)
 target_include_directories(rdmalib PUBLIC "rdmalib/include")
-target_include_directories(rdmalib SYSTEM PUBLIC $<TARGET_PROPERTY:PkgConfig::rdmacm,INTERFACE_INCLUDE_DIRECTORIES>)
-target_include_directories(rdmalib SYSTEM PUBLIC $<TARGET_PROPERTY:PkgConfig::ibverbs,INTERFACE_INCLUDE_DIRECTORIES>)
+if( ${WITH_LIBFABRIC} )
+  target_include_directories(rdmalib SYSTEM PUBLIC $<TARGET_PROPERTY:PkgConfig::fabric,INTERFACE_INCLUDE_DIRECTORIES>)
+  if( ${WITH_GNI_AUTH} )
+    target_include_directories(rdmalib SYSTEM PUBLIC $<TARGET_PROPERTY:PkgConfig::drc,INTERFACE_INCLUDE_DIRECTORIES>)
+  endif()
+else()
+  target_include_directories(rdmalib SYSTEM PUBLIC $<TARGET_PROPERTY:PkgConfig::rdmacm,INTERFACE_INCLUDE_DIRECTORIES>)
+  target_include_directories(rdmalib SYSTEM PUBLIC $<TARGET_PROPERTY:PkgConfig::ibverbs,INTERFACE_INCLUDE_DIRECTORIES>)
+endif()
 target_include_directories(rdmalib SYSTEM PUBLIC $<TARGET_PROPERTY:cereal,INTERFACE_INCLUDE_DIRECTORIES>)
 target_include_directories(rdmalib SYSTEM PRIVATE $<TARGET_PROPERTY:spdlog::spdlog,INTERFACE_INCLUDE_DIRECTORIES>)
 set_target_properties(rdmalib PROPERTIES POSITION_INDEPENDENT_CODE On)
 set_target_properties(rdmalib PROPERTIES LIBRARY_OUTPUT_DIRECTORY lib)
-target_link_libraries(rdmalib PUBLIC PkgConfig::rdmacm)
-target_link_libraries(rdmalib PUBLIC PkgConfig::ibverbs)
+if( ${WITH_LIBFABRIC} )
+  target_link_libraries(rdmalib PUBLIC PkgConfig::fabric)
+  if( ${WITH_GNI_AUTH} )
+    target_link_libraries(rdmalib PUBLIC PkgConfig::drc)
+  endif()
+else()
+  target_link_libraries(rdmalib PUBLIC PkgConfig::rdmacm)
+  target_link_libraries(rdmalib PUBLIC PkgConfig::ibverbs)
+endif()
 target_link_libraries(rdmalib PRIVATE spdlog::spdlog)
 target_link_libraries(rdmalib PRIVATE cereal)
 
@@ -138,8 +197,6 @@ target_include_directories(rfaaslib SYSTEM PUBLIC $<TARGET_PROPERTY:spdlog::spdl
 set_target_properties(rfaaslib PROPERTIES POSITION_INDEPENDENT_CODE On)
 set_target_properties(rfaaslib PROPERTIES LIBRARY_OUTPUT_DIRECTORY lib)
 target_link_libraries(rfaaslib PUBLIC rdmalib)
-target_link_libraries(rfaaslib PUBLIC PkgConfig::rdmacm)
-target_link_libraries(rfaaslib PUBLIC PkgConfig::ibverbs)
 target_link_libraries(rfaaslib PUBLIC spdlog::spdlog)
 target_link_libraries(rfaaslib PRIVATE cereal)
 target_link_libraries(rfaaslib PUBLIC dl)
@@ -212,3 +269,10 @@ if( ${RFAAS_WITH_TESTING} )
   include(testing)
 endif()
 
+if( ${WITH_LIBFABRIC} AND ${WITH_GNI_AUTH})
+  configure_file(
+    scripts/setup.sh.in scripts/setup.sh
+    FILE_PERMISSIONS GROUP_READ GROUP_WRITE GROUP_EXECUTE OWNER_READ OWNER_WRITE OWNER_EXECUTE
+  )
+endif()
+

benchmarks/cold_benchmark.cpp

@@ -1,5 +1,6 @@
 
 #include <chrono>
+#include <rdma/fabric.h>
 #include <thread>
 #include <string>
 
@@ -61,15 +62,23 @@ int main(int argc, char ** argv)
   std::vector<rdmalib::Buffer<char>> out;
   for(int i = 0; i < opts.cores; ++i) {
     in.emplace_back(opts.input_size, rdmalib::functions::Submission::DATA_HEADER_SIZE);
+    #ifdef USE_LIBFABRIC
+    in.back().register_memory(executor._state.pd(), FI_WRITE);
+    #else
     in.back().register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE);
+    #endif
     memset(in.back().data(), 0, opts.input_size);
     for(int i = 0; i < opts.input_size; ++i) {
       ((char*)in.back().data())[i] = 1;
     }
   }
   for(int i = 0; i < opts.cores; ++i) {
     out.emplace_back(opts.input_size);
+    #ifdef USE_LIBFABRIC
+    out.back().register_memory(executor._state.pd(), FI_WRITE | FI_REMOTE_WRITE);
+    #else
     out.back().register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE);
+    #endif
     memset(out.back().data(), 0, opts.input_size);
   }
 

benchmarks/cold_benchmark_opts.cpp

@@ -1,4 +1,6 @@
 
+#include <iostream>
+
 #include <cxxopts.hpp>
 
 #include "cold_benchmark.hpp"

benchmarks/cpp_interface.cpp

@@ -1,5 +1,6 @@
 
 #include <chrono>
+#include <rdma/fabric.h>
 #include <thread>
 #include <fstream>
 
@@ -68,10 +69,17 @@ int main(int argc, char ** argv)
   }
   rdmalib::Buffer<char> in(opts.input_size, rdmalib::functions::Submission::DATA_HEADER_SIZE), out(opts.input_size);
   rdmalib::Buffer<char> in2(opts.input_size, rdmalib::functions::Submission::DATA_HEADER_SIZE), out2(opts.input_size);
+  #ifdef USE_LIBFABRIC
+  in.register_memory(executor._state.pd(), FI_WRITE);
+  out.register_memory(executor._state.pd(), FI_WRITE | FI_REMOTE_WRITE);
+  in2.register_memory(executor._state.pd(), FI_WRITE);
+  out2.register_memory(executor._state.pd(), FI_WRITE | FI_REMOTE_WRITE);
+  #else
   in.register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE);
   out.register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE);
   in2.register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE);
   out2.register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE);
+  #endif
   std::vector<rdmalib::Buffer<char>> ins;
   ins.push_back(std::move(in));
   ins.push_back(std::move(in2));

benchmarks/cpp_interface_opts.cpp

@@ -1,4 +1,6 @@
 
+#include <iostream>
+
 #include <cxxopts.hpp>
 
 #include "cpp_interface.hpp"

benchmarks/credentials.cpp

@@ -0,0 +1,57 @@
+#include <iostream>
+#include "gni_pub.h"
+
+extern "C" {
+#include "rdmacred.h"
+}
+
+void assert_z(const std::string &text, const int x) {
+	if (x != 0) {
+    std::cout << "[ERROR] " << text << " failed with code " << x << "\n" << std::endl;
+    exit(1);
+  }
+}
+
+void assert_nEOF(const std::string &text, const int x) {
+	if (x == EOF) {
+    std::cout << "[ERROR] " << text << " returned EOF\n" << std::endl;
+    exit(1);
+  }
+}
+
+void assert_nNULL(const std::string &text, const void *x)  {
+	if (x == NULL) {
+    std::cout << "[ERROR] " << text << " returned NULL\n" << std::endl;
+    exit(1);
+  }
+}
+
+int main() {
+  // Acquire, grand access and save the credential
+  uint32_t credential;
+  int ret = drc_acquire(&credential, 0);
+  if (ret == 0) {
+    char buffer[11];
+    FILE *file;
+    drc_grant(credential, 28487, DRC_FLAGS_TARGET_UID);
+    snprintf(buffer, 11, "%u", credential);
+    assert_nNULL("fopen", file = fopen("credential.txt", "w"));
+    assert_nEOF("fputs", fputs(buffer, file));
+    assert_nEOF("fclose", fclose(file));
+    printf("Saved credential %s\n", buffer);
+  } else {
+    std::cout << "[ERROR] Cannot acquire the credential, failed with code" << ret << std::endl;
+    exit(1);
+  }
+
+	// Access the credential and print cookies
+  uint32_t cookie1;
+	uint32_t cookie2;
+  drc_info_handle_t info;
+  uint8_t ptag;
+	assert_z("drc_access", drc_access(credential, 0, &info));
+	cookie1 = drc_get_first_cookie(info);
+  cookie2 = drc_get_second_cookie(info);
+  GNI_GetPtag(0, cookie1, &ptag);
+	std::cout << "[INFO] Got cookies " << cookie1 << " and " << cookie2 << " with ptag " << ptag << std::endl;
+}

benchmarks/parallel_invocations.cpp

@@ -1,5 +1,6 @@
 
 #include <chrono>
+#include <rdma/fabric.h>
 #include <thread>
 
 #include <spdlog/spdlog.h>
@@ -72,15 +73,23 @@ int main(int argc, char ** argv)
   std::vector<rdmalib::Buffer<char>> out;
   for(int i = 0; i < opts.numcores; ++i) {
     in.emplace_back(opts.input_size, rdmalib::functions::Submission::DATA_HEADER_SIZE);
+    #ifdef USE_LIBFABRIC
+    in.back().register_memory(executor._state.pd(), FI_WRITE);
+    #else
     in.back().register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE);
+    #endif
     memset(in.back().data(), 0, opts.input_size);
     for(int i = 0; i < opts.input_size; ++i) {
       ((char*)in.back().data())[i] = 1;
     }
   }
   for(int i = 0; i < opts.numcores; ++i) {
     out.emplace_back(opts.input_size);
+    #ifdef USE_LIBFABRIC
+    out.back().register_memory(executor._state.pd(), FI_WRITE | FI_REMOTE_WRITE);
+    #else
     out.back().register_memory(executor._state.pd(), IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE);
+    #endif
   }
 
   rdmalib::Benchmarker<1> benchmarker{settings.benchmark.repetitions};

benchmarks/parallel_invocations_opts.cpp

@@ -1,4 +1,6 @@
 
+#include <iostream>
+
 #include <cxxopts.hpp>
 
 #include "parallel_invocations.hpp"