Aquileo | Linux Plumbers Conference: Presentation Proposals

Aquileo | Android/Mobile Wearables

2014-10-15T12:09:37-04:00

One Line Summary:: Wearables, big.LITTLE, migration

Abstract:: The Linux Plumbers 2014 Android/Mobile Wearables BoF is focusing on the ongoing integration of Android into the mainline, as well as new form factors where Android ecosystem is expanding and the new challenges arising from this. Topics this year include: android sync, moving things out of staging, LLVM, 64-bit (bionic, binder, porting…) and Big.Little.

Speaker:

Rom Lemarchand
Rom has been working in the consumer electronics industry for over 10 years. Originally working on various proprietary operating systems, he switched to Android about 5 years ago and hasn’t looked back since.

Rom joined Google in 2012 and since then has been working on lowering Android memory requirements and graphics.

Rom holds a degree in Computer Science from Universite de Rouen and a Masters in Software Engineering from Carnegie Mellon University.

Aquileo | RT Status report

2014-10-14T11:02:43-04:00

One Line Summary:: Status of the realtime project. Mini-Summit readout

Abstract:: Status of the realtime project. Mini-Summit readout

Speaker:

Thomas Gleixner
Long time Linux kernel hacker with embedded background and a strong affinity to impossible missions.

Aquileo | Avoiding some of the mmap_sem usage

2014-10-12T06:58:56-04:00

One Line Summary:: Avoiding some RT issues by avoiding mmap_sem

Abstract:: In this talk we examine the mmap_sem, a known pain point of the rt kernel. And explore possible means of avoiding it under some conditions. Most notable we examine speculative page faults.

Speaker:

Peter Zijlstra
Peter Zijlstra — Intel OTC — kernel maintainer for some, hacker for other parts.

Aquileo | SIL2LinuxMP: GNU/Linux Multicore platform for safety related systems

2014-10-12T04:35:54-04:00

One Line Summary:: Certifying GNU/Linux for safety

Abstract:

In the past decade there have been a number of key publications on using COTS, including open-source, for safety related systems. A series of UK HSE reports as well as the US FRA report looked into COTS in the safety domain.

To address this growing need, The OSADL Safety Critical Linux Working Group, founded in 2007, has been preparing an open-source project called SIL2LinuxMP striving to prepare certification of a Linux RTOS (PREEMPT_RT) based platform to a systematic capability (SC)/safety integrity level (SIL) of 2 in accordance with IEC 61508 Edition 2.

In this talk we will outline the overall SIL2LinuxMP project and then focus on the safety case development issues. With a focus on the selection of the conformance route. While such a talk can only be sketchy we do hope that it will help in clarifying the big picture of “certifying GNU/Linux for safety”.

Speaker:

Nicholas Mc Guire
Nicholas McGuire’s first contact with Linux dates back to Linux kernel version 0.99.112, at a time when many rumors and myths were circulating about the fledgling open source operating system. McGuire first came into contact with RTLinux at RTL version 0.5, in the course of developing a DSP system replacement for magnetic bearing control, at the Institute for Material Science of the University of Vienna, Austria. McGuire began developing MiniRTL while RTLinux was at version 1.1, and has been engaged in RTLinux and MiniRTL based development work ever since.

Aquileo | Read Write Semaphore bottlenecks

2014-10-12T04:21:01-04:00

One Line Summary:: Handling the difficulties of priority inheritance and Reader Writer semaphores.

Abstract:: Priority inheritance is complex and when you add boosting priority for multiple tasks the complexity increases exponentially. A previous version to attempt this was too complex to get right and was ripped out. But this was a learning experience and there are other ways to handle boosting multiple tasks with some compromises. Perhaps this is a time to revisit this method or find another method, but until Linux removes all reader writer semaphores, this will continue to cause a large gap with performance between mainline and the -rt patch.

Speaker:

Steven Rostedt
Steven Rostedt has been working with the Linux kernel since 2001. He currently works for Red Hat working in their Messaging Real-time Grid (MRG) division. He created and maintains Ftrace, the official Linux kernel tracer, and is the current real-time kernel stable maintainer.

Aquileo | What's new in the LLVM Ecosystem, and how does that affect the kernel?

2014-10-09T17:29:57-04:00

One Line Summary:: A tour of LLVM technologies, concentrating on those of interest to kernel developers.

Abstract:: LLVM is a collection of software projects, all working off of a (more or less) common code base. The best known LLVM project is “clang” the compiler. But there are many others. In this session, Marshall will take a whirlwind tour of the LLVM ecosystem, and show which parts can be used by kernel developers.

Speaker:

Marshall Clow
Marshall has been a developer for more than 30 years. He has worked on hardware (printers), drivers, utility software, end-user applications, developer tools and libraries

He currently is the “code owner” of libc++, the standard library implementation for LLVM, as well as the author and maintainer of several boost libraries. He also serves on the C++ standards committee.

Marshall is employed by Qualcomm Technologies, Inc., where he is a principal engineer.

Aquileo | Network switching offload architecture for the Linux kernel (Part II)

2014-10-09T09:07:40-04:00

One Line Summary:: Architecture discussion on how to better handle (multilayer) network switching chips in the Linux kernel and incorporate it with existing offload APIs.

Abstract:

Several types of (multilayer) switch devices currently exist of which only a subset is supported in the kernel through the existing DSA subsystem. Especially the newer devices do not fit well with the existing kernel APIs. In a related context, the availability of extended switching functionality on host NICs allows for additional offloads for existing dataplane functionality which could reuse the same set of APIs.

This BoF combines the related proposals by Shrijeet Mukherjee of Cumulus Networks and Benjamin LaHaise into a single session.

Work already performed on this particular subject includes Jiri Pirko and Scott Feldman’s NetDev proposal for a new generation of APIs to abstract the various hardware switch models.

The goal of this BoF is to combine all efforts to define and finalize the hardware packet switching offload API architecture with all common uses cases taken into account. Everybody is encouraged to present their views and raise concerns with the proposals.

Use cases to consider include:

Switch management using existing RTNETLINK interfaces
Offload of existing L2/L3 software forwarding
Switch management and offload using Open vSwitch
Offload of Classifier/Qdisc layers
Compatibility with existing FDB ioctls for SR-IOV
Offload Netfilter/nftables policy to implement port security / ACL
…

The session is moderated by John Linville and Thomas Graf.
Please send agenda proposals directly to the sessions leaders.

Speakers:

John Linville
John W. Linville is the current Linux kernel maintainer for wireless local area networking. John is employed by Red Hat, where his primary focus is wireless networking in the upstream kernel and the Fedora distribution.
Thomas Graf
Contributor to various networking related open source projects.

Aquileo | Remote Vehicle Interaction (RVI)

2014-10-08T14:11:01-04:00

