Explore Projects

<p>QEMU supports exposing block devices to the guest OS over the virtio-scsi protocol. Currently, this is implemented using C code running in the main QEMU process. There is also support for using an external backend over vhost-user-scsi, but the existing backend is implemented in C, and is fairly limited, only supporting iSCSI.</p> <p>The goal of this project is to implement an alternate vhost-user-scsi backend in Rust. This would provide benefits to security, reusability, and performance.</p>

<p>QEMU uses a single-threaded tiny code generator (TCG) which translates instructions of the guest ISA to instructions of the host ISA. These translated instructions are then executed on the host in an execution thread. For SMP guests, this single thread is scheduled to execute translated instructions of all the CPUs in a round robin manner. This is a significant performance bottleneck in utilizing all the available cores on the host machine. Multi-threaded TCG (MTTCG) project was started to solve this problem by designing and implementing a multi-threaded TCG. In this design, multiple threads are concurrently scheduled, and each thread executes the translated instructions from one guest CPU. Various consistency issues were identified in this design and the current work aims to solve them.</p>

This project aims to enhance QEMU's HP PA-RISC emulation by implementing LASI Network Card and NCR 710 SCSI Controller device models. LASI Network Card: Debug, test and complete the current Intel 82596 based implementation to provide full functionality NCR 710 SCSI Controller: Develop a new, accurate QEMU device model based on documentations present. Deliverables: Fully functional LASI Network Card and NCR 710 SCSI Controller models.

Virtiofs is a shared file system that lets virtual machines access a directory tree on the host. Unlike existing approaches, it is designed to offer local file system semantics and performance. Currently, virtiofsd integrates the sandboxing code and the server code in a single binary. The goal is to extract that code and create an external tool that creates a sandbox environment and runs virtiofsd in it. This will make it easier to develop sandboxing features and virtiofsd side by side. In addition, that tool should be extended to be able to run virtiofsd in a restricted environment with Landlock. Landlock is a Linux kernel module that allows unprivileged processes to restrict their own access rights. This will enable the tool to apply access restrictions to virtiofsd without requiring privileged access, in a way that is enforced by the kernel, thereby increasing the protection of virtiofsd users. This will allow greater flexibility when integrating virtiofsd into a VMM or running it inside a container, due to how Landlock enforces access restriction rules as composable security layers that are compatible with system access controls.

Improving the testing system of the Kiwix Android app to make tests more stable, faster, and reliable. This includes fixing flaky tests, improving CI/CD performance, and ensuring testing reflects real-world usage conditions.

The "Market Rewards Toolkit" project seeks to develop a comprehensive toolkit for harvesting market rewards from diverse investments, extending functionalities beyond existing R packages like FactorAnalytics and PerformanceAnalytics. It will enable users to construct factors for analysis, forecast returns, assess asset class returns and investment strategies, and analyze risk factors' impact. Challenges such as data quality and task complexity will be addressed through thorough data validation, task breakdown, and a contingency plan for unforeseen delays. Spanning 3 months, the project will undergo phases of initial development, testing and refinement, and finalization and documentation, ensuring regular code submissions, testing, and documentation for steady progress. Effective project management strategies include daily commits, task breakdown, regular code submissions and reviews, continuous testing, and version control systems. Ultimately, the project aims to deliver an advanced toolkit for factor analysis in investment returns, enhancing decision-making capabilities in the financial industry.

<p>I/O throttling is currently hard-coded in QEMU. A request is checked for throttling directly in block-backend.c instead of having a filter driver process every I/O request for throttling during the walk in the BlockDriverState graph. Throttling can become modular by being utilised with a filter block driver.</p> <p>Add before write notifying (bdrv_add_before_write_notifier: which is used in backup_run for backups) is also hard-coded.</p>

Cyfra is a GPU runtime and a DSL that makes Scala a viable choice for GPU programming. Currently, the Scala ecosystem does not have an easy-to-use library for doing general computations on the GPU. Cyfra aims to fill this gap. Goal of the project is to implement support for GPU computations on data streams, with focus on usability, and integration with the popular fs2 (Functional Streams for Scala) library, which is used widely in the Scala ecosystem. Cyfra should enable developers that do not have background in GPU programming to write a simple data processing pipeline in Cyfra that performs compute on GPU and efficiently manages memory. The pipeline should be interoperable with fs2. Integrating Cyfra's pipeline with fs2 will also make it compatible with major Scala open source libraries, opening them up to execution on the GPU.

