Embedded, Networked and Distributed Systems

This group systematically explores architectures, models, algorithms, engineering, measurement, and control of embedded, networked, and distributed systems. The group is especially interested in large-scale systems, based on both wireless and wireline interconnection technologies, as well as high-performance system interconnects. Current group interests include:

- Environmental sensor monitoring systems
- Home network monitoring and management systems
- Complex event processing systems
- Routing and broadcasting in wireless, mobile, vehicular, ad hoc networks
- Networked multimedia - transport protocols and standards
- Scalability of the Internet routing architecture
- Content-centric networks
- Novel approaches to network protocol implementation
- Network instrumentation and traffic modelling
- Novel analysis of program code
- Runtime memory management
- Acceleration of computations on parallel platforms
- Programming models for many-core systems
- FPGA and GPU programming
- Functional hardware description languages
- Hypercomputation
- large scale(typically distributed) information/data systems (IDEAS)

Many academic members are also involved in a cross-cutting The Glasgow Parallelism Group (GPG) theme due to the shared interests in multi- and many-core machines, Clouds, High-Performance Computers (HPC). ENDS group also has strong connections with SICSA in Next Generation Internet and Complext Systems Engineering research thems.

Academic Staff: Dr Lewis M Mackenzie, Dr John T O'Donnell, Dr Colin Perkins, Dr Dimitrios Pezaros, Dr Jeremy Singer, Dr Tim StorerDr Wim VanderbauwhedeProf Phil Trinder, Prof Peter Triantafillou

Research Fellows and Associates: Dr Nikos Ntarmos, Dr David R. White, Dr Christos Anagnostopoulos, Dr Natalia Chechina, Dr Kenneth MacKenzie, Dr Patrick Maier,  Dr Waqar Nabi

Research Assistants and Research Students: Mr Gubran Alkubati, Mr Khaled Alnowaiser, Mr Niaz Chowdhury, Mr Paul Harvey, Mr Paul Jakma, Mrs Mozhgan Kabiri Chimeh Mr Wing Li, Mr Stuart Monro,  Mr Kyle White, Mr Ashkan Tousimojarad, Miss Sharifa Al Khanjari, Mr Michael Comerford, Mr Georgios Maniatis, Mr Simon Jouet, Mr Amir Ghaffari, Mr Joe Davidson, Mr Abyd Adhami, Mr Georgios Sfakianakis, Ms Foteini Katsarou, Mr Jing Wang, Mr Callum Cameron, Mr Richard Cziva, Mr Malak Al Jabri, Mr Majed Al Saeed, Mr Stephen McQuistin.

  • Performance measurement and analysis
  • network measurement
  • policy-based network management
  • network modelling
  • next generation internet
  • complex systems engineering
  • networked multimedia
  • parallel programming
  • embedded systems
  • sensor networks
  • digital circuit design
  • task parallelism
  • data parallelism

This Week’s EventsAll Upcoming EventsPast Events

This Week’s Events

There are no events scheduled for this week

Upcoming Events

There are no upcoming events scheduled.

Past Events

Open Problems in 2-level Compact Routing (14 November, 2012)

Speaker: Paul Jakma

"A quick talk on the subject of my PhD, on some of the open problems in compact routing. In particular, issues around selecting landmark nodes in 2-level compact routing schemes, and their influence on other problems such as policy in routing."

VM Migration: Juggling the Data Center. (21 November, 2012)

Speaker: Gregg Hamilton

One major goal of data center operators is to give predictable, bounded performance guarantees (or SLAs) across their network. However, with the majority of traffic flows being highly dynamic and short-lived, achieving balanced network performance is somewhat problematic. Current virtual machine (VM) migration techniques balance server workloads using CPU and memory resources as migration indicators, with few considering the effects on network performance. This talk will look at the topic of my PhD work: combining server-side and network performance indicators to achieve a stable and predictable network through VM migration.

ERMMM - Economic Resource Modelling for Memory Management (28 November, 2012)

Speaker: Jeremy Singer

How do we share resources equitably between competing individuals? In this particular case, how do we share main memory between concurrent JVM processes? Can micro-economic theory provide inspiration to software systems architects? In this week's ENDS talk I aim to address these questions in a pragmatic way.

A Parallel Task Composition Approach to Manycore Programming (20 February, 2013)

Speaker: Ashkan Tousimojarad