One Line Summary:: RVI is an open source framework for connecting vehicles to cloud services and mobile devices that handles authentication, authorization, discovery of services and data exchange over any network topology.

Abstract:

A connected car platform that allows OEMs to easily enable value-added services themselves and through partners will benefit the ecosystem of their brands:

80% of the connected car functionality is shared across platforms – Core in-vehicle telematics and cloud backend functionality are common in architecture and similar in implementation. The remaining 20% are the services that define the user experience.

A shared, open-source platform will benefit OEMs – A joint architecture and reference implementation allows OEMs to minimize cost, eliminated vendor dependencies and mitigate security risks allowing them to focus on applications and services that offer market differentiation.

A shared, open-source platform will enable service providers – Market adoption is key to success. To attract service providers the size of the ecosystem is of significance. A common architecture allows service providers to easily port their offerings to multiple OEMs, this giving them a diversified revenue stream from multiple vendors.

A shared, open-source platform will reduce time to market – Development cycles in the automotive industry are more than twice as long as the lifespan of the average startup company. To create an innovative and fast moving market place that allows young companies to develop in-vehicle apps and their corresponding backend services on an OEM-approved platform within weeks or months and showcase the product to the OEMs.

Remote Vehicle Interaction (RVI) is an open-source project initiated by Jaguar Land Rover and hosted by AGL with the objective to develop vendor-neutral telematics framework that can easily be adopted and extended:

Pluggable Architecture – The framework follows strict “design-to-the-interface” rules. The APIs are at the center. The reference implementation is an example albeit one that strives for production quality.

Device, service and connection agnostic – Devices shall be able to access services on other visible devices regardless of device operating system and whether a connection is made directly or via Internet.

Peer-to-peer based – Devices can access services via local networks without an Internet connection.
Dynamic Provisioning – Nodes and services can be added to or removed from the system at runtime without relying on a centralized provisioning system.

Granular Authentication & Authorization – All authentication and authorization is done on the service level against certified credentials.

Service Discovery – Applications and services can discover and invoke other services.
Low-overhead Invocation – Services can be remotely invoked over sparsely connected networks.

Speaker:

Rudolf Streif
As an Infotainment Specialist for Jaguar Land Rover’s Open Source Technology Center Rudolf Streif applies open source software technology and engineering practices to next generation infotainment systems, enabling rapid development and new ecosystems.

Prior to that, as the Linux Foundation’s Director of Embedded Solutions, Mr. Streif connected companies seeking to leverage Linux and open source for embedded product development with open source communities. He has created the Automotive Linux Summit an event that brings together the most innovative minds from automotive expertise with open source software excellence. He is leading the Linux Foundation’s Automotive Grade Linux collaboration project, an initiative to advance Linux and open source in the automotive industry.

Mr. Streif is a seasoned software engineering / management executive with over 20+ years experience and expertise in embedded software and hardware engineering, product development, life-cycle management and organizational leadership. He held engineering management positions in various industries including automotive, IPTV/DVB digital television and industrial imaging. He has successfully leveraged the strengths of the Linux operating system and open source software for many demanding applications. Mr. Streif received B.Sc. and M.Sc. in Electrical Engineering and MBA from the Technical University in Munich, Germany. He is a frequent speaker at various events on Linux, open source, automotive and telematics.

Aquileo | Adding stateful features to OVS

2014-10-07T12:08:07-04:00

One Line Summary:: Discuss adding stateful features to OVS by leveraging kernel functions

Abstract:: Open vSwitch is a full-featured, multilayer virtual switch. It’s traditionally been programmed through OpenFlow, which was originally targeted at hardware switches and built around matching packet headers. New demands have necessitated keeping track of state across packets and flows. In this presentation, we look at leveraging some of the kernel’s features to enable stateful services. We will discuss the best approaches to integrate with the kernel and how to expose those services through a traditionally stateless protocol like OpenFlow. In particular, we will look at connection tracking, NAT, load-balancing, and DPI.

Speaker:

Justin Pettit
Justin Pettit is an engineer at VMware’s Networking & Security BU. Justin joined VMware through the Nicira acquisition and was a founding employee at Nicira Networks. He was one of the original authors of the OpenFlow Standard, working on both the specification and reference implementation. He is one of the lead developers of Open vSwitch and involved in the development of VMware’s other products. Prior to Nicira, Justin worked at three successful startups focused on network security.

Aquileo | Integrated Network Virtualization

2014-10-06T16:45:54-04:00

One Line Summary:: Integrated Network Virtualization is aimed at providing a minimally intrusive and highly performant network virtualization solution in the Linux stack.

Abstract:

In this talk we’ll consider the prospects of integrating networking virtualization into the Linux Networking stack in a minimally intrusive way.

Job scheduling and resource management in modern data centers is a very difficult but critical problem. Virtualizing the whole data center to allow jobs (not just VMs!) to seamlessly be migrated to optimize scheduling would be a game changer. For the networking part of this solution, we want a very lightweight solution which has no impact other than when we wish to migrate (near zero tolerance for performance regression for this function). A solution to this is to consciously integrate networking virtualization in the stack. Several
of the mechanisms that may be useful for a solution are already in place— TCP_REPAIR and network namespaces for instance. The goal is that all the existing functionality of the stack— routing, IP tables, NAT, etc.— should seamlessly be virtualization aware.

Speaker:

Tom Herbert
Senior Staff engineer @Google

Aquileo | UDP encapsulation, FOU, GUE, & RCO

2014-10-06T16:40:54-04:00

One Line Summary:: A discussion around recent work to support UDP encapsulation in the stack.

Abstract:

A discussion about recent efforts to make UDP encapsulation performant and well supported in the Linux networking stack, and also an introduction of foo-over UDP (FOU) and Generic UDP Encapsulation(GUE).

UDP based encapsulation is likely to become ubiquitous in data centers, not just for virtualization use case but also for non-virtualization. The reasons for this are simple: it’s a low overhead protocol and allows us to leverage several UDP specific optimizations commonly supported by networking hardware (RSS and ECMP for instance). In part one of this this talk, we’ll review the additions to the Linux kernel to make UDP encapsulation efficient and a first class citizen of the stack.

For part two of this discussion, we’ll look at foo-over-UDP (FOU). FOU is an encapsulation method to where IP protocol packets are directly encapsulated in a UDP payload. The first support of this is IPIP, sit, GRE tunnels which can be configured to transmit using FOU encapsulation. The GRE part implements the GRE/UDP draft.

For part three of this discussion, we’ll look at Generic UDP Encapsulation (GUE) and Remote Checksum Offload. GUE is a lightweight, extensible, and performant encapsulation mechanism of IP protocol packets (indicated in a header field). The GUE header allows for optional data fields which which we intend to use for virtualization, security, and congestion control.

Speaker:

Tom Herbert
Senior Staff engineer @Google

Aquileo | Tracing on large scale infrastructure

