Enumerated BSP Automata

Abstract

Parallel software needs formal descriptions and mathematically verified tools for its core concepts that are data-distribution and inter-process exchanges or synchronizations. Existing formalisms are either non-specific, like process algebras, or unrelated to standard Computer Science, like algorithmic skeletons or parallel design patterns. This has negative effects on undergraduate training, general understanding and mathematically-verified software tools for scalable programming. To fill a part of this gap, we adapt the classical theory of finite automata to bulk-synchronous parallel computing (BSP) by defining BSP words, BSP automata and BSP regular expressions. BSP automata are built from vectors of finite automata, one per computational unit location. In this first model the vector of automata is enumerated, hence the adjective enumerated in the title. We also show symbolic (intensional) notations to avoid this enumeration. The resulting definitions and properties have applications in the areas of data-parallel programming and verification, scalable data-structures and scalable algorithm design.

Appendices

Appendix 1

1.1 BSP Automaton Versus Product of Automata

The theory of products of automata is developed by Gécseg in [6]. It describes decompositions of finite automata as products of simpler ones, and is closely related to the theory of semigroup decompositions.

A BSP computation is more than a vector of sequential computations, and this is reflected by the fact that a BSP automaton is more than a vector of DFA. This is relatively obvious but we make it here completely explicit by comparing that definition (Definition 2) with that of a product automaton.

Let $A^i = (Q^i, \varSigma , \delta ^i, q_0^i, F^i), i\in [p]$ be a vector of DFA and $A= (A^0, \ldots , A^{p-1}, \varDelta )$ a BSP automaton built from them. Gécseg’s definition (Definition 4.2 in [6]) of machine product applies to Mealy machines i.e. DFA with an output function added. For the purpose of language recognition the output functions are not necessary, so we consider the machine product $\prod _i A^i$ as the Gécseg without outputs. According to Definition 4.2 in [6], $\prod _i A^i$ is a state machine with vector states $\prod _i Q^i$, just like the BSP automaton, a new externally-defined alphabet X, and a special transition function $\delta _\psi$ based on the externally-given function

$$\begin{aligned} \phi : (\prod _i Q^i)\times X \rightarrow \varSigma ^p \end{aligned}$$

such that

$$\begin{aligned} \delta _\psi (<q^0,\ldots ,q^{p-1}>, x) = <\delta ^0(q^0,x^0),\ldots , \delta ^{p-1}(q^{p-1},x^{p-1}) > \end{aligned}$$

where $<x^0,\ldots ,x^{p-1}> = \phi ((<q^0,\ldots ,q^{p-1}>, x)$.

It is trivial to show that the automaton product can simulate the asynchronous parts of a BSP computation. But the structure of $\delta _\psi$ is not the same as a synchronization function $\varDelta$. The product automaton could simulate the BSP automaton but at the expense of an unnatural encoding e.g. $X = (\varSigma ^*)^p \times \prod _i Q^i$ to let $\phi$ distinguish asynchronous versus synchronous applications of $\varDelta$.

But an alphabet which contains states and trace histories is hardly a natural (and low-complexity) encoding. Following this theoretical direction would defeat the purpose of BSP automata that is not the study of algebraic decompositions, or decidability, but rather to investigate programming notations having BSP implementations.

Appendix 2

2.1 Regular Expressions

Regular expressions are a well-known notation for the languages of finite automata. The definitions and properties we state below can be found in every textbook on finite automata for example Chap. 3 of [21]. The languages denoted by regular expressions are called regular, and that class of languages is the same as those recognized by a DFA or its equivalent, non-deterministic variants.

A regular expression is an expression r from the following grammar:

$$ r \;\;\text{::= }\;\; \emptyset \mid \epsilon \mid a \mid r r \mid r* \mid r + r $$

where $a\in \varSigma$ is any symbol from the alphabet. We write $\text{ RE }$ for the set of regular expressions . The language of a regular expression is defined by $L:\text{ RE } \rightarrow \mathcal {P}(\varSigma ^*)$ where function L translates $\emptyset$ to the empty language, $\epsilon$ (resp. a) to a singleton empty word (resp. singleton one-symbol word), $r_1 r_2$ to the concatenation of languages, $r^*$ to $L(r)^* = \bigcup _{n\ge 0} L(r)^n$ and $r_1 + r_2$ to the union of the two languages. The union, concatenation, *-closure of two regular languages is regular. The complement of a regular language is also regular [15].

For $r\in RE$, there exists a NFA A such that $L(A) = L(r)$. A time-optimal quadratic time algorithm for this transformation is described in [3]. It has been improved to a linear-space and parallelisable algorithm in [22]. Both use the Glushkov automation of r whose states are the positions in r’s syntax tree.

Inversely, for A a finite automaton, there exists $r \in RE$ such that $L(r)= L(A)$. The two equivalence properties are called Kleene’s theorems [10].