Many-core processors have emerged to change the parallel computation world. Efficient utilization of these platforms is a great challenge. The Glasgow Parallel Reduction Machine (GPRM) is a novel, flexible framework for parallel task-composition based manycore programming. We structure programs into task code, written as C++ classes, and communication code, written in a restricted subset of C++ with pure functional semantics and parallel evaluation. Therefore, our approach views programs as parallel compositions of (sequential) tasks.
In this talk I will discuss the GPRM, the virtual machine underlying our framework. I demonstrate the potential using an implementation of a merge sort algorithm on a 64-core Tilera processor, as well as on a conventional Intel quad-core processor. The results show that our approach actually outperforms the OpenMP code, while facilitates writing of parallel programs.

Wireless sensor networks for real time particle tracking in inaccessible environments (27 February, 2013)

Speaker: George Maniatis

One of the most difficult problems of contemporary Geophysics is the description and the prediction of the movement of the riverbeds. According to the Lagrangian description of the system the whole movement can be resolved into the combinational result of the movement of individual grains across several time and space scales. The verification of this type of models demands the acquisition of data that a) express the synergistic effect of hydrological and topographical circumstances, b)describe the movement of each grain as an continuous process, especially during events of special interest (like floods) and c) give representative macroscopic information for the riverbed (synchronous monitoring of many grains).Although many of the contemporary technologies have been applied (advanced RFID techniques, specialized piezoelectric sensors, sonar e.t.c) none of the existing datasets meets all the above three requirements. The first stage of this project is the development of a Wireless Sensor that will be able to monitor robustly all the phases of individual grain movement (entrainment, transition,deposition) by correlating measures for both causal and result factors (experienced accelerations and travel-path length/position respectively).The second stage will be the deployment of a number of sensors which will be installed into artificial and/or natural stones and will form a Wireless Network of smart-pebbles- motes that would address the need for representative macroscopic information. The final stage will be the deployment of this WSN into a motoring system that will ,along with the data concerning the movement of the grains, provide synchronous information about the state of the river (stage discharge, flow velocity, local topography e.t.c).This is a challenging application, with constrains posed on all the "aspects" of the WSN (from the motes and the physical to the network and finally the application layer) .Those constrains are driven from the special characteristics of the system (difficult initial sensor calibration,demand for robust under- water RF communication,harsh environmental conditions e.t.c) and the stochasticity of the understudy process (need for robust event detection algorithms,decision making based on very variable thresholds, real time reprogramming for recalibration e.t.c).

Optimizing Multicore Java Virtual Machines (17 April, 2013)

Speaker: Khaled Alnowaiser

The Java Virtual Machine (JVM) consumes a significant portion of its execution time performing internal services such as garbage collection and optimising compilation. Multicore processors offer the potential to reduce JVM service overhead by utilising the parallel hardware. However, the JVM developers face many challenges to adapt and achieve optimal performance. This talk will motivate and discuss multicore garbage collection performance and some behavioural observations of OpenJDK Hotspot JVM. We will propose some potential solutions to JVM performance optimisation.

One VM to Rule Them All (ENDS Seminar) (16 October, 2013)

Speaker: Chris Seaton

The Virtual Machines research group at Oracle Labs is exploring ways to implement high performance virtual machines for a wide range of languages, building on technology in the JVM.
Graal is a JVM compiler, written in Java, that exposes an API to the running program. Using Graal a program can directly access its own IR and supporting mechanisms such as dynamic code installation and invalidation.
Truffle is a framework for implementing languages in Java as simple AST interpreters, and specialising the AST over time to better suit the running program and input.
When Truffle is run on a JVM with the Graal compiler it can take the IR of all of the Java AST methods that make up your interpreter and compile them as a single machine code method optimised with partial-evaluation.
Chris's internship at Oracle Labs over the first half of this year looked at implementing the Ruby programming language using Graal and Truffle. Ruby is an extremely dynamic language and an implementation such as JRuby that uses bytecode to interface to the JVM must make a lot of redundant checks and boxing. We show how our techniques entirely remove these obstacles to high performance.
Our implementation of Ruby is both strikingly simple, written as just a Java program that interprets Ruby AST, and strikingly fast, running compute intensive benchmarks significantly faster than any other implementation of Ruby.
These techniques should be interesting to anyone who implements custom languages or who is interested in how JVM languages may work in the future.

SD Erlang Operational Semantics (23 October, 2013)

Speaker: Natalia Chechina

