Marco Liess, M.Sc.

With the advent of research on the next generation of
mobile communications 6G, we are engaged in exploring
architecture extensions for Smart Network Interface Cards
(SmartNICs). To enable adaptive, energy-efficient and
low-latency network interfaces, we are prototyping a
custom packet processing pipeline on FPGA-based NICs,
partially based on the open-nic project
(https://github.com/Xilinx/open-nic).

To test the performance of a SmartNIC-assisted server
under peak loads and achieve precise measurements of
key performance indicators (KPIs) such as throughput and latency, an FPGA-based Network Tester for 100 Gbps links shall be implemented and tested. For this, the Alveo U55C FPGA-based SmartNICs shall be used. With packet generation and throughput and latency measurements in hardware, maximum performance and precision should be reached.

The goal of this work is to implement the required logic modules in HDL (Verilog), integrate these modules into the OpenNIC Shell platform and test the design on the Alveo U55C FPGAs. Additionally, a software-interface to control the network tester can be developed, building up on a previous 10 Gbps Network Tester design. The design should also be evaluated regarding the performance of the packet generation as well as the precision in throughput and latency measurement.

• Programming skills VHDL/Verilog and C (and Python)
• Good Knowledge of computer networks, OSI layer model and protocols
• Comfortable with the Linux command line and bash
• Preferably practical experience in FPGA design and implementation

eBPF (extended Berkeley Packet Filter) is a technology used in Linux for running user-defined sandboxed programs in the kernel without changing kernel source code or loading kernel modules. In networking, eBPF can be used to redefine the network stack behavior by allowing the dynamic insertion of powerful networking and security functions deep inside the Linux kernel.

SmartNICs (Network Interface Cards with a programmable processor) can offload some processing tasks that the system CPU would normally handle. This is beneficial in freeing up CPU resources and improving networking performance. eBPF can be used in conjunction with SmartNICs to offload some network processing tasks to the SmartNIC, further enhancing performance.

The goal of this seminar topic is to provide a background overview of Linux eBPF in networking and to explore how eBPF can be leveraged in SmartNICs to improve network performance and security. Look into recent advancements, challenges, and future prospects.

With the advent of research on the next generation of
mobile communications 6G, we are engaged in exploring
architecture extensions for Smart Network Interface Cards
(SmartNICs). To enable adaptive, energy-efficient and
low-latency network interfaces, we are prototyping a
custom packet processing pipeline on FPGA-based NICs,
partially based on the open-nic project
(https://github.com/Xilinx/open-nic).

To improve the performance and energy efficiency of a
modern server, SmartNICs can be used to preprocess
incoming packets and gather characteristics on traffic and processing requirements. This information can be used to change the processing behavior of the server and react to the dynamic network and processing requirements. To do so, the server has to be notified of detected events using an interrupt.

The goal of this work is to implement hardware-based interrupt generation in an FPGA-based SmartNIC using HDL and PCIe IP cores, registering the interrupt with the Linux interrupt driver as well as writing a suitable ISR (interrupt service routine). This mechanism should be functionally verified in a hardware testbed and evaluated regarding the latency of the interrupt. Additionally, the work could be extended to include setting the core affinity of an interrupt and generating interrupts destined for specific CPU cores.

• Programming skills in VHDL/Verilog and C (and Python)
• Practical experience with FPGA Design and Implementation
• Good Knowledge of computer architecture and low-level software / drivers
• Comfortable with the Linux command line and bash

With the advent of research on the next generation of
mobile communications 6G, we are engaged in exploring
architecture extensions for Smart Network Interface Cards
(SmartNICs). To enable adaptive, energy-efficient and
low-latency network interfaces, we are prototyping a
custom packet processing pipeline on FPGA-based NICs,
partially based on the open-nic project
(https://github.com/Xilinx/open-nic).

To properly evaluate the performance of a
SmartNIC-assisted server, a webserver-based application
shall be setup in a Linux OS environment and tested with different request rates. Additionally, the performance of single- vs. multicore platforms for one and multiple webserver instances should be compared. CPU core isolation mechanisms can be used to setup such scenarios on the server.

The goal of this work is to setup a webserver (e.g. NGINX), potentially with a database backend (e.g. MongoDB) and develop a measurement and testing methodology for performance benchmarking of a SmartNIC-assisted server. This includes throughput and latency measurements, as well as analysis of the CPU and network utilization.

•     Programming skills C and Python
•     Good Knowledge of computer networks, OSI layer model and protocols
•     Comfortable with the Linux command line and bash
•     Preferably experience with Linux drivers and low-level software

With the advent of research on the next generation of
mobile communications 6G, we are engaged in exploring
architecture extensions for Smart Network Interface Cards
(SmartNICs). To enable adaptive, energy-efficient and
low-latency network interfaces, we are prototyping a
custom packet processing pipeline on FPGA-based NICs,
partially based on the open-nic project
(https://github.com/Xilinx/open-nic).

Incoming packet flows should be differentiated and differently
processed, which is typically solved with match-action tables (MATs).
MATs match on a certain packet condition (e.g. packet header 5-tuple) and execute an according action (e.g. dropping, forwarding or modifying the packet). A recent Xilinx IP core implements MATs that can be programmed with P4, a programmable packet processing language gaining momentum in networking. The goal of this work is to investigate the implementation of MATs in hardware, integrate them into our current HDL design based on open-nic and test and evaluate the results.

•     Programming skills in VHDL/Verilog and C (and Python)
•     Practical experience with FPGA Design and Implementation
•     Good Knowledge of computer networks, OSI layer model and protocols
•     Preferably basic knowledge of P4 packet processing language

Im industriellen Umfeld werden Informationen zunehmend in visuellen Codes (z.B.
Strichcodes, QR-Codes) zur automatisierten Verarbeitung abgelegt. Steigende
Durchsatzzahlen stellen immer höhere Anforderungen an die Geschwindigkeit der
Datenverarbeitung.
In dieser Arbeit soll anhand eines kostengünstigen kommerziell erhältlichen Multicore-
Systems untersucht werden, inwieweit bisher durch Hardware realisierte
Verarbeitungsgeschwindigkeiten durch Parallelisierung der Auswertungsschritte in CPU-Systemen erreicht, werden können.
Insbesondere soll untersucht werden, ob spezialisierte Co-Prozessoren (z. B. Vector
Processing Units (VPUs)) zur Beschleunigung beitragen können oder wie diese auf die Aufgabe hin optimiert gestaltet werden können (Application-Specific Instructionset
Processor (ASIP)).

Linux is one of the most utilized Operating Systems in Embedded Systems and Cloud
Infrastructure worldwide. Sustainability will become more relevant in the future and saving power is a crucial aspect. This shows the increasing importance of efficient Linux Power Management.

The Power Management in Linux is implemented in several kernel subsystems correlating to hardware characteristics, like P-States (Frequency Scaling) and C-States (Sleep States). This thesis examines the Idle Power Management of Linux, and therefore focuses on C-States. C-States are per Core states and allow parts of the core to shut down individual features. Each processor implements C-States in different ways. Increasing C-State number, e.g. C6, translate to a deeper sleep with lower energy consumption and higher power-on reaction time.

The recently released eBPF functionality makes the kernel more programmable, bypassing the original monolithic characteristics. This mechanism can be divided into four components: the eBPF hooks in the kernel, the interfaces, the in-kernel eBPF infrastructure to execute eBPF bytecode and compile into native code and verify the code and finally the eBPF application itself, which can be written in a C like dialect and compiled into eBPF bytecode by LLVM and GCC.

This thesis aims to analyze and compare the idle governors in the current Kernel in specific situations. It also should provide insight in the C-State usage depending on the architecture. The data is acquired using specific Tracepoints within the Kernel, which can be recorded and parsed with the Kernel Tool perf. Furthermore, we explore the feasibility of a custom eBPF powered idle governor.