DEBS Grand Challenge: Glasgow Automata Illustrated

The challenge is solved using Glasgow automata, concise complex event processing engines executable in the context of a topic-based publish/subscribe cache of event streams and relations. The imperative programming style of the Glasgow Automaton Programming Language (GAPL) enables multiple, efficient realisations of the two challenge queries

Actors: The Ideal Abstraction for Programming Kernel-Based Concurrency

GPU and multicore hardware architectures are commonly used in many different application areas to accelerate problem solutions relative to single CPU architectures. The typical approach to accessing these hardware architectures requires embedding logic into the programming language used to construct the application; the two primary forms of embedding are: calls to API routines to access the concurrent functionality, or pragmas providing concurrency hints to a language compiler such that particular blocks of code are targeted to the concurrent functionality. The former approach is verbose and semantically bankrupt, while the success of the latter approach is restricted to simple, static uses of the functionality. Actor-based applications are constructed from independent, encapsulated actors that interact through strongly-typed channels. This paper presents a first attempt at using actors to program kernels targeted at such concurrent hardware. Besides the glove-like fit of a kernel to the actor abstraction, quantitative code analysis shows that actor-based kernels are always significantly simpler than API-based coding, and generally simpler than pragma-based coding. Additionally, performance measurements show that the overheads of actor-based kernels are commensurate to API-based kernels, and range from equivalent to vastly improved for pragma-based annotations, both for sample and real-world applications

A NON-EQUILIBRIUM STATISTICAL MECHANICAL APPROACH FOR DESCRIBING HEAVY ION REACTIONS

With the availability of heavy-ion projectiles (A > 4) at low to intermediate energies (4 < E/A < 10), products showing various stages of relaxation for certain macroscopic variables (center-of-mass energy, orbital angular momentum, etc.) were produced in various reactions. The distributions for these macroscopic variables showed a correlation between the stage of relaxation reached and the net amount of mass transfer which had occurred in the reaction. There was also evidence that there was an asymmetry in the number of net transfers necessary for complete relaxation between stripping and pickup reactions. A model for describing the time-evolution of these reactions was formulated, the keystone of which is a master-equation approach for describing the time-dependence of the mass-asymmetry. This, coupled with deterministic equations of motion for the other macroscopic coordinates in the reaction lead to calculated distributions which provide an excellent qualitative description of these reactions, and, in some cases, quantitatively reproduce the experimental data quite well. 61 figures, 2 tables

Wireless sensor network simulation with Xen

The large-scale and inaccessibility of deployed wireless sensor networks mandate that the code installed in sensor nodes be rigorously tested prior to deployment. Such testing is primarily done using software simulators. Discrete event simulators, by their very nature, mask race conditions in the code since simulated interrupts never interrupt running code; an additional limitation of most such simulators is that all simulated nodes execute the same application code, at variance with common practice in actual deployments. Java-based simulators often suffer from efficiency issues, which limits the scale and performance of the simulation. Since all of these problems reduce confidence in the deployed system, the focus of this work is to eliminate these problems via complete emulation of wireless sensor networks using virtualisation techniques in a scalable manner. This work describes the virtualisation of the Contiki, TinyOS, and InceOS wireless sensor network operating systems to execute as guest domains over the Xen hypervisor. In each case, the hardware virtualisation is performed at the lowest possible layer, maximising the amount of OS and application code which is executed during the emulation. This work also introduces a novel Xen-specific radio model mechanism, easing the introduction of different radio models for use during emulations

SmallSync: A Methodology for Diagnosis & Visualization of Distributed Processes on the Web

SmallSync, an internet event synchronizer, is intended to provide a monitoring and visualization methodology for permitting simultaneous analysis and control of multiple remote processes on the web. The current SmallSync includes: (1) a mechanism to multicast web window-based commands, message passing events and process execution events among processes; (2) an event synchronizer to allow concurrent execution of some functions on multiple machines; (3) a means to report when these events cause errors in the processes; and (4) ad hoc visualization of process states using existing visualizers

Adaptable Actors: Just What The World Needs

The combination of improved battery technology and more power-efficient computing hardware has led to the proliferation of heterogeneous distributed systems. This internet of things consists of embedded, wearable, hobbyist, parallel, and commodity devices. Given the different resource and power constraints of such systems, applications must be able to reconfigure or adapt their runtime execution environment in order to make best use of the resources available. In order for the underlying operating system/runtime to support runtime adaptation, an application must be suitably designed. The actor model of computation presents a natural fit for programming such adaptive systems with shared-nothing semantics and use of message passing. This paper addresses the limitations of current actor approaches and argues that an actor is the appropriate unit of adaptation. This is justified through experimentation across heterogeneous platforms