- When: 1st November 2018 13:00 - 14:00
- Where: Cole 1.33b
- Series: Systems Seminars Series
- Format: Seminar, Talk
AbstractRecord linkage is the process of identifying records that refer to the same real-world entities, in situations where entity identifiers are unavailable. Records are linked on the basis of similarity between common attributes, with every pair being classified as a link or non-link depending on their degree of similarity. Record linkage is usually performed in a three-step process: first groups of similar candidate records are identified using indexing, pairs within the same group are then compared in more detail, and finally classified. Even state-of-the-art indexing techniques, such as Locality Sensitive Hashing, have potential drawbacks. They may fail to group together some true matching records with high similarity. Conversely, they may group records with low similarity, leading to high computational overhead. We propose using metric space indexing to perform complete record linkage, which results in a parameter-free record linkage process combining indexing, comparison and classification into a single step delivering complete and efficient record linkage. Our experimental evaluation on real-world datasets from several domains shows that linkage using metric space indexing can yield better quality than current indexing techniques, with similar execution cost, without the need for domain knowledge or trial and error to configure the process.
Virtualisation is a powerful tool used for the isolation, partitioning, and sharing of physical computing resources. Employed heavily in data centres, becoming increasingly popular in industrial settings, and used by home-users for running alternative operating systems, hardware virtualisation has seen a lot of attention from hardware and software developers over the last ten?fifteen years.
From the hardware side, this takes the form of so-called hardware assisted virtualisation, and appears in technologies such as Intel-VT, AMD-V and ARM Virtualization Extensions. However, most forms of hardware virtualisation are typically same-architecture virtualisation, where virtual versions of the host physical machine are created, providing very fast isolated instances of the physical machine, in which entire operating systems can be booted. But, there is a distinct lack of hardware support for cross-architecture virtualisation, where the guest machine architecture is different to the host.
I will talk about my research in this area, and describe the cross-architecture virtualisation hypervisor Captive that can boot unmodified guest operating systems, compiled for one architecture in the virtual machine of another.
I will talk about the challenges of full system simulation (such as memory, instruction, and device emulation), our approaches to this, and how we can efficiently map guest behaviour to host behaviour.
Finally, I will discuss our plans for open-sourcing the hypervisor, the work we are currently doing and what future work we have planned.
Head of School Simon Dobson will deliver a keynote at Dasip, the Conference on Design and Architectures for Signal and Image Processing in October in Porto. Dasip provides an international forum for innovation and developments in the field of embedded signal processing systems. Simon’s keynote will focus on making the transition from sensors to sensor systems software.
Abstract: Signal processing underpins everything we do with sensors. The physical limits of sensors, and the effects of their exposure to their environment, in turn constrain their accuracy, and therefore affect the trust we can place in sensor-driven systems. But this is a long pipeline, and it’s by no means clear how to trace from low-level errors and inaccuracies to their high-level consequences. In this talk I will try to tease-out some of the desiderata we might look for in such a pipeline, with a view to understanding how we can go about building sensor systems that deserve our trust.
Professor Adam Barker is featured in this month’s Communications of the ACM Magazine (CACM) discussing his recent Visiting Faculty appointment at Google. The Viewpoints article summarises his experiences working in software engineering on the Borgmaster team, and some of the core lessons which can be brought back to academia.
Borg is Google’s cluster management framework, which runs hundreds of thousands of jobs, across a number of clusters each with up to tens of thousands of machines.
In this talk, I will talk about the possibility of using Bayesian nonparametric clustering, or Dirichlet Process Mixture model to solve human activity recognition problem. In particular, I will discuss how the technique can be useful when the activity labels are not annotated and/or the activity evolves over the time. This initial study is built on an existing work on using directional statistical models (von Mises-Fisher) distribution, called Hierarchical Mixture of Conditional Independent von Mises Fisher distribution (HMCIvMFs), for unknown events detection and learning. Markov chain Monte Carlo sampling based learning algorithm will be presented together with some initial experiment results.
We have explored data coordination techniques that permit distributed systems to be constructed by interconnecting services. In such systems the network latency is often a problem. For example, large data volumes might have to be transmitted across the network if computation cannot be co-located close to data sources. One solution to this problem is the ability to deploy services in appropriate geographical locations and compose them together to create distributed ecosystems. Hence we seek to be able to deploy such services rapidly and dynamically enact and orchestrate them. However, this goal is hindered by the size of the deployments. Currently, virtual machine appliances that host such services on top of monolithic kernels are very large, thus are potentially slow to deploy as they may need to be transmitted across a network.
Our principles led us to take the route of re-engineering the standard software stack to create self-contained applications that are less-bloated and consequently much smaller based on Unikernels. Unikernels are compact library operating systems that enable a single application to be statically linked against a simple kernel that manages the underlying resources presented by a hypervisor. In this talk I will present Stardust – a specialised Unikernel that aims to support the deployment of application services based on the Java programming language.
Biography: Dr. Anil Madhavapeddy is a University Lecturer at the Cambridge Computer Laboratory, and a Fellow of Pembroke College where he is Director of Studies for Computer Science. He has worked in industry (NetApp, Citrix, Intel), academia (Cambridge, Imperial, UCLA) and startups (XenSource, Unikernel Systems, Docker) over the past two decades. At Cambridge, he directs the OCaml Labs research group which delves into the intersection of functional programming and systems, and is a maintainer on many open source projects such as OpenBSD, OCaml, Xen and Docker.
9:30: Introduction by Professor Saleem Bhatti
9:35: Lecture 1
10:35: Break with tea and coffee
11:15: Lecture 2
12:15: Lunch (not provided)
14:00: Lecture 3
15:00: Close by Professor Simon Dobson
Lecture 1: Rebuilding Operating Systems with Functional Principles
The software stacks that we deploy across computing devices in the world are based on shaky foundations. Millions of lines of C code crammed into monolithic operating system kernels, mixed with layers of scheduling logic, wrapped in a hypervisor, and served with a dose of nominal security checking on the side. In this talk, I will describe an alternative approach to constructing reliable, specialised systems with a familiar developer experience. We will use modular functional programming to build several services such as a secure web server that have no reliance on conventional operating systems, and explain how to express their logic in a high level, functional fashion. By the end of it, everyone in the audience should be able to build their own so-called unikernels!
Lecture 2: The First Billion Real Deployments of Unikernels
Unikernels offer a path to a more sane basis for driving applications on hardware, but will they ever be adopted for real? For the past fifteen years, an intrepid group of adventurers have been developing the MirageOS application stack in the OCaml programming language. Along the way, it has been deployed in many unusual industrial situations that I will describe in this talk, starting with the Docker container stack, then moving onto the Xen hypervisor that drives billions of servers worldwide. I will explain the challenges of using functional programming in industry, but also the rewards of seeing successful deployments quietly working in mission-critical areas of systems software.
Lecture 3: Programming the Next Trillion Embedded Devices
The unikernel approach of compiling highly specialised applications from high-level source code is perfectly suited to programming the trillions of embedded devices that are making their way around the world. However, this raises new challenges from a programming language perspective: how can we run on a spectrum of devices from the very tiny (with just kilobytes of RAM) to specialised hardware? I will describe the new frontier of functional metaprogramming (programs which generate more programs) that we are using to compile a single application to many heterogenous devices, and a Git-like model to coordinate across thousands of nodes. I will conclude with by motivating the need for a next-generation operating system to power new exciting applications such as augmented and virtual reality in our situated environments, and remove the need for constant centralised coordination via the Internet.
The core problem in many sensing applications is that we’re trying to
infer high-resolution information from low-resolution observations —
and keep our trust in this information as the sensors degrade. How can
we do this in a principled way? There’s an emerging body of work on
using topology to manage both sensing and analytics, and in this talk I
try to get a handle on how this might work for some of the problems
we’re interested in. I will present an experiment we did to explore
these ideas, which highlights some fascinating problems.