Projects

[Performance/eBPF] Performance Modeling of eBPF Programs (Tao Lyu)

eBPF enables 1) customizing the policies of kernel subsystems (e.g., scheduling policy, page eviction policy) and 2) offloading application logic to the kernel as a fast path. In both scenarios, eBPF programs (also known as kernel extensions) reside at the performance-critical paths. Therefore, they should be as performant as possible. Otherwise, eBPF programs can be counterproductive: instead of improving kernel performance, they actually degrade it.

Unfortunately, performance issues are common because (1) eBPF applications are updated frequently, often without rigorous performance review, making them more error-prone; and (2) many eBPF developers aren’t kernel experts and lack familiarity with the performance characteristics and micro-optimizations of hot kernel paths. Unlike safety, which the eBPF verifier forcefully guarantees, the ecosystem overlooks this equally important concern: performance due to the overshadowed of the focus on safety.

In this project, we call on the community to also focus on the performance clarity of eBPF programs. Ideally, in this project, we aim to design a scalable and accurate performance model for eBPF programs. This model, acting as a building block, can further be utilized in various use cases, including:

• Performance quantification: Quantify the performance of each line of programs with explanations to help people understand their performance.
• Performance debugging: based on the performance quantification, either manually or semi-automatically adjust programs to achieve better performance.
• Performance check: Check the new program’s performance against that of functionally equivalent baselines, serving as oracles. This performance check is optional for developers, rather than being mandatory like the safety verification.

Targeting students who want to do a thesis or long-term research.

[Memory Management] Memory allocators in tiered memory (Musa Unal)

Memory management is a critical component of operating systems. Modern data centers rely on different types of memory (with different latency and bandwidth) to manage data, which is also referred as tiered memory. This project aims to understand how profiling can help identify optimal allocation sites in tiered memory.

In this project, you will:

• Learn how PGO (Profile-guided optimization) can help an application to improve it's performance.
• Learn how memory allocators works and manage the data.
• Understand how CXL (Compute Express Link) works.

Prerequisite:

• Have a basic understanding of how operating systems work.
• Understanding C/C++

References:

• https://dl.acm.org/doi/abs/10.1145/3582016.3582063
• https://dl.acm.org/doi/pdf/10.1145/3600006.3613157
• https://dl.acm.org/doi/pdf/10.1145/3461648.3463844

[Memory Management] Energy consumption in tiered memory (Musa Unal)

Memory management is a critical component of operating systems. Modern data centers rely on different types of memory (with different latency and bandwidth) to manage data, which is also referred as tiered memory. This project aims to understand the trade-offs between energy consumption and performance in tiered memory.

In this project, you will:

• How Linux's memory tiering system works.
• Understand how to measure energy consumption in memory tiering.
• Understand how CXL (Compute Express Link) works.

Prerequisite:

• Have a basic understanding of how operating systems work.
• Understanding C/C++

References:

• https://dl.acm.org/doi/abs/10.1145/3582016.3582063
• https://docs.kernel.org/scheduler/sched-energy.html

[Scalable OS] Linux Kernel Data Structure Switching (Vishal Gupta)

The Linux kernel uses multiple data structures across different subsystems to store data. This includes linked list, hash table, red-black tree and maple tree. However, based on different access patterns these data structures might not be optimal.

In this project, you will:

• Implement mechanisms to switch between different kernel data structures.
• Implement policies to decide when to switch.

Prerequisite: Understanding of kernel data structures.

• Linked list: https://github.com/torvalds/linux/tree/master/include/linux/list.h
• Hash Table: https://github.com/torvalds/linux/tree/master/include/linux/hashtable.h
• Red-Black Tree: https://github.com/torvalds/linux/tree/master/include/linux/rbtree.h
• Maple Tree: https://github.com/torvalds/linux/tree/master/include/linux/maple_tree.h

[Scalable OS] Faster Uprobes using User Mode eBPF (Kumar Kartikeya Dwivedi)

BPF based tracing is used to execute programs and collect data when certain functions are triggered in the kernel. The same is possible in user space using the ‘user probes’ feature, where programs are executed when USDT probes are triggered within the user space applications. However, currently the implementation of uprobes requires trapping in to the kernel whenever an event occurs, leading to slowdowns in applications, and being up to 2x slower than system call context switches. This project explores whether the inception of a new ‘user mode eBPF’ mode and making uprobes execute such program types in user space will be faster and have the same level of usability. The ideal end goal would be to attain transparent 100% compatibility with the current uprobe mechanism.

In this project, you will:

• Develop a deep understanding of the eBPF verifier’s static analysis process.
• Create a new ‘user mode eBPF’ program type for eBPF.
• Measure and benchmark usability and performance differences between the current uprobe mechanism and the one based on user mode eBPF.

Prerequisite:

• A basic level of understanding of eBPF.
• Proficiency in C and Python.

References:

• https://lwn.net/Articles/753601
• https://lore.kernel.org/bpf/20211116013041.4072571-1-andrii@kernel.org
• https://www.brendangregg.com/blog/2015-06-28/linux-ftrace-uprobe.html

[Systems for ML] Improving the performance of ML workloads (Yueyang Pan)

ML workloads are at the center stage of the 21st century computing evolution. However, software that runs them is not entirely efficient. Thus, to efficiently utilize current hardware, whether for inference or training, within a single machine or across machines, we need to understand and redesign the current software stack.

In this project, you will:

• Analyze and understand the overhead current software stack.
• Do a complete breakdown of the cost associated within a single machine and across machines for both inference and training.
• Propose a set of optimizations that improves such systems performance.

Prerequisite:

• Using existing ML software.
• Basics about ML algorithms.

You will learn:

• Understanding the performance of software systematically.

In case you have projects that are not mentioned above but fall under the purview of our group's interest, feel free to contact us.