rFaaS: RDMA-Enabled FaaS Platform for Serverless High-Performance Computing

A high-performance FaaS platform with RDMA acceleration for function invocations.

The cloud paradigm Function-as-a-Service (FaaS) provides an ability to execute stateless and fine-grained functions on elastic and ephemeral resources. However, serverless struggles to achieve the performance needed in high-performance computing: slow invocations, low network bandwidth, and the overheads of the FaaS management system make it difficult to incorporate serverless functions when every millisecond counts. Therefore, we decided to combine the best of both worlds: elasticity of FaaS and high-performance of cluster batch systems. We built a new FaaS platform with RDMA-accelerated network transport.

rFaaS is a serverless platform redesigned to support high-performance and low-latency invocations with a direct RDMA connection. In rFaaS, the centralized schedulers and API gateway are replaced with a decentralized allocation mechanism. Instead of using a traditional cloud trigger, HPC applications query executor servers, obtain resource allocation and establish RDMA connections to remote workers. Every function is invoked by writing input data directly to the memory of the worker. This allows us to achieve a single-digit microsecond hot invocation latency - hot invocations add less than 350 nanoseconds overhead on top of the fastest available network transmission.

To use rFaaS, please read the documentation on software and hardware requirements, installation instructions, and the basic example of using rFaaS. rFaaS comes with a set of benchmark applications and tests. We provide an extended set of C++ serverless functions, including multimedia and ML inference examples from the serverless benchmarking suite SeBS. Finally, you can find more details about rFaaS in the documentation on the system and the client rFaaS library.

Do you have further questions not answered by our documentation? Did you encounter troubles with installing and using rFaaS? Or do you want to use rFaaS in your work and you need new features? Feel free to reach us through GitHub issues or by writing to marcin.copik@inf.ethz.ch.

Paper

When using rFaaS, please cite our arXiv paper preprint, and you can find more details about research work in this paper summary. You can cite our software repository as well, using the citation button on the right.

@inproceedings{copik2023rfaas, title={{r}FaaS: Enabling High Performance Serverless with RDMA and Leases}, author={Marcin Copik and Konstantin Taranov and Alexandru Calotoiu and Torsten Hoefler}, year={2023}, series = {IPDPS '23}, booktitle = {Proceedings of the 37th IEEE Interational Parallel and Distributed Processing Symposium}, eprint={2106.13859}, }

Requirements

Hardware rFaaS supports SoftROCE and RoCE RDMA NICs with the help of ibverbs. Evaluation and testing with IB fabric is currently in progress.

In future versions, we plan for rFaaS to support Cray interconnect through libfabric and its ugni provider.

Software Currently, rFaaS works only on Linux systems as we realy heavily on POSIX interfaces. We require the following libraries and tools:

• CMake >= 3.11.
• C++ compiler with C++17 support.
• libibverbs with headers installed.
• librdmacm with headers installed.

Furthermore, we fetch and build the following dependencies during CMake build - unless they are found already in the system.

• spdlog 1.8
• cereal 1.3
• readerwriterqueue 1.0.6
• pistache 0.0.5
• cxxopts
• googletest

Containers rFaaS supports two types of function executors - a bare-metal process and a Docker container. For Docker, we use the SR-IOV plugin from Mellanox to run Docker-based function executors with virtual NIC device functions. Please follow Mellanox documentation and instructions to install and configure the plugin. rFaaS expects that docker_rdma_sriov binary is available in PATH.

In future versions, we plan to support Singularity containers and offer a simpler, but less secure Docker networking.

Installation

To build rFaaS, run the following CMake configuration:

bash cmake -DCMAKE_CXX_COMPILER=<your-cxx-compiler> -DCMAKE_BUILD_TYPE=Release <source-dir> cmake --build .

To enable more verbose logging, change the CMake configuration parameter to: -DCMAKE_BUILD_TYPE=Debug.

The CMake installation has the following optional configuration parameters.

| Arguments | | |-------------------------------------------------------------------|----------------------------------------------| | WITHEXAMPLES | EXPERIMENTAL Build additional examples (see examples subsection for details on additional dependencies). | | WITHTESTING | EXPERIMENTAL Enable testing - requires providing JSON testing configuration as the value of this flag. See testing subsection for details. | | CXXOPTSPATH | Path to an existing installation of the cxxopts library; disables the automatic fetch and build of the library. | | SPDLOGPATH | Path to an existing installation of the spdlog library; disables the automatic fetch and build of the library. | | LIBRDMACM_PATH | Path to a installation directory of the librdmacm library. |

Usage

To learn how to use rFaaS, please follow the tutorial

For an in-depth analysis of each component and their configuration, please look at the system documentation.

Authors & Contributors

• Marcin Copik (ETH Zurich) - main author.
• Konstantin Taranov (ETH Zurich) - troubleshooting and optimizating RDMA.
• Marcin Chrapek (ETH Zurich) - libfabrics port and support for Cray GNI.
• Nicolò Monaldini (University of Bologna) - improvements to build and RDMA toolchains.