Wadoud Bousdira

Calculating Parallel Programs in Coq Using List Homomorphisms

SyDPaCC is a set of libraries for the Coq proof assistant. It allows to write naive functional programs (i.e. with high complexity) that are considered as specifications, and to transform them into more efficient versions. These more efficient versions can then be automatically parallelised before being extracted from Coq into source code for the functional language OCaml together with calls to the Bulk Synchronous Parallel ML library. In this paper we present a new core version of SyDPaCC for the development of parallel programs correct-by-construction using the theory of list homomorphisms and algorithmic skeletons implemented and verified in Coq. The framework is illustrated on the maximum prefix sum problem.

Replicated Synchronization for Imperative BSP Programs

Abstract The BSP model (Bulk Synchronous Parallel) simplifies the construction and evaluation of parallel algorithms, with its simplified synchronization structure and cost model. Nevertheless, imperative BSP programs can suffer from synchronization errors. Programs with textually aligned barriers are free from such errors, and this structure eases program comprehension. We propose a simplified formalization of barrier inference as data flow analysis, which verifies statically whether an imperative BSP program has replicated synchronization, which is a sufficient condition for textual barrier alignment.

A verified library of algorithmic skeletons on evenly distributed arrays

To make parallel programming as widespread as parallel architectures, more structured parallel programming paradigms are necessary. One of the possible approaches are algorithmic skeletons. They can be seen as higher order functions implemented in parallel. Algorithmic skeletons offer a simple interface to the programmer without all the details of parallel implementations as they abstract the communications and the synchronisations of parallel activities. To write a parallel program, users have to combine and compose the skeletons. Orleans Skeleton Library (OSL) is an efficient meta-programmed C++ library of algorithmic skeletons that manipulate distributed arrays. A prototype implementation of OSL exists as a library written with the function parallel language Bulk Synchronous Parallel ML (BSML). In this paper we are interested in verifying the correctness of a subset of this prototype implementation. To do so, we give a functional specification of a subset of OSL and we prove the correctness of the BSML implementation with respect to this functional specification, using the Coq proof assistant. To illustrate how the user could use these skeletons, we prove the correctness of two applications implemented with them.

Functional Parallel Programming with Revised Bulk Synchronous Parallel ML

Bulk Synchronous Parallel ML or BSML is a high-level language for programming parallel algorithms. Built upon the Objective Caml language, it provides a safe setting for implementing Bulk Synchronous Parallel (BSP) algorithms. It avoids concurrency related problems: deadlocks and non-determinism. BSML is based on a very small core of parallel primitives that extended functional sequential programming to functional BSP programming with a parallel data structure and operations to manipulate it. However, in practice the primitives for writing the parallel non-communicating parts of the program are not so easy to use. Thus we designed a new syntax that makes programs easier to write and read. Revised BSML is presented and its expressiveness and performance are illustrated through an application example.

On Theorem-Proving in Horn Theories with Built-in Algebras

We present a semi-decision procedure to prove ground theorems in Horn theories with built-in algebras. This is a maximal-unit-strategy based method, i.e in all our inference rules at least one of the premises clauses is an unit one. As in [4], constraint formalism is used as well; but more general specifications are studied. To limit the search space, an rpo-like ordering is used. Neither unification nor matching modulo the predefined algebra is needed. As a result, thanks to available constraint solvers on finite domains, naturals, integers, finite sets,... our method is easy to implement and it is actually efficient to prove ground theorems.

CDR: A Rewriting Based Tool to Design FPLA Circuits

A rewriting based method to design circuits on FPLA electronic devices is presented. It is an improvement of our previous work. In comparison with this latter, the number of boolean vectors generated during the design process is reduced. This is done thanks to new forms of rewriting rules denoting new interesting properties on boolean vectors, associated to boolean products. Only boolean products which are implicants of the circuit to design are computed. Thus, this new design process is more efficient than the previous one.

Formalization of a Big Graph API in Coq

We now live surrounded by sensors, we create information continuously and we leave constantly computer traces of our activities. The processing and analysis of this huge volume data, so called Big Data, offer innumerable and still largely unexplored: health (epidemiology, genomics complex energy networks, intelligent cities, forecasting and management of environmental risks, etc. Big Data has, and will increasingly, a very significant impact at the societal economic and commercial levels. Many interesting Big Data problems can be modeled as problems on graphs/networks.