PMG: Multi-core metabolite identification

Distributed computing has been considered for decades as a promising way of speeding up software execution, resulting in a valuable collection of safe and efficient concurrent algorithms. With the pervasion of multi-core processors, parallelization has moved to the center of attention with new challenges, especially regarding scalability to tens or even hundreds of parallel cores. In this paper, we present a scalable multi-core tool for the metabolomics community. This tool addresses the problem of metabolite identification which is currently a bottleneck in metabolomics pipeline.Analytical BioScience

Model checking GOAL agents

This thesis presents a novel approach to model checking of agent programs written in an agent programming language. The language we consider is GOAL. The novelty of the approach is that we implement model checking algorithms from scratch on top of the standard language interpreter. In contrast, in the literature on agent program verification, agents are translated to the input language of an existing model checker, after which this verification tool is used as usual for actual model checking. We present an implementation, and show that our approach performs substantially better in terms of resource consumption than existing model checkers for GOAL. Moreover, our approach allows for more expressive property specification languages and has benefits from a software engineering point of view: the implementation of a language interpreter is gained for free. Both conceptually and on the implementation level, our approach is generic and can be applied to other agent programming languages as well. Additionally, we investigate state space reduction techniques tailored to GOAL, namely property-based slicing and partial order reduction, to further optimise our model checker's performance. To this end, we develop a static source code analysis method for GOAL agents. Case studies with both techniques show that substantial reductions can be gained when certain conditions are met.Man-Machine Interaction GroupMediamaticsElectrical Engineering, Mathematics and Computer Scienc

Centralized coordination vs. partially-distributed coordination with Reo and constraint automata

High-level concurrency notations and abstractions have several well-known software engineering advantages when it comes to programming concurrency protocols among threads. To also explore their complementary performance advantages, in ongoing work, we are developing compilation technology for a high-level coordination language, Reo, based on this language's formal automaton semantics. By now, as shown in our previous work, our tools are capable of generating code that can compete with carefully handcrafted code, at least for some protocols. An important prerequisite to further advance this promising technology, now, is to gain a better understanding of how the significantly different compilation approaches that we developed so far, which vary in the amount of parallelism in their generated code, compare against each other. For instance, to better and more reliably tune our compilers, we must learn under which circumstances parallel protocol code, with high throughput but also high latency, outperforms sequential protocol code, with low latency but also low throughput. In this paper, we report on an extensive performance comparison between these approaches for a substantial number of protocols, expressed in Reo. Because we have always formulated our compilation technology in terms of a general kind of communicating automaton (i.e., constraint automata), our findings apply not only to Reo but, in principle, to any language whose semantics can be defined in terms of such automata. (C) 2017 Elsevier B.V. All rights reserved

Constraint automata with memory cells and their composition

Highlights • We extend constraint automata to compactly deal with infinite data domains. • We define foundational notions as behavior, equivalence, congruence, composition. • We present a new approach to composing a set of constraint automata. • We compare the new approach to the existing approach in a number of experiments