2014-10-06T05:18:16-04:00

One Line Summary:: How to best use tracing tools on severals thousands of servers

Abstract:

Using tracing for monitoring issues on a large scale server infrastructure can generate a huge amount of data. What are the best solution to handle that data and to analyse it to gain insight on the health of the kernel on a server fleet.
We heard of the Dapper and Zipkins solutions, is there other frameworks or simple tools to agregate the result of tracing?

Also, how can we facilitate the deployment of the tracing tools either for debugging or monitoring?

Speaker:

Yannick Brosseau
Yannick Brosseau is a Production Engineer on the Kernel team at Facebook. As such he works on improving the stability and performance of the kernels deployed on the Facebook infrastructure and develops testing, monitoring and deployment tools to help in this endeavor. Previously, he was a Research associate at École Polytechnique de Montréal where he worked on performance analysis tools for Linux. He worked on several part of the LTTng project. He was also an open source software consultant for several years and is a Fedora Packager.

Aquileo | Rich probe filtering and reporting with variable locations and types

2014-10-02T05:07:40-04:00

One Line Summary:: How to combine various mechanisms (CTF, SDT, DWARF, etc.) used by various tools to provide rich filtering and reporting of events.

Abstract:

Various observation tools use different ways to locate and access arguments and variables in scope when a probe point is hit or an event is triggered. Having the location and type of arguments and variables allows for richer filtering and reporting or user defined logging of events. Some mechanisms are tied to the way some probe mechanism is setup, others provide more generic descriptions of locations and types of variables at a particular address location. With eBPF we might be able to translate these mechanisms into efficient filters and data extraction for events used in the kernel.

I would like to go over some of the diffent mechanisms some of the tools use. Simple arch specific function arguments, CTF – Compact C Type Format used by dtrace with a experimental convertor in pahole/dwarves, (U)SDT User Static Defined Trace points with two (source compatible) implementations in dtrace and systemtap, also used by gdb and perf, and full DWARF location expressions that can be used by both user space and kernel tools. And explore why or why not these mechanisms are used by which tools.

The outcome will hopefully be a better understanding of which mechanisms are the most useful for all tools, which really won’t work in some situations and how to translate some of these into eBPF filters/functions that can be used by (all) in kernel tools.

Speaker:

Mark Wielaard
Mark works for Red Hat in the Engineering Tools group. Currently he works mostly on the elfutils and valgrind projects. He has contributed to systemtap, gdb and gcc a bit (mostly around extending DWARF support).

Aquileo | Linux Tracing Strategy

2014-10-01T20:17:28-04:00

One Line Summary:: The current state of tracing, integration between and of the tracers, and where we should be going.

Abstract:: There are many tracing options for Linux: ftrace, perf_events, SystemTap, LTTng, dtrace4linux, ktap, eBPF, and sysdig. What are we trying to accomplish — what are the end use cases for Linux tracing — and how do we get there? This may involve integration of tracers (SystemTap, LTTng), as well as integration between tracers (ktap, eBPF).

Speaker:

Brendan Gregg
Brendan Gregg is a senior performance architect at Netflix, where he does large scale computer performance design, analysis, and tuning. He is the author of the book “Systems Performance”, and recipient of the USENIX 2013 LISA Award for Outstanding Achievement in System Administration. Previously a performance and kernel engineer, his recent work includes developing visualizations, methodologies, and tools for performance analysis.

Aquileo | Sharing kernel tools code

2014-10-01T16:05:32-04:00

One Line Summary:: Making perf tools generic code available as a tools library.

Abstract:

There’s been a need to librarize some of the perf tools code
too be used by other tools, which are at the moment not
part of the kernel tree (trace-cmd, RAS Deamon).

Discuss how to handle out of tree dependency and the state
and future of the tools/lib.

Speaker:

Jiri Olsa
I work for RedHat work full time for Linux as kernel generalist engineer in Brno office, Czech Republic.
I currently divide my work time by upstream perf work and RHEL perf maintaining.

Aquileo | Processor (hardware) trace

2014-10-01T12:01:57-04:00

One Line Summary:: We have ARM CoreSight and Intel PT patches on the mailing lists. We need to find common ground for them.

Abstract:

In the last months there was some work done around hardware tracing, both on ARM and Intel platforms:

http://thread.gmane.org/gmane.linux.ports.arm.kernel/355820/
http://thread.gmane.org/gmane.linux.kernel/1771197/

It would be good to discuss how to proceed with those.

Speaker:

Paweł Moll
I’ve worked with so called “embedded Linux” for the last ten years, currently for ARM in Cambridge, UK as a kernel hacker and consultant, with main focus on developer tools, in all possible form and shape, except for compilers :-)

Aquileo | Docker and the Linux kernel

2014-09-30T18:15:35-04:00

One Line Summary:: a talk about performance, stability and commonly encountered kernel related problems when running Docker

Abstract:

Preliminary list of topics:

stability of the Docker storage drivers
performance of the storage drivers
differences between aufs, devicemapper and btrfs
btrfs performance, gotchas, problems and workarounds
kernel performance and scalability with containers
common problems and errors

Speaker:

Cristian Staretu
Docker maintainer

Aquileo | A High Performance Socket Interface in Linux

2014-09-30T15:44:09-04:00

One Line Summary:: A proposal for using hardware queues with the af_packet interface and a discussion on how to use this with existing virt interfaces.

Abstract:

AF_PACKET is a Linux interface for processing packets in user space. In this talk we will outline our code which uses techniques (direct DMA, polling mode) learned in our DPDK work to provide an interface on top of existing in-kernel drivers and the AF_PACKET sockets to support performance equivalent to similar work being done with VFIO drivers.

In this talk we would like to encourage other driver owners to support the interface. And facilitate a discussion on how to integrate this work with other components in Linux. In particular the virtio drivers could leverage the direct DMA and polling modes supported.

Patches will be submitted to netdev mailing list prior to talk.

Speakers:

John Fastabend
John Fastabend is a software engineer at Intel where he works on various networking components focusing on Linux and switch software.
John Ronciak
John Ronciak has been one of the main Open Source people within Intel LAD and currently represents LAD in a number of Intel forums regarding Open Source and Linux. John will be presenting the new LAD technology called Thunderbolt. The main points regarding the Thunderbolt within the Open Source communities and the Linux OSV’s. John is a SW Architect within LAD with over 25 years of driver writing development. John is also one of the kernel maintainers for the LAD Ethernet drivers, e100, e1000, e1000e, igb and ixgbe.

Aquileo | LXC after 1.0

2014-09-29T13:51:02-04:00

One Line Summary:: Looking at the future for LXC after the 1.0 release.

Abstract:: LXC’s first production-ready release was released back in February 2014, during this talk I’ll very briefly cover what we’ve been up to since and what are our goals for the future.

Speaker:

Stéphane Graber
Working for Canonical as part of the Ubuntu Foundations team and upstream developer for a bunch of projects such as LXC, LTSP and Upstart.

Aquileo | OVS Micro Summit Summary

2014-09-25T09:41:29-04:00

One Line Summary:: Summary of proceedings of the dataplane focused OVS micro summit on Wednesday.

Abstract:: Summary of proceedings of the dataplane focused OVS micro summit on Wednesday.

Speakers:

Thomas Graf
Contributor to various networking related open source projects.
Jesse Gross
Jesse Gross is a developer on the Open vSwitch project and original maintainer of the Linux kernel fast path. He is also the lead author of the Geneve and STT tunneling protocols, using for linking together components in network virtualization systems. Jesse is a Sr. Staff Engineer at VMware (formerly Nicira), an early contributor to many of the technologies related to software defined networking.

Aquileo | Linux packet processing performance improvements

2014-09-24T13:28:42-04:00

One Line Summary:: Discussing ongoing work to incorporate bulk transmit, lock removal, and other improvements for in-kernel packet performance.

Abstract:

In the networking Linux mailing list there has been recent work to support batch xmit routines out of the queuing disciplines and other devices. As well as support for running new queueing disciplines that require no locking.

Many of the kernel developers working in this area will be at LPC this year. This BoF provides a forum to discuss the latest improvements and proposals that have occured in previous conferences and on the mailing list. As well as share progress and results.

Blogpost on latest progress with bulking:
http://netoptimizer.blogspot.dk/2014/10/unlocked-10gbps-tx-wirespeed-smallest.html

Some reference slides from previous conferences:

Lockless qdisc slides:
http://people.netfilter.org/hawk/presentations/nfws2014/dp-accel-qdisc-lockless.pdf

10G-challenge talking about need for bulking:
http://people.netfilter.org/hawk/presentations/nfws2014/dp-accel-10G-challenge.pdf

References to mailist discussion and evolving patch sets include, (although please browse netdev mailing list for the latest relevant information)

http://lists.openwall.net/netdev/2014/09/04/86
http://www.spinics.net/lists/netdev/msg295846.html

Speakers:

John Fastabend
John Fastabend is a software engineer at Intel where he works on various networking components focusing on Linux and switch software.
Jesper Brouer
Jesper Brouer is Senior Kernel Engineer at Red Hat, and is part of the team that maintains the Linux Kernel Network Stack. He is working from the comfort of this home in Denmark, outside Copenhagen.
John Ronciak
John Ronciak has been one of the main Open Source people within Intel LAD and currently represents LAD in a number of Intel forums regarding Open Source and Linux. John will be presenting the new LAD technology called Thunderbolt. The main points regarding the Thunderbolt within the Open Source communities and the Linux OSV’s. John is a SW Architect within LAD with over 25 years of driver writing development. John is also one of the kernel maintainers for the LAD Ethernet drivers, e100, e1000, e1000e, igb and ixgbe.

Aquileo | Network switching offload architecture for the Linux kernel (Part I)

2014-09-24T09:11:29-04:00

One Line Summary:: Notes etherpad: https://etherpad.fr/p/LPC2014_NetOffload Slides: http://goo.gl/ChGFnx Architecture discussion on how to better handle (multilayer) network switching chips in the Linux kernel and incorporate it with existing offload APIs.

Abstract:

This BoF combines the related proposals by Shrijeet Mukherjee of Cumulus Networks and Benjamin LaHaise into a single session.

Work already performed on this particular subject includes Jiri Pirko and Scott Feldman’s NetDev proposal for a new generation of APIs to abstract the various hardware switch models.

Use cases to consider include:

Switch management using existing RTNETLINK interfaces
Offload of existing L2/L3 software forwarding
Switch management and offload using Open vSwitch
Offload of Classifier/Qdisc layers
Compatibility with existing FDB ioctls for SR-IOV
Offload Netfilter/nftables policy to implement port security / ACL
…

The session is moderated by John Linville and Thomas Graf.
Please send agenda proposals directly to the sessions leaders.

Etherpad: https://etherpad.fr/p/LPC2014_NetOffload
Slides: http://goo.gl/ChGFnx

Speakers:

Thomas Graf
Contributor to various networking related open source projects.
John Linville
John W. Linville is the current Linux kernel maintainer for wireless local area networking. John is employed by Red Hat, where his primary focus is wireless networking in the upstream kernel and the Fedora distribution.

Aquileo | Process isolation for autonomous driving.

2014-09-19T10:16:14-04:00

One Line Summary:: How mainline kernels support enforcement of freedom from interference between processes.

Abstract:

Linux has already made it into cars, but is currently only applied in the infotainment domain. In future car manufacturers plan to leverage Linux and its eco system also for safety relevant software, like for driver assistance and autonomous driving.

Autonomous driving functions require high-performance computing with strong safety and security demands. Such systems will consist of multiple and partially redundant software components. Therefore, one key capability of such systems is to isolate faulty or malicious behavior of individual software components from each other. Interference is for example possible through shared resources, such as caches and exhausting of kernel objects (inodes, task slots, …).

Virtualization solutions seem not appropriate because number of software components greatly exceeds available CPU cores. Further more, the nature of software algorithms requires dynamic resource allocation to software components during runtime, which is hard to achieve with full virtualization technologies.

The Linux kernel gained real-time capability through the PREEMPT_RT work and OSADL is currently pushing towards safety qualification in the SIL2LinuxMP project. Current work in the Linux community is focusing on appropriate scheduling and memory partitioning techniques.

In this topic, I like to explore capabilities and limits of the mainline Linux kernel to achieve strong process isolation fulfilling the above mentioned boundary conditions.

Speaker:

Tilmann Ochs
Software developer and strong supporter of open-source development models for automotive use-cases.

Aquileo | Encrypted VXLAN

2014-09-18T19:21:46-04:00

One Line Summary:: ideas for providing per tenant encryption of virtualized networks in the cloud

Abstract:: Physical and virtual network break-ins are two largest security threats in the cloud. Large datacenters with multiple geographical locations are the most vulnerable. Encrypting traffic at datacenter boundary might not be enough. Per tenant encryption of inner packets encapsulated in tunnel protocol like vxlan provides desired level of security. This talk describes this new protocol and proposes generalization of tunnel+encryption.

Speaker:

Alexei Starovoitov
Alexei is a distinguished engineer at PLUMgrid where he works on distributed platform, dataplane, compilers. In Linux kernel his interests are Berkeley Packet Filters and their applicability to tracing and networking. In his free time he enjoys mountain biking and backpacking.

Aquileo | Does network packet format matter?

2014-09-18T17:55:03-04:00

One Line Summary:: Ideas for solving ever growing needs of networking in the cloud and live discussion