The RELEASE project aims to scale Erlang to build reliable general-purpose software, such as server-based systems, on massively parallel machines. To extend the Erlang concurrency-oriented paradigm to large-scale reliable parallelism (10^5 cores) we have implemented an extension to the Erlang language, Scalable Distributed Erlang (SD Erlang)p. Key goals in scaling the computation model are to provide mechanisms for controlling locality and reducing connectivity, and to provide performance portability.

In this talk we introduce an operational semantics for SD Erlang. The semantics defines an abstract state and presents transition of SD Erlang functions. In addition we have validated the consistency between the formal semantics and the SD Erlang implementation. Our approach is based on property-based testing, in particular we use the Erlang QuickCheck tool developed by Quivq.

ENDS Seminar: ForgetMeNot (11 December, 2013)

Speaker: Jeremy Singer

In a future computational environment with terabytes of non-volatile RAM and petabytes of cloud-based backing store, can we avoid explicit delete/free()s and implicit garbage collection altogether? Health warning: this is a highly speculative, low-content presentation.

Network coding-based data dissemination for Accident Warning Systems in Vehicular Ad-hoc Networks (08 January, 2014)

Speaker: Niaz Chowdhury

Abstract: Data dissemination in Vehicular Ad-hoc Networks (VANETs) is challenging because of the dynamics of this network. It becomes more intense when VANET works with Accident Warning System (AWS) like real-time application that delivers time-dependent safety notifications. Most existing protocols use limited-scope-broadcast to increase reachability ratio of their warnings within a tolerable delay. Though there are other initiatives to distribute warning notifications in VANETs, but a higher reachability ratio within a tolerable delay can most likely be secured by limited-scope-broadcast. However, in turn it creates Broadcast Storm Problem (BSP) in dense traffic and accounts for long delay in notification delivery and data-loss in the worst case. Our research aims to develop a data dissemination scheme that matches the performance of limited-scope-broadcast but will not create contention and collision in channel access by employing Network Coding. This new scheme will reduce number of transmission by encoding multiple notifications together and aggregates multiple encoded notifications further with a view to reduce channel access competition. 

Advanced Management Techniques for Many-core Communication Systems (22 January, 2014)

Speaker: Sharifa Khanjari

A Quadtree is a tree in which each internal node has exactly four children. Quadtrees are most often used to partition a two-dimensional space by recursively subdividing it into four quadrants. My research is about building an infrastructure for many cores on chip networks architectures using novel topologies. The infrastructure should focus on quality of service provisioning and task allocation. This talk will provide an overview of the quadtree topology in network on chip and some preliminary results when comparing it with mesh using locality distribution.

Analysing Twitter Traffic on the Independence Referendum - A Thesis Procrastination Project (TPP) (29 January, 2014)

Speaker: Michael Comerford

Social media platforms like Twitter are of growing interest to political science and sociology as additional data sources and the Independence Referendum offers an opportunity to analyse public discourse in a unique set of historical circumstances. Working with Policy Scotland in the College of Social Sciences I've been harvesting twitter traffic for the #IndyRef and visualising the network of twitter users and hashtags over snapshot time periods. The purpose of this talk is to outline my methodology and some early findings. I'd be keen to get feedback on whether considering the data as a network is useful and what further analysis in this vein might be interesting. Further details of the project can be found here:http://policyscotland.gla.ac.uk/twitter-analysis/

Models and Modalities (05 February, 2014)

Speaker: Joe Davidson

In this talk I will attempt to examine the relationship between the size of a program written in a particular language and the expressiveness of the semantics of that language. We compare across the program/memory boundary using Random Access Stored Program (RASP)  machines as a Von Neumann model, and the classic Turing Machine as our Harvard architecture. But will also iterate on our RASP machine to see how minor semantic changes affect our program sizes within a single memory model.

In addition, I explain how semantics are not as suitable as we’d like for these comparisons and use this to motivate how I have grounded our models using Field Programmable Gate Arrays. I’ll will present the current results from both the program+semantics analysis and grounding into FPGAs.

Guest Talk - Enhancing Network Structure to Increase Resilience and Survivability (11 February, 2014)

Speaker: Prof James P.G. Sterbenz

