-
-
Notifications
You must be signed in to change notification settings - Fork 602
Google Summer of Code 2015
For this year, we will be accepting applications for both OSv itself, and Seastar, our newly released framework for writing asynchronous and non-blocking applications. If you want to know more about Seastar, take a look at seastar's website. Note that for development simplicity, much of seastar's functionality is available on Linux. If you select a Seastar project, chances are you can code most of your project without using OSv at all. You will, however, be required to demonstrate your final deliverable running on OSv.
(Details needed -- something like this https://www.usenix.org/legacy/events/usenix05/tech/freenix/full_papers/hensbergen/hensbergen_html/index.html for OSv?)
OSv is implementing the POSIX API layer on a need-to-do basis. The first task of porting a new runtime is identifying which calls are needed for go that are not implemented by OSv, and then of course, implementing them.
Currently, OSv’s Xen support is restricted to HVM guests, which means hardware virtualization extensions are needed. However, that is not Xen's main mode of operation. The student tackling this project will need to implement all the relevant hypercalls that will enable OSv to boot on top of Xen, and also make sure his implementation is efficient Difficulty: Medium
Due to initial technical constraints, OSv does not have the ability to run an ELF binary. We have our own ELF loader and from there, we execute a shared object (.so). While this works, this means native compiled applications that wants to be ran on OSv need to be recompiled as a shared library. It is technically possible to lift that limitation, by: Loading a full ELF file and reading its list of mappings If the kernel mapping overlaps the binary (it probably does), remap the kernel somewhere else, where the application left a hole unfilled Audit all the places in which the kernel symbols are used directly: those places will access the old addresses, and will need to be fixed.
Difficulty: Easy to Medium
Required skills: POSIX, C++
Non Volatile Memory Express (NVMe) is a new storage technology for accessing high performance solid-state drives (SSDs). NVMe features include excellent virtualization support; it is also already supported by QEMU.
As such, NVMe is a great candidate for providing high throughput I/O to OSv instances. The student will implement an OSv driver for NVMe and test it on QEMU/KVM.
Required skills: device drivers, C++.
Difficulty: Medium
(for extreme rapid boots on VMs that do not need much storage -- Don)
novm is a new legacy-free, type 2 hypervisor for Linux, using KVM. novm exposes a flexible filesystem interface instead of virtual block devices, to make it easier to manage independent software and data bundles and combine them into a single virtual machine instance.
https://github.com/google/novm
Hyper-V is a VMM provided from Microsoft. It’s requires non-standard para-virtual drivers to run GuestOS, called “Virtual Service Client”(VSC). NetVSC is for networking, StorVSC is for block device. VSCs are communicate through VMBus, which is similar to Xen’s XenBus. Hyper-V Architecture details are here: https://msdn.microsoft.com/en-us/library/cc768520%28v=bts.10%29.aspx
OSv is implementing the POSIX API layer on a need-to-do basis. The first task of porting a new runtime is identifying which calls are needed for go that are not implemented by OSv, and then of course, implementing them.
Currently OSv kernel is always statically linked with all kernels, all features even some of them are actually never used (ex: vmware drivers never used on kvm). We need kernel build configuration system to customize build for each VM image. The target of customization is not just select drivers, we need to enable/disable network stack and ZFS, select VM image format, enable/disable REST server and CLI, specify application name, specify command line(optional). We can refer Linux kernel’s building system (we don’t have to implement menuconfig but it’s good to refer its config file), but cannot port their code since it should GPL licensed.
Currently we only supported single queue virtio-net, implement multiqueue support on it and optimize network stack for multiqueue devices.
Implement SR-IOV Virtual Function driver on OSv. ixgbevf is good choice since it’s most common.
Seastar is a novel framework, based on future and promises, asynchronous programming, and which heavily uses C++14. If you submit an application for Seastar, you will have to demonstrate that you are familiar with future and promises and assynchronous programming. You don't have to demonstrate expert levels, so if you are interested in the general topics but doesn't quite grasp the fundamentals, don't worry: feel free to read about it, go through the code, and drop questions at the mailing list. But we expect all of that to happen before the selection deadline.
Currently the Seastar networking stack supports IPv4 only. The project will extend it to support IPv6 packets and IPv6 configuration protocols.
Required skills: ipv4, ipv6, general networking, C++14.
Difficulty: Medium
Add support for multiple NICs in the same seastar application, including routing.
Non Volatile Memory Express (NVMe) is a new storage technology for accessing high performance solid-state drives (SSDs). NVMe features include strong support for kernel bypass technologies and excellent multi-core support.
Seastar is a user-space server application framework that achieves high performance via a share-nothing SMP model and using kernel bypass for I/O.
As such, the two technologies are well suited for each other. The student will develop an NVMe driver for seastar and measure its performance on cloudius-provided hardware.
Required skills: device drivers, C++14.
Difficulty: Medium
We would like to have applications that demonstrate the potential for performance and scalability of the seastar framework.
We currently have a version of memcached and a simple httpd that serves requests from memory. Both perform better than their standard counterparts.
Possible ideas include: extending httpd to be a fully-featured http server, ... , or coming up with an application on your own. A streaming server, a proxy, or anything that is expected to handle an abnormally high number of transactions.
Please be as descriptive as possible. Your proposal should include:
Difficulty Level: application-dependent
Skills required C++14 + other application-dependent.