Abstract:: Limitations of existing encapsulation protocols (VXLAN and NVGRE) brought up various extensions (GENEVE, GUE, NSH). While SW can accommodate any protocol, HW has been boxed by standards, which in turn forced SW to artificially limit itself. SW and HW will be free to innovate if we can answer questions: Why did packet format matter? Where does it still matter? What kind of HW offload model allows SW to run any network protocol on top?

Speaker:

Alexei Starovoitov
Alexei is a distinguished engineer at PLUMgrid where he works on distributed platform, dataplane, compilers. In Linux kernel his interests are Berkeley Packet Filters and their applicability to tracing and networking. In his free time he enjoys mountain biking and backpacking.

Aquileo | "Minstrel-Blues" - Practical Joint Rate und Power Control in Linux mac80211 with todays 802.11b/g/a/n Chips

2014-09-15T10:15:01-04:00

One Line Summary:: I will present the design, implemenation and performance imapct of my pratical joint rate and power control algorithm "Minstrel-Blues" within Linux mac80211 and IEEE 802.11 a/b/g/n Atheros chips.

Abstract:: Todays WiFi networks do only focus on rate control as adaptation to dynamic channel conditions. Transmit power control is
limited to a common power level with a rather fixed and high value for all outgoing packets. This leads to unnecessary high interference within the wireless network and therefore decreased overall network throughput. With Minstrel-Blues we introduce the first practical joint rate and power control algorithm in the Linus kernel. Its objective is to dynamically control the power levels of outgoing packets per communication link in such a way, that is tries to find the minimum power level needed to transmit with the same performance in terms of throughput. Our results show that in many cases we can significantly reduce transmission power levels while maintaining the same throughput per link and therefore reduce the overall interference within the network. The decreased level of interference give more transmission opportunities to other links (increased spatial reuse) and hence increases the sum network throughput. We have implemented our algorithm in Minstrel and Minstrel_HT at the mac80211 subsystem and adapted ath5k and ath9k to make use of a wide subset of Atheros chips that do provide fine grain power level settings per packet.

Speaker:

Thomas Hühn
I am a 37 years old senior researcher at Technical University of Berlin who oszillates between my home village Sundhausen & my work town Berlin.
Since 2003 I am building Freifunk mesh networks in and around my home village to get and distribute broadband Internet in our rural area.
I am an active member of Freifunk association since 10 years and since than I have planed, built and do operate a 100 nodes Freifunk network to provide internet access in 5 villages without DSL connectivity.
Within my daily job as reseearcher I focus on practical transmit power control and rate control in WiFi networks based on Openwrt Linux.

Aquileo | Standardizing privileged operations

2014-09-15T03:50:30-04:00

One Line Summary:: Discussion about standardizing how privileged operations like screenshots or registering global hotkeys can be done.

Abstract:

With wayland apps which want to do certain privileged operations, like taking a screenshot or registering global hotkey handler need to go through a privileged application, typically the compositer.

Currently desktop environments like gnome are rolling their own (dbus) based API-s for this. This is undesirable, as this means that a qt wayland app may be able to only do hotkeys under kde, and a gtk app under gnome, so we should standardize this.

Discussion points:
1) Do we agree that these things should be standardized
2) dbus-api or xdg_shell (or a new wayland proto extension)
3) Make a list of operations we want to standardize

Speaker:

Hans de Goede
Hans has been a Linux developer since 1996, working for Red Hat since 2008. He primarily works on Linux webcam support, USB redirection for virtual machines and has recently joined Red Hat’s Graphics team working on the input stack for wayland.

Hans has given talks on a variety of topics at Fosdem, Plumbers and KVM forum.

Aquileo | CPUfreq and scheduler integration

2014-09-12T16:41:07-04:00

One Line Summary:: Discussion on the state of the art regarding scheduler-driven cpu frequency transitions

Abstract:: The topic is to discuss the work done to-date by Linaro around moving cpu frequency scaling policy out of the legacy CPUfreq governors and into the scheduler. After an overview of that work we should discuss what steps must be taken to get an upstreamable solution.

Speaker:

Mike Turquette
Linux kernel hacker since 2008, I focus on upstream power management frameworks. I currently maintain the clock framework. At Linaro I am involved in integrating CPUfreq with the scheduler.

Aquileo | Exploring synergies between Linux Kernel and Xen hypervisor live patching

2014-09-11T08:24:05-04:00

One Line Summary:: A quick introduction into the design space for live patching for Xen.

Abstract:: I would like to discuss design options for Xen live patching and contrast that to Linux approaches.

Speaker:

Martin Pohlack
Martin Pohlack studied computer science at the TU Dresden, Germany,
where he received his Master in 2003 for work on real-time scheduling
of disk requests. He joined the operating system’s group of
Prof. Härtig at TU Dresden as a PhD student in 2003 and worked in the
areas of real-time systems, microkernel-based systems, and runtime
monitoring for real-time systems. Martin Pohlack joined AMD’s
Operating System Research Center to work on AMD’s Advanced
Synchronization Facility (hardware transactional memory) in 2008. In
2013, he started working for Amazon Web Services on kernel and
hypervisor topics as well as scalability and performance.

Aquileo | Ion and the DMA coherency model

2014-09-07T21:01:58-04:00

One Line Summary:: A look at ion and how it handles memory coherency

Abstract:: The Ion memory manager used by Android allows for allocation of both coherent
and non-coherent buffers. Ion’s handling of these buffers does not match with
the existing DMA framework for handling coherency which is a stumbling block
to ever moving Ion out of staging. The focus of this talk is a review of what
Ion does regarding memory coherency, the requirements driving some of these
choices, and what might be required to bring Ion into compliance with the
expected DMA APIs.

Speaker:

Rom Lemarchand
Rom has been working in the consumer electronics industry for over 10 years. Originally working on various proprietary operating systems, he switched to Android about 5 years ago and hasn’t looked back since.

Rom joined Google in 2012 and since then has been working on lowering Android memory requirements and graphics.

Rom holds a degree in Computer Science from Universite de Rouen and a Masters in Software Engineering from Carnegie Mellon University.

Aquileo | Welcome: Android upstreaming status

2014-09-05T09:26:32-04:00

One Line Summary:: Karim Yaghmour gives an overview of the state of Android upstreaming

Abstract:: Kick off to the Android microconf.
State of the progress of upstreaming the Android kernel: what has been achieved, what’s left to be done.

Speaker:

Rom Lemarchand
Rom has been working in the consumer electronics industry for over 10 years. Originally working on various proprietary operating systems, he switched to Android about 5 years ago and hasn’t looked back since.

Rom joined Google in 2012 and since then has been working on lowering Android memory requirements and graphics.

Rom holds a degree in Computer Science from Universite de Rouen and a Masters in Software Engineering from Carnegie Mellon University.

Aquileo | The next event with the io latency tracking

2014-09-05T07:54:05-04:00