<p>The implementing serial tablet would allow to have mouse integration for vintage operating systems. This feature is absent in other virtualisation systems, as far a I know. Emulating additional character device with absolute coordinates – the one which was rather popular in 1990x– would allow us to use already existing drivers for old operating systems without USB support and so such device would bring mouse integration to them.</p>

The problem I aim to solve is the inefficiency in searching for specific Scala code information, particularly within Scaladoc documentation. Currently, developers often face challenges navigating external websites or manually sifting through code. To address this issue, I propose to integrate Scaladoc search functionality into Protosearch, a documentation search tool. By leveraging existing data structures and indexing/querying mechanisms in Protosearch, I plan to develop a Scaladoc Parsing Module to extract relevant metadata from Scaladoc comments and an Indexing Module to organize and store Scaladoc content for efficient search operations. The deliverables of this project include: 1. Scala Doc Parsing Module: Develop a module to access Scaladoc data in a structured way using tools like Scalameta 2. Scala Doc Indexing Module: Create a module to process and index Scaladoc content into Protosearch's existing data structures 3. User Interface Enhancements: Design and implement user interface enhancements within Protosearch to support Scaladoc search functionality, ensuring a seamless and intuitive search experience for developers. 4. Comprehensive Documentation: Document the implementation details, usage, and maintenance of the Scaladoc search feature, providing clear instructions for developers on how to utilize the functionality within Protosearch.

Add a new virtual device to QEMU to interface with a custom snapshot/restore functionality. Modified memory is kept track of by instrumenting the TCG store instructions. The virtual device will be designed for easy integration with a fuzzer, such as AFL.

<p>case classes are a very useful feature of the scala language, but can be limiting. For example, there is no way to modify the internal representation of a case class, leading to heap usage problems for larger applications that generate hundreds of millions of instances. And this projects aims to make case classes more flexible and optimized, in the same time giving a developer way to turn on/off all the options thus adjusting case classes for his needs.</p>

<p>The aim of the project is to build a Text User Interface(TUI) for issuing and receiving QEMU Monitor Protocol (QMP) commands from a running QEMU instance.</p>

<p>Scala-offheap is an experimental project which provides type-safe off-heap memory management for Scala language. The goal of this project is to expose the full potential of Scala off-heap collections by expanding the existing functionality of Array combinator methods and providing an efficient implementation of the off-heap Set and Map classes.</p>

Virtio-fs is a shared file system that lets virtual machines access a directory tree on the host. Virtiofsd is the user-level host daemon that communicates with the guest VMs and performs I/O operations on the shared directory tree. Currently, virtiofsd processes FUSE-based I/O requests in a mostly sequential manner. Even though it uses a thread pool, concurrency is limited by the number of available threads. This project aims to enable truly asynchronous I/O request handling in virtiofsd by leveraging io_uring. The deliverables will include a complete patch implementing asynchronous I/O handling, along with a performance evaluation of the resulting system.

The current state of the asynchronous I/O on the JVM involves using separate selector threads to manage I/O events through system functions like epoll or kqueue. Although frameworks like Netty and NIO2 make this approach seem reasonable, the use of separate event loop threads is not without cost. In high-RPS services, these threads can compete for CPU time with worker threads executing application tasks, leading to resource contention and potentially significant performance loss. In contrast, Cats Effect offers a different threading model, integrating I/O and application tasks into a single runtime system, reducing contention an enhancing overall efficiency. io_uring, the key component of this project, offers two major advantages: (1) it enables all supported syscalls to become asynchronous from the application’s perspective, allowing for multiple syscalls to be initiated in parallel without blocking the calling thread, and (2) it uses a pair of ring buffers for syscall submission and completion events that are shared between the application and the kernel, dramatically reducing the overhead of calling from userspace into kernelspace. When integrated with Cats Effect, io_uring can significantly improve the efficiency of syscalls, requiring fewer calls into kernelspace during the worker loop. This proposal brings two key innovations together: a new threading model and a new I/O API. By integrating Cats Effects and FS2 with io_uring, we aim to develop an alternative solution to minimize the inefficiencies found in the traditional model, offering a more efficient and performant solution for I/O-intensive applications.

