93 research outputs found
Parallelizing Deadlock Resolution in Symbolic Synthesis of Distributed Programs
Previous work has shown that there are two major complexity barriers in the
synthesis of fault-tolerant distributed programs: (1) generation of fault-span,
the set of states reachable in the presence of faults, and (2) resolving
deadlock states, from where the program has no outgoing transitions. Of these,
the former closely resembles with model checking and, hence, techniques for
efficient verification are directly applicable to it. Hence, we focus on
expediting the latter with the use of multi-core technology.
We present two approaches for parallelization by considering different design
choices. The first approach is based on the computation of equivalence classes
of program transitions (called group computation) that are needed due to the
issue of distribution (i.e., inability of processes to atomically read and
write all program variables). We show that in most cases the speedup of this
approach is close to the ideal speedup and in some cases it is superlinear. The
second approach uses traditional technique of partitioning deadlock states
among multiple threads. However, our experiments show that the speedup for this
approach is small. Consequently, our analysis demonstrates that a simple
approach of parallelizing the group computation is likely to be the effective
method for using multi-core computing in the context of deadlock resolution
08332 Abstracts Collection -- Distributed Verification and Grid Computing
From 08/10/2008 to 08/14/2008 the Dagstuhl Seminar 08332 ``Distributed Verification and Grid Computing\u27\u27 was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl.
During the seminar, several participants presented their current
research, and ongoing work and open problems were discussed. Abstracts of
the presentations given during the seminar as well as abstracts of
seminar results and ideas are put together in this paper. The first section
describes the seminar topics and goals in general.
Links to extended abstracts or full papers are provided, if available
The design of a neural network compiler
Computer simulation is a flexible and economical way for
rapid prototyping and concept evaluation with Neural
Network (NN) models. Increasing research on NNs has led
to the development of several simulation programs. Not
all simulations have the same scope. Some simulations
allow only a fixed network model and some are more
general. Designing a simulation program for general
purpose NN models has become a current trend nowadays
because of its flexibility and efficiency. A proper
programming language specifically for NN models is
preferred since the existing high-level languages such as
C are for NN designers from a strong computer background.
The program translations for NN languages come from
combinations which are either interpreter and/or
compiler. There are also various styles of programming
languages such as a procedural, functional, descriptive
and object-oriented.
The main focus of this thesis is to study the
feasibility of using a compiler method for the
development of a general-purpose simulator - NEUCOMP that
compiles the program written as a list of mathematical
specifications of the particular NN model and translates
it into a chosen target program. The language supported
by NEUCOMP is based on a procedural style. Information
regarding the list of mathematical statements required by
the NN models are written in the program. The
mathematical statements used are represented by scalar,
vector and matrix assignments. NEUCOMP translates these
expressions into actual program loops.
NEUCOMP enables compilation of a simulation program
written in the NEUCOMP language for any NN model,
contains graphical facilities such as portraying the NN
architecture and displaying a graph of the result during
training and finally to have a program that can run on a
parallel shared memory multi-processor system
Concurrent Bounded Model Checking
The Definitive Version can be found in the ACM Digital Library here: http://dx.doi.org/10.1145/2693208.2693240issue_date: January 2015 numpages: 5 acmid: 2693240 keywords: Bounded Model Checking, Concurrency, Symbolic Executionissue_date: January 2015 numpages: 5 acmid: 2693240 keywords: Bounded Model Checking, Concurrency, Symbolic Executionissue_date: January 2015 numpages: 5 acmid: 2693240 keywords: Bounded Model Checking, Concurrency, Symbolic Executio
Learning port-Hamiltonian systems -- algorithms
In this article we study the possibilities of recovering the structure of
port-Hamiltonian systems starting from ``unlabelled'' ordinary differential
equations describing mechanical systems. The algorithm we suggest solves the
problem in two phases. It starts by constructing the connectivity structure of
the system using machine learning methods -- producing thus a graph of
interconnected subsystems. Then this graph is enhanced by recovering the
Hamiltonian structure of each subsystem as well as the corresponding ports.
This second phase relies heavily on results from symplectic and Poisson
geometry that we briefly sketch. And the precise solutions can be constructed
using methods of computer algebra and symbolic computations. The algorithm
permits to extend the port-Hamiltonian formalism to generic ordinary
differential equations, hence introducing eventually a new concept of normal
forms of ODEs.Comment: to appear in Computational Mathematics and Mathematical Physics, 1,
202
LTSmin: high-performance language-independent model checking
In recent years, the LTSmin model checker has been extended with support for several new modelling languages, including probabilistic (Mapa) and timed systems (Uppaal). Also, connecting additional language front-ends or ad-hoc state-space generators to LTSmin was simplified using custom C-code. From symbolic and distributed reachability analysis and minimisation, LTSmin’s functionality has developed into a model checker with multi-core algorithms for on-the-fly LTL checking with partial-order reduction, and multi-core symbolic checking for the modal μ calculus, based on the multi-core decision diagram package Sylvan.\ud
In LTSmin, the modelling languages and the model checking algorithms are connected through a Partitioned Next-State Interface (Pins), that allows to abstract away from language details in the implementation of the analysis algorithms and on-the-fly optimisations. In the current paper, we present an overview of the toolset and its recent changes, and we demonstrate its performance and versatility in two case studies
07241 Abstracts Collection -- Tools for the Model-based Development of Certifiable, Dependable Systems
From June 10th to June 15th 2007, the
Dagstuhl Seminar 07241 ``Tools for the Model-based Development of Certifiable, Dependable Systems\u27\u27 was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl.
During the seminar, several participants presented their current
research, and ongoing work and open problems were discussed. Abstracts of
the presentations given during the seminar as well as abstracts of
seminar results and ideas are put together in this paper. The first section
describes the seminar topics and goals in general.
Links to extended abstracts or full papers are provided, if available
HPC-GAP: engineering a 21st-century high-performance computer algebra system
Symbolic computation has underpinned a number of key advances in Mathematics and Computer Science. Applications are typically large and potentially highly parallel, making them good candidates for parallel execution at a variety of scales from multi-core to high-performance computing systems. However, much existing work on parallel computing is based around numeric rather than symbolic computations. In particular, symbolic computing presents particular problems in terms of varying granularity and irregular task sizes thatdo not match conventional approaches to parallelisation. It also presents problems in terms of the structure of the algorithms and data.
This paper describes a new implementation of the free open-source GAP computational algebra system that places parallelism at the heart of the design, dealing with the key scalability and cross-platform portability problems. We provide three system layers that deal with the three most important classes of hardware: individual shared memory
multi-core nodes, mid-scale distributed clusters of (multi-core) nodes, and full-blown HPC systems, comprising large-scale tightly-connected networks of multi-core nodes. This requires us to develop new cross-layer programming abstractions in the form of new domain-specific skeletons that allow us to seamlessly target different hardware levels. Our results show that, using our approach, we can achieve good scalability and speedups for two realistic exemplars, on high-performance systems comprising up to 32,000 cores, as well as on ubiquitous multi-core systems and distributed clusters. The work reported here paves the way towards full scale exploitation of symbolic computation by high-performance computing systems, and we demonstrate the potential with two major case studies
Replicable parallel branch and bound search
Combinatorial branch and bound searches are a common technique for solving global optimisation and decision problems. Their performance often depends on good search order heuristics, refined over decades of algorithms research. Parallel search necessarily deviates from the sequential search order, sometimes dramatically and unpredictably, e.g. by distributing work at random. This can disrupt effective search order heuristics and lead to unexpected and highly variable parallel performance. The variability makes it hard to reason about the parallel performance of combinatorial searches.
This paper presents a generic parallel branch and bound skeleton, implemented in Haskell, with replicable parallel performance. The skeleton aims to preserve the search order heuristic by distributing work in an ordered fashion, closely following the sequential search order. We demonstrate the generality of the approach by applying the skeleton to 40 instances of three combinatorial problems: Maximum Clique, 0/1 Knapsack and Travelling Salesperson. The overheads of our Haskell skeleton are reasonable: giving slowdown factors of between 1.9 and 6.2 compared with a class-leading, dedicated, and highly optimised C++ Maximum Clique solver. We demonstrate scaling up to 200 cores of a Beowulf cluster, achieving speedups of 100x for several Maximum Clique instances. We demonstrate low variance of parallel performance across all instances of the three combinatorial problems and at all scales up to 200 cores, with median Relative Standard Deviation (RSD) below 2%. Parallel solvers that do not follow the sequential search order exhibit far higher variance, with median RSD exceeding 85% for Knapsack
- …