One Line Summary:: The IO latency tracking allows to track per task the expected sleep time when blocked on an IO. Coupled with the next timer event, it gives an accurate information about the next event supposed to wake up a cpu

Abstract:: The increasing part of the embedded systems in the linux ecosystem forces the kernel developers to take into account an energy efficient approach when bringing a new platform. The different energy frameworks are standalone sub-systems acting independently and in a opportunistic way when there is nothing to do on the system. The energy efficient scheduler wants to integrate all these energy components in order to act proactively by having a better knowledge of the potential energy saving for each scheduling decision it will take. This presentation describes a new paradigm where the events occurring in a acceptable interval are considered predictable and can be tracked per task. It will describe the IO latency tracking fully integrated in the scheduler and, thanks to better predictions, allows to get ride of the cpuidle’s governor by directly choosing an idle state from the scheduler

Speaker:

Daniel Lezcano
Daniel worked in 1998 in the Space Industry and Air traffic management for distributed system project in life safety constraints. He acquired for this project a system programming expertise. He joined IBM in 2004 and since this date he does kernel hacking and pushed upstream the resource virtualization with the namespaces. He is the author and maintainer of the Linux Container (LXC).

In 2012, he joined the Linaro project in the power management team. He is deeply involved in kernel contributions for the power management.

http://www.linkedin.com/profile/view?id=209357048&trk=nav_responsive_tab_profile

Aquileo | What's left to make allyesconfig on x86_64

2014-09-04T13:56:57-04:00

One Line Summary:: The LLVMLinux is close to be able to compile the full kernel (aka allyesconfig) - what is left to do ?

Abstract:: This talk will show the status of the LLVMLinux project on x86_64 and the current state of options that still need to be disabled or does not build.
We’ll discuss the current patches for these areas and what needs to be done to resolve it.

Speaker:

Jan-Simon Möller
Jan-Simon Möller is an electrical engineer who has spent the past decade working with and on Open Source projects and Linux. His previous work involved embedded systems, build systems, device drivers, power management, robotics and SELinux. He has been involved in a number of Open Source projects, including being a contributor to the Open Build Service. Currently Jan-Simon works as a consultant as well as being a Trainer for The Linux Foundation.

Aquileo | Systematic testing of fault handling code in Linux kernel

2014-09-04T10:02:17-04:00

One Line Summary:: The target audience is Linux kernel developers as well as anyone who is interested in advanced verification and testing techniques, for example, to build, verify and certify safety or security critical systems on top of Linux kernel.

Abstract:

“The talk presents a method to extend coverage of existing tests by systematic and targeted fault injection in Linux kernel. The method is developed within Linux File System Verification project that aims to provide an exhaustive test suite for Linux file system drivers.

The presented method of fault injection allows to systematically simulate faults dedicated to a file system driver under test (faults of memory allocation requests, bio layer, etc.). That means it does not introduce faults into requests coming from other modules and it implements systematic iteration of fault situations versus a prevailing random approach.

The talk presents results of experiments with the method, defines requirements to tests so they can be used with the method and discusses lessons learnt so far."

Speaker:

Alexey Khoroshilov
Alexey Khoroshilov is a director of the Linux Verification Center of Institute for System Programming of the Russian Academy of Sciences. He has graduated from Computer Sciences Department of the Lomonosov’s Moscow State University with honour and received a Ph.D. in Computer Sciences on the Formal Specification and Testing of Asynchronous Systems.

