Ian Ward

CKAN contributor/tech lead
Urwid author
PyRF contributor
Speedometer author

Contributing to Open Source
IASA E-Summit, 2014-05-16
Urwid Applications
Urwid Intro
Unfortunate Python
Django 1.1

Moving to Python 3
Article Tags


Ian Ward's email:
first name at this domain

wardi on OFTC, freenode and github

Locations of visitors to this page

Ottawa Linux Symposium 2007 Day 1

OLS 2007 Programme
Posted on 2007-06-27, last modified 2007-07-01.

The ninth annual OLS has begun in Ottawa's sweltering summer heat.

There are as many as three different talks and two different tutorial topics being presented in each time slot. This is a summary of the talks I attended in day 1.

The Kernel Report - Jonathan Corbet

Everything is well in kernel-land, with the exception of release 2.6.21 which due to a number of major changes wasn't as stable as most releases.

Releases are happening quickly and the development process is working well for most people. The number of lines changed in the kernel has been fairly steady with over 2M lines of code changing in the last year, going against a prediction by Andrew Morton that the kernel would be done soon and "things will slow down".

There are issues with file system scalability. Disks are getting larger while not getting much faster, so some users of large file systems experience fsck times measured in days or weeks, not minutes. There are a number of file systems being worked on to solve this problem.

There are many new features that may become part of the upcoming 2.6.23 release including the "Completely Fair Scheduler". This scheduler removes the heuristics that try to determine which processes are "interactive" and yet actually improves desktop responsiveness.

Jonathan covered a huge number of topics and I strongly recommend that you read his slides and watch for his report on LWN.net.

KVM: The Kernel-Based Virtual Machine - Avi Kivity

KVM is a full virtualization option for Linux systems with hardware support.

KVM exposes the hardware capabilities to user space and adds a third mode of process operation called "guest mode". In guest mode certain operations are trapped and sent to the kernel. Memory virtualization is handled in the kernel while I/O is passed to user space. KVM uses QEMU for its I/O handling and some virtual devices. "KVM could be seen as an accelerator for QEMU".

KVM extends the kernel's usual process semantics. Guests are attached to regular processes. Guest SMP is implemented as threads within the process. The usual process control mechanisms apply, so you can kill, suspend and resume a guest by sending its process the appropriate signal.

KVM maintains a shadow page table that maps the guest's view of system memory to physical memory. Maintaining the shadow page table accounts for most of the performance overhead in KVM. They also consume most of KVM's 4MB memory overhead per guest.

KVM is claimed to be faster than Xen for kernel compiles by as much as 15%. KVM inherits the benefits of scalability work that has gone into the kernel and does not have a single domain handling all I/O like Xen's dom0, which can be a bottleneck with many guests.

During the presentation Avi booted both Fedora and Windows XP within QEMU. Both booted, however Fedora took many times as long to present a login prompt.

Kernel Support For Stackable File Systems - Josef Sipek

Stackable file systems appear to be regular file systems but rely on one or more other file systems for the data they contain. They can perform functions such as encryption, compression and merging contents of the underlying file systems.

Stackable file systems appear to be file systems to the Linux VFS layer, and they appear to be the VFS layer to their underlying file systems.

Stacking file systems in Linux work well in simple cases, but some stackable file systems would benefit from being able to store meta data for the files they contain. This meta data cannot be stored on the underlying file system, and includes things like persistent INODE numbers for NFS exporting and Unix attributes for file systems that don't support them. There is work being done on such a data store called "ODF".

Future work includes creating a directory-level fsck command to validate an ODF against an underlying file system and the creation of a reference stackable file system similar to BSD's "Nullfs".

My Bandwidth is Wider Than Yours - Iñaky Pérez-González

Ultra-Wide-Band is a high-bandwidth, low-power transport layer protocol that supports protocols such as Wireless USB and WiNET (IP over UWB). It is designed for a range of up to 10 meters and provides more bandwidth than other wireless standards by operating within a very wide spectrum but at a very low power.

UWB can't transmit through walls but unlike the signals put out by cellular phones, "you can put it next to your privates and you won't fry anything". It operates at "noise levels" so it doesn't have the same regulatory problems that common wireless adapters have.

There are plans to send uncompressed video over UWB to monitors and high-definition televisions. It supports QoS through reserved slots so that it can maintain a throughput for streaming devices.

UWB uses AES 128 for encryption to keep transmissions private, and consumer devices will likely be "plugged in" to each other by scanning and confirming a short hash on each device or by entering a password.

Linux support for UWB was demonstrated during the talk by streaming a compressed high-definition video from one laptop to another. Windows will soon have support for UWB but it will be a "Vista only" feature.

The 7 Dwarves: Debugging Information Beyond gdb - Arnaldo Carvalho de Melo

The DWARF format debugging information used by gdb can be useful outside of the debugger too.

There are tools that can be use to optimize data structures by reorganizing their binary format, measure the effects of function inlining, verify ABI compliance and identify differences in binary code generated between two versions of an executable.

The "pahole" program can identify alignment holes in data structures and mark cache line boundaries that will affect how long it will take a processor to load and use those structures. With deeply nested structures or structures with many typedefs it can be difficult to discern this information from the source code alone.

The "pfunct" program can be used to collect statistics on function size and the number of times they have been inlined. It can also be used to answer questions like "what are all the functions that operate data structure foo?" by searching their parameter types.

The "codiff" program shows the impact that certain compiler options or source code changes have on an executable. It can quickly identify type and size changes and can be used to verify that an application's binary interface has not changed.

continue to day 2

Tags: OLS Linux