<p>This project targets at enabling the current RoboSherlock to work in form of parallel pipeline, which also includes merging results of different camera configurations. In this proposal, I present my plan, methods, timeline and some related experience.</p>

Cyfra is a GPU runtime and DSL that simplifies GPU programming in Scala by abstracting Vulkan. This project will build a real-time rendering pipeline with outputs to a window, data stream, and file. Deliverables include high-level GPU APIs, GLFW integration, efficient swap chain/synchronization, and clear documentation with examples—making high-performance graphics more accessible to Scala developers.

<p>One of the most important steps in tuning an emulator performance is to identify which are the hot regions and to measure their translation quality. However, in QEMU, there is no easy way to identify hot TBs. Therefore, we propose in this project the enhance of QEMU log system to add these capabilities. Our plan is to add three new capabilities to QEMU: (1) to profile and list hot emulated blocks, (2) to calculate global and per block translation quality statistics, and (3) to allow all these inspections to be done in an interactive mode in the monitor tool.</p>

This project aims to migrate the existing Scala documentation website from Jekyll to Scaladoc. This migration will provide a more streamlined, modern, and easily maintainable documentation experience that is tightly integrated within the Scala ecosystem. I will focus on replicating key Jekyll features, such as the "include" mechanism and custom tabs, using the "liqp" library within the Scaladoc framework. Existing content (Markdown, HTML, CSS) will be carefully adapted, and styling will be applied to match the look and feel of the current website. If time permits, I will explore additional customizations to Scaladoc's default output for greater layout flexibility. The key deliverables of this project include a functional MVP website, replicated Jekyll functionality, and comprehensive documentation of all implemented features.

<p>In GSoC, I propose to introduce deep learning annotators in RoboSherlock for more various task. Because many deep learning frameworks and repositories are written in Python, I first improve RoboSherlock system to be able to run annotators written in Python. Then, I implement annotators using deep learning such as object detection, semantic segmentation, instance segmentation and so on into RoboSherlock system. As the final result of the project, the real robot execute a manipulation task with the deep-learning annotators. The main contributions of my proposal will be as belows:</p> <ul> <li>Improve Robosherlock to execute annotators written in Python</li> <li>Introduce several useful deep-learning annotators in Robosherlock</li> <li>Implement the new annotators in daily-life task with real robot</li> </ul>

This project extends QEMU FUSE export with support for FUSE-over-io_uring, a modern Linux interface that enables asynchronous, high-performance communication between FUSE daemons and the kernel. Unlike the traditional /dev/fuse path, io_uring reduces system calls, supports batching, and lowers CPU overhead. This project will integrate FUSE-over-io_uring into QEMU as an optional mode, enabling more efficient access to disk image contents through the FUSE export. The work includes implementing queue setup and negotiation with the kernel, supporting multiple inflight FUSE requests, enabling multi I/OThreads, and benchmarking performance using fio. Deliverables include: FUSE-over-io_uring support in QEMU Multi-inflight and multi-IOThread support Performance benchmarks Documentation

<p>Zero-configuration communication between the QEMU hypervisor and its guests can be achieved using the virtio-serial device. Virtio-serial has several limitations though. For example, it does not allow multiple connections to the same port. To overcome this limitations the driver virtio-vsock has been developed.</p> <p>The virtio-vsock driver supports the POSIX Sockets API which is more familiar to developers wanting to perform communication between processes. The Sockets API allows N:1 communication and differentiates between block and stream protocols. In addition, programs that already use sockets can easily transition to the virtio-vsock device without major changes in their code.</p> <p>However, the traffic sent through virtio-vsock is hidden to the outside world, as it is internally performed between the hypervisor and the driver. And to facilitate debugging is important to be able to see this exchange of information.</p> <p>The goal of this project is to expose the traffic exchanged through the virtio-vsock socket interface so that programs like Wireshark can capture it. To achieve this, it would be necessary to implement a device driver that exposes the traffic and a Wireshark dissector.</p>