29 research outputs found
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
Recommended from our members
A NON-EQUILIBRIUM STATISTICAL MECHANICAL APPROACH FOR DESCRIBING HEAVY ION REACTIONS
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