He has more than 50 research publications and has presented at numerous scientific and developer conferences. Alexey is also an author of more than 100 patches to Linux kernel that were prepared within Linux Driver Verification project (http://linuxtesting.org/ldv).>

Aquileo | Moving code out of staging

2014-09-03T23:58:03-04:00

One Line Summary:: open discussion about moving the Android code out of staging

Abstract:: Open discussion about the state of Android drivers in the tree and how to move them out of staging.

Speaker:

Rom Lemarchand
Rom has been working in the consumer electronics industry for over 10 years. Originally working on various proprietary operating systems, he switched to Android about 5 years ago and hasn’t looked back since.

Rom joined Google in 2012 and since then has been working on lowering Android memory requirements and graphics.

Rom holds a degree in Computer Science from Universite de Rouen and a Masters in Software Engineering from Carnegie Mellon University.

Aquileo | Porting Generic Android Drivers and 64-bit Binder ABI

2014-09-03T23:54:20-04:00

One Line Summary:: Generic 64-bit driver porting guidelines; 64-bit Binder ABI; Replacing Binder IPC.

Abstract:: This presentation will focus on the issues we faced while porting Android’s IPC mechanisms, binder and ashmem, to 64-bit. We will discuss about Android’s compact layer, support for 32-bit applications running on 64-bit kernels, as well as 64-bit ABI changes. We will also propose a path for replacing Binder, Android’s IPC.

Speaker:

Serban Constantinescu
I am Software Engineer working for ARM as part of the Android team. In the past few years I have been involved on a couple of Android subsystems from Ashmem and Binder to libc, Dalvik and ART. I have been actively involved in the ARM64 Android bootstrap and previously I have been maintaining the ARM Versatile Express Android ports.

At roots I have an electronics background, graduated the Polytechnic University of Bucharest and a master at Bristol University.

Ask me about:
- ARM
- Binder
- Bionic
- Art
- Android
- OpenCV (though a bit rusty now)
You can check my latest patches here:
- AOSP: http://goo.gl/s5XLS2
- Linux Kernel: http://goo.gl/cHigeb

Aquileo | Power management discussion: Big.Little

2014-09-03T23:52:37-04:00

One Line Summary:: Open discussion regarding big.little and more generally power management in Android

Abstract:: So far, there hasn’t been a Big.Little Nexus device. Many challenges arise when using these types of CPU architectures: latency of turning cores on and off, app execution predictability… This will be an open discussion for anyone wanting to participate.

Speaker:

Rom Lemarchand
Rom has been working in the consumer electronics industry for over 10 years. Originally working on various proprietary operating systems, he switched to Android about 5 years ago and hasn’t looked back since.

Rom joined Google in 2012 and since then has been working on lowering Android memory requirements and graphics.

Rom holds a degree in Computer Science from Universite de Rouen and a Masters in Software Engineering from Carnegie Mellon University.

Aquileo | Introduction to AARCH64

2014-09-03T23:51:05-04:00

One Line Summary:: ARM64 Instruction Set Overview

Abstract:: Last year ARM released the ARMv8 architecture which defines the 64-bit ARM architecture and this presentation will focus on the 64-bit instruction set. We’ll give an overview of its defining features as well as highlight the main differences with its 32-bit counter-part. This talk is addressed to those who are curious.

Speaker:

Rodolph Perfetta
Rodolph has been leading the team in ARM contributing the initial port of the GoogleV8 JavaScript Engine to AArch64 (64-bit ARMv8).

Rodolph joined ARM in 2001 where he has been mostly focus on optimising virtual machines for the ARM architecture, 32 and 64-bit.

Aquileo | dma-fence & android sync

2014-09-03T23:49:56-04:00

One Line Summary:: explicit synchronization in the android graphics layers and mainlining efforts

Abstract:

“Modern Android devices have a userspace layer known as the Hardware Composer HAL (HWC) that’s responsible for abstracting away the per-SoC logic for doing display composition of graphics buffers, and feeding the results to display. HWC can also pull data from media IP blocks, like camera or video decode/encode, and use them for composition. In order to exploit parallelism between this hardware, SoC vendors often implemented implicit synchronization contracts between drivers/hardware that made systems very difficult to debug or reason about, and were often flat out wrong. Android sync is a framework for explicit synchronization, so that drivers and hardware can safely and performantly synchronize with one another through a unified interface.

The canonical usage of sync is between graphics and display. A GPU driver can kick off work for generating a graphics buffer, and before this work is complete and the buffer finished, create a “sync pt” file descriptor to track this work. Userspace software can now hand off this graphics buffer and “sync pt” to a display driver, which can begin spooling up the next frame for display – before the GPU block has finished with the buffer. This deferred synchronization reduces latency, and depending on the platform, allows drivers to exploit hardware synchronization. Android sync also has strong facilities for debugging, which can greatly aid in figuring out the deadlocks and race-conditions which often appear in these data pipelines."

Speaker:

Rom Lemarchand
Rom has been working in the consumer electronics industry for over 10 years. Originally working on various proprietary operating systems, he switched to Android about 5 years ago and hasn’t looked back since.

Rom joined Google in 2012 and since then has been working on lowering Android memory requirements and graphics.

Rom holds a degree in Computer Science from Universite de Rouen and a Masters in Software Engineering from Carnegie Mellon University.

Aquileo | Migrating code from ARM to ARM64

2014-09-03T23:45:43-04:00

One Line Summary:: Best practices for migrating code from ARM to ARM64

Abstract:: The ARM world is shifting to 64-bit. While good quality C/C++ code is fairly straightforward to port, assembly will require some work. I will start by giving a short summary of the best practises and present the most common mistakes. I will then talk about the key differences between arm and arm64, and provide tips to help you migrate your assembly code, including code using NEON vector instructions. Your code might not be completely ready but you should be.

Speaker:

Rom Lemarchand
Rom has been working in the consumer electronics industry for over 10 years. Originally working on various proprietary operating systems, he switched to Android about 5 years ago and hasn’t looked back since.

Rom joined Google in 2012 and since then has been working on lowering Android memory requirements and graphics.

Rom holds a degree in Computer Science from Universite de Rouen and a Masters in Software Engineering from Carnegie Mellon University.

Aquileo | Bionic - 64 bit ABI and 64-bit ART

2014-09-03T23:43:48-04:00

One Line Summary:: Overview of Android's runtime and libc.

Abstract:

“ART is an evolution of the Android runtime, first made available as a developer option on Android 4.4 KitKat. It comes with improvements in the garbage collector, threading and locking model, compiler and runtime performance. It also adds support for 64-bit architectures. This talk will look at how ART differs from earlier runtimes.

Bionic is Android’s C library. It’s a BSD-licensed C library for the Linux kernel supporting 6 architectures (arm/arm64, mips/mips64, and x86/x86_64). This talk looks at how and why bionic differs from other C libraries, and how it gets along with the Linux kernel."

Speaker:

Elliott Hughes
Elliott Hughes is a member of the Android Runtime Team at Google. He’s worked on both the old Dalvik VM and the new Art VM, the core java.* libraries, and the Android C library (bionic). Recently he’s been focused on getting the libraries and core system tools (like the dynamic linker) ready for 64-bit.

Aquileo | Smart system shutdown

2014-09-03T11:19:45-04:00

One Line Summary:: How systemd inhibitors can be used to handle system shutdown in eCall and telephony scenarios.

Abstract:

A cars infotainment system is not necessarily shutdown once the car is stoppend and the key is removed. There are certain scenarios where the system has to remain active.

With a regular phone call, when the car is turned off, the system should only shutdown if the call is ended or the battery level reaches a point where ignition of the car would be impossible.

In case of an accident, modern cars use an eCall to automatically contact emergency services and transmit relevant data. Since the electronic system itself is an additional cause for injuries, it needs to be shutdown once the eCall is finished.

An eCall can also be started manually, e.g. in case of a medical emergency. In these cases the system must stay active even if the battery level is getting low.

In this session we would like to discuss if systemd inhibitors are capable of dealing with these scenarios and should limitations exist, how they can be fixed.

Speakers:

Timo Müller
No Biography Provided
Colin Guthrie
I have been an avid user of Linux for the last twenty or so years and in that time have built up a wealth of experience and connections.

Initially involved in Mandrake Linux as a packager/contributor and then through the renaming process to Mandriva. When the commerical company behind Mandriva hit financial troubles, I, along with several other former employees, was one of the founding members of the Mageia distribution which is still going strong.

Over the years my areas of focus have shifted somewhat. Originally I was maintainer of X.org stack and helped push the eyecandy related Compiz packages. I moved on to caring about audio and was responsible for pushing PulseAudio as the default audio option in Mandriva which received very good writeups for the way in which it was introduced and it’s stability there compared to other distributions. I was heavily involved in the upstream PulseAudio project.

Laterly, focus has shifted again but remains in the Plumbing layers. I have been responsible for pushing systemd and dracut as the boot+init solutions in Mageia and adapting various tools as well as contributing back to upstream dracut and systemd (albeit minimally in the case of the latter).

I remain very interested in Audio and the other Plumbing layers although my day job is unrelated and invovles web development and a little sysadmin at my own company Tribalogic Ltd http://www.tribalogic.net

Aquileo | LLVMLinux progress

2014-09-02T17:58:58-04:00

One Line Summary:: Where do we stand with the patches to support compiling the kernel with clang

Abstract:: Many things have changed in clang to support compiling the Linux kernel. What’s left to do on the Linux kernel side to support using clang? We’ll go through the current patches and what hasn’t been solved yet.

Speaker:

Behan Webster
Behan Webster has spent two decades in diverse tech industries such as telecom, datacom, optical, and automotive writing code for a range of hardware from the very small to the very large. He has Linux experience spans kernel programming, Embedded Linux, and board bring-up. Currently Behan is the lead consultant at Converse in Code Inc, an embedded Linux engineer and project lead working on the LLVMLinux project as well as being a Trainer for The Linux Foundation.

Aquileo | vampyr: configurability aware compile-testing of source files

2014-09-02T16:10:39-04:00

One Line Summary:: I present a tool, which compile-tests sourcefiles with a high coverage of configurable CPP-blocks.

Abstract:

Some bugs in the linux kernel only appear with specific configurations. In the same way, it’s possible that compiler errors and warnings only emerge with specific configurations, because configurable CPP-Blocks hide the code from the compiler. Compile-testing source code with all possible configurations is a tedious and error prone task. Maintainers often compile changes with the ‘make allyesconfig’ configuration, which doesn’t necessarily cover the whole code.
Our approach delegates compile-testing to a tool called ‘vampyr’.

The talk includes global coverage statistics of ‘allyesconfig’ in comparison to the results of the
vampyr approach for linux versions v3.2 and v3.16.

Speaker:

Stefan Hengelein
I’m about to finish my Master’s degree in CS at the Friedrich-Alexander University of
Erlangen-Nuremberg and I’m working in the vamos-project ¹² as a research student for about 1.5
years.

¹ https://vamos.cs.fau.de
² https://cados.cs.fau.de

Aquileo | Filesystem Status and Updates

2014-09-02T15:42:40-04:00

One Line Summary:: Filesystem Status and Updates

Abstract:: A short review of the current development focus in Linux filesystems. I’ll cover ongoing projects in Btrfs and invite others to do the same in their target areas.

Speaker:

Chris Mason
Chris Mason is a Linux Kernel Developer at Facebook and the maintainer of the Btrfs filesystem.

Aquileo | SMR integration and how to overcome layering issues

2014-09-02T10:21:55-04:00

One Line Summary:: This talk will focus on SMR integration with the linux SCSI stack and how layering issues can be overcome

Abstract:

SMR (shingled media recording) requires the OS to read in the list of zones to figure out the zone sizes and the status of the write pointer.
The idea here is that the OS reads the entire list to be able to make correct decisions about where the data should be written to or how I/O should be formatted.

For linux this means that initially we would need to keep the lists of zones at several layers:

- at the libata layer, as the zbc specification requires the SATL to return specific sense codes.
- at the SCSI layer, we might need to keep the write pointer up-to-date
- at the device-mapper layer, as the zone information determines the device-mapper table layout

For efficiency it would be good to keep the zone layout only once within the kernel, but the current layering forbids us to import this layer from other layers.

In this talk I will be presenting the problems during SMR integrations and discuss ways on how to overcome the layering problem.

Speakers:

Hannes Reinecke
Studied Physics with main focus image processing in Heidelberg from 1990 until 1997, followed by a PhD in Edinburgh ’s Heriot-Watt University in 2000. Worked as sysadmin during the studies, mainly in the Mathematical Institute in Heidelberg. Now working at SUSE Labs with focus on storage and mainframe. Principal contact point for storage related issues on SLES.

Linux addict since the earliest days (0.95); various patches to get Linux up and running. Main points of interest are storage, (i)SCSI, FC/FCoE, and multipathing. And S/390, naturally.

I’m active on the Linux SCSI mailing list, reviewing patches and dusting out murky corners in the SCSI stack. Plus occasionally maintaining the aic79xx driver.

Played around with kvm/qemu; I’ve implemented the megasas HBA emulation for qemu.
James Borden
Director of Data Center Ecosystem Engagement focusing on the open-source community.

Aquileo | What features are needed from a live patching solution?

2014-09-02T04:12:18-04:00

One Line Summary:: What features are needed from a live patching solution?

Abstract:: There are currently several competing solutions for live patching. The aim of this session is to try to reach an agreement (through mixture of presentation and discussion) on what features the live patching solution should be implementing so that user expectations are satisfied.

Speaker:

Jiri Kosina
Jiri works as a Linux Kernel developer and a leader of the “Core Kernel” team at SUSE Labs.

Aquileo | How to fix bugs automatically?

2014-09-01T11:36:18-04:00

One Line Summary:: I will introduce the idea of automatic software repair and how it works in practice.

Abstract:: Automatic software repair is the process of fixing software bugs automatically. An automatic software repair system fixes software bugs with no human intervention. The goal of automatic software repair is to save maintenance costs and to enable systems to be more resilient to bugs and unexpected situations. I will discuss the foundations of repair: it may happen at the level of the program code (for instance by changing the conditional expression of an if statement) or at the level of the program state (for instance by replacing a stale unrecoverable object by a fresh one), it focuses on one particular type of bug, in one particular technical space (e.g. initialization bugs in Java programs); it embeds algorithms and heuristics that leverage knowledge about this kind of bugs: on what the causes are, on how the symptoms manifest themselves, on what the likely fixes look like.

Speaker:

Martin Monperrus
I am an associate professor at the University of Lille (France) and a member of INRIA’s research group SPIRALS.

Aquileo | Refactor interrupt remapping interfaces to support hierarchy irqdomain

2014-09-01T10:00:18-04:00

One Line Summary:: We are trying to refactor x86 interrupt architecture with hierarchy irqdomain, so changes to current interrupt remapping interfaces are needed to support the refactor.

Abstract:: We have different interrupt controllers on x86 platforms, such as Local APIC, IO-APIC, PIC, MSI, Hypertransport Interrupt, and interrupt remapping controller etc. Drivers for interrupt controllers are tightly coupled with each other. We are trying to build a stacked driver model and decouple interrupt controller drivers from each other as much as possible based on hierarchy irqdomain interfaces. So we need to make changes to current interrupt remapping interfaces.

Speaker:

Jiang Liu
A Linux and OpenSolaris developer since 2004.

Aquileo | How to evaluate block allocator changes

2014-09-01T05:51:58-04:00

One Line Summary:: This session will discuss ways we can and should evaluate changes to a file system block allocator to avoid performance regressions.

Abstract:

Changing file system block allocator is a tricky thing to do on its own, but despite that we do not have any standardised way to evaluate the change to prevent performance regressions.

Xfstests is currently the standard tool to test file systems to avoid regressions and bugs. It is widely used by file system developers so it seems like the right place for performance regression tests as well. But that’s just the beginning.

Having simple performance “unit” tests such as sequential/random/direct/async read/write is easy, but it does not give us complete picture especially since block allocator changes might have bigger impact in the long run when file system ages. That’s why we need workload examples, simulations of the real applications.

Some of it may be simulated by fio, fsstress, filebend or others, but ultimately the best test would be provided by the application developers. Having it easy to setup and run, small and without complex dependenties will be the key. Do we need a specific file system aging tool ? Can we use workload simulation to age the file system with the certain workload ? We do not care about the data, how to speed up the process ?

But some problems might be even discovered more quickly by static analyze of the file system. But what are the traits we’re looking for ? File fragmentation, free space fragmentation, data/metadata locality, that much is obvious, what else ? That’s up for the discussion.

Speaker:

Lukáš Czerner
Lukas is one of the core ext4 developers employed by Red Hat, Inc located in Czech Republic. He is actively working on improving the ext4 file systems as well as other local Linux file systems and its user space utilities. He is active member of Linux kernel community participating on many conferences and kernel developers encounters world wide.