Resilience and survivability of the Future Internet is increasingly important to preserve critical services, particularly against attackers with knowledge of the structure and vulnerabilities of the network, as well as against large scale disasters that affect a large area.  A brief motivation and introduction will be given to the ResiliNets architecture, strategy, design principles, and analysis methodology.  This presentation will then describe the graph-theoretic properties required for flow-robustness, and introduce our path diversity measures.  Two current research directions will then be described:  how to add links to existing graphs under cost constraints to increase flow robustness, and geographic diversity as a basis for multipath geodiverse end-to-end transport (ResTP) and routing (GeoDivRP).

A Novel Approach in Task-based Parallelism (19 February, 2014)

Speaker: Ashkan Tousimojarad

The Glasgow Parallel Reduction Machine (GPRM) is a novel task-based parallel framework targeting shared-memory many-core systems. Our approach is to provide a task composition language with default parallel evaluation, implemented using a restricted subset of C++ which is familiar and easy to use for the end users.

In this talk, I will shortly describe the structure of the GPRM. Micro-benchmarks used to identify bottlenecks in other approaches, specifically OpenMP, will be shown. Then I will present a solution we have used in our framework to increase the scalability of an LU Factorisation algorithm for Sparse Matrices. 

Software Defined Data Centres through Container based Virtualisation (28 March, 2014)

Speaker: Mr. Simon Jouet

Due to structural and design reasons such as uncertain resource demand, pour workload placement and long provisioning time scales modern data centres have been running as low as 10% utilisation. In order to increase utilisation the modern approach has been to allocate multiple tenants onto the same server through virtualisation techniques such as Xen, however, even with highly sophisticated placement and consolidation algorithms servers rarely runs above 50% utilisation.

In this talk, I will discuss about container-based virtualisation, a finer grain approach to multi-tenant isolation and the possible immediate benefits on server utilisation. Secondly I will briefly introduce Docker and how it can significantly change current DC management. Finally I will explain my idea on how containers can be used to improve server utilisation as well as network placement and isolation (slicing), storage and finally resiliency.

Introducing Tagged Pointers to the HotSpot JVM (07 May, 2014)

Speaker: Mr Wing Li

Our previous research has shown that that non-Java languages, such as Clojure and Scala, frequently box their primitive values within objects. These objects are typically short lived, requiring garbage collection later. Tagged pointers address this problem by encoding the primitive value directly in the bitstring of the pointer word itself, removing the need to allocate an object on the heap. However, checking each pointer reference for tags and type lookup can add to the overhead of this technique. This presentation is on my work implementing tagged pointers within the industry-standard HotSpot JVM interpreter. I describe some of the decisions made and their effects. I also describe the modifications made to the template based interpreter to support tagged pointers.

A Domain Specific Language for GPU Programming (14 May, 2014)

Speaker: Dr John O'Donnell


Callisto: revisiting parallel runtime systems for multicore architectures (23 May, 2014)

Speaker: Tim Harris

Tim Harris is a researcher at Oracle Labs where his interests include parallel programming, operating systems, and architecture support for programming language runtime systems. His other recent work has focused on the implementation of software transactional memory for multi-core computers, and the design of programming language features based on it. He is a co-author of the Morgan Claypool textbook on Transactional Memory.

Tim has a BA and PhD in computer science from Cambridge University Computer Laboratory. He was on the faculty at the Computer Laboratory from 2000-2004 where he led the department’s research on concurrent data structures and contributed to the Xen virtual machine monitor project. He was at Microsoft Research from 2004, and then joined Oracle Labs in 2012.

Fast dynamic type-checking of unsafe code (and other stories) (11 August, 2014)

Speaker: Stephen Kell

Huge amounts of widely-used code are written in C, C++ and other unsafe 
languages (meaning languages which do not enforce any type- or 
memory-safety invariants). Considerable existing work has added some 
kind of invariant checking to such languages (usually just to C), but 
with several caveats: sacrificing source- or binary-level compatibility, 
imposing high run-time overheads, and (almost always) checking spatial 
and/or temporal memory correctness but ignoring type-correctness.

To start, I'll describe libcrunch, a language-agnostic infrastructure 
for dynamically checking the type-correctness of unsafe code.  Using a 
novel disjoint metadata implementation and careful integration with 
existing toolchains (notably a C front-end), libcrunch allows fast 
dynamic type checking with full source- and binary-level compatibility 
and with generally low run-time overheads.

Towards the end of the talk I'll zoom out a little to place libcrunch 
alongside some other projects, as part of a wider agenda: closing the 
gap between "static" and dynamic language infrastructure, hence enabling 
greater degrees of cross-language composition, reasoning and tool