Synchronization Expressions: Characterization Results and. Implementation. Kai Salomaa y Sheng Yu y. Abstract

Transcription

1 Synchronization Expressions: Characterization Results and Implementation Kai Salomaa y Sheng Yu y Abstract Synchronization expressions are dened as restricted regular expressions that specify synchronization constraints between parallel processes and their semantics is dened using synchronization languages. In this paper we survey results on synchronization languages, in particular various approaches to obtain an exact characterization of this language class using closure properties under a set of rewriting rules or homomorphic characterizations. implementation of synchronization expressions. Also we discuss the 1 Introduction Synchronization expressions (SE's) were originally introduced in the parallel programming language ParC [7] as high-level constructs for specifying synchronization constraints between parallel processes. Synchronization requests are specied as expressions of tags for statements that are to be constrained by the synchronization requirements. The semantics of SE's is dened using synchronization languages. The corresponding synchronization language describes intuitively how an SE is implemented in the parallel programming language ParC. Using this formalism, relations such as equivalence and inclusion between SE's can be easily understood and tested. Thus the synchronization languages provide a systematic approach for the implementation and simplication of SE's in parallel programming languages. A synchronization language can be seen as the set of correct executions (as controlled by the SE) of a distributed application where each action is split into two atomic parts, its start and termination. It can be argued [8, 9] that synchronization languages are a more suitable semantic model for SE's than traditional models such as traces, Petri nets, or process algebra [10, 17]. An important feature of the semantics dened by synchronization languages is that it splits each action into two parts, the start and the termination. For instance, in trace semantics [6] parallel execution is interpreted as a k b = ab + ba, but in order to control the execution of parallel Research supported by the Natural Sciences and Engineering Research Council of Canada Grant OGP y Department of Computer Science, University of Western Ontario, London, Ontario N6A 5B7, Canada 1

2 processes it is necessary to distinguish sequences like ab and ba from real parallel execution. By having the start and termination of an action as separate instantaneous parts such distinctions can be made. Furthermore, synchronization languages can specify that certain occurrences of given processes are parallel whereas other occurrences need to be executed in a specied sequential order. The relationship of and dierences between synchronization languages and the formalisms used in concurrency will be discussed further in [3]. It was shown in [8, 9] that synchronization languages are closed under certain naturally dened rewriting rules and there it was also conjectured that synchronization languages would consist of the subset of regular languages closed under these rules and satisfying the so called start-termination property. The conjecture was proved for languages expressing synchronization between two distinct actions (i.e, for a two-letter alphabet) by Clerbout, Roos and Ryl [5, 13] and furthermore they showed that the conjecture is false in general. We discuss two distinct approaches that have been followed in attempting to obtain an exact characterization of the synchronization languages. By modifying the semantics of SE's [16] considered a new denition of synchronization languages. The new denition has the advantage that it allows us to eliminate the intuitively less well motivated transformations (rewriting rules) describing closure properties of the synchronization languages and the new set of rules always preserves regularity. This approach allows us to obtain an exact characterization at least for the nite synchronization languages in terms of simple semi-commutation rules [16]. However, it remains an open question whether the rewriting rules can be used to characterize synchronization languages in general. Another approach is to extend the set of rewriting rules [13]. The extended system satis- es classical properties of commutation systems, for instance, it enables one to prove a projection lemma. Besides giving rise to interesting questions in formal language theory, synchronization languages provide us with a systematic method for implementing SE's in a parallel programming language such as ParC. In the nal section we discuss the practical implementation of SE's. This gives one more example on the usefulness of the interaction between formal language theory and practical computer science. 2 Synchronization Expressions and Languages We assume that the reader is familiar with the basic notions related to regular expressions and rewriting systems [1, 15, 18]. The set of nite words over a nite alphabet is denoted, is the empty word, and + =? fg. The catenation of languages L 1 ; L 2 is L 1 L 2 = fw 2 j (9v i 2 L i ; i = 1; 2) w = v 1 v 2 g and the catenation of n copies of L is L n (n 0). Note that L 0 = fg. The Kleene star of a language L is L = [ 1 i=0 Li. The shue of words u; v 2 is the language!(u; v) consisting of all words that can be written in the form u 1 v 1 u n v n, n 0, where u = u 1 u n, v = v 1 v n, u i ; v i 2, 2

3 i = 1; : : :; n. The shue operation is extended for languages in the natural way:!(l 1 ; L 2 ) = S w 1 2L 1 ;w 2 2L 2!(w 1 ; w 2 ), where L 1 ; L 2. A string-rewriting system (or Thue system) over is a nite set R of rules u! v, u; v 2. The rules of R dene the (single step) reduction relation! R as follows. For w 1 ; w 2 2, w 1! R w 2 if and only if there exists a rule u 1! u 2 2 R and r; s 2 such that w i = ru i s, i = 1; 2. The reduction relation of R is the reexive and transitive closure of! R and it is denoted! R. We dene synchronization expressions using the extended denition from [16]. The operators!, k, j, & and are called, respectively, the sequencing, join, selection, intersection, and repetition operators. Later we give also the original more restricted denition that diers only in the use of the join operator. The intuitive meaning of the operations will be apparent from the semantic interpretation given below. For easier readability we omit the outermost parentheses of an expression. All the four binary operations will be associative, so usually also other parentheses may be omitted. Let be an alphabet such that each symbol of denotes a distinct process. In order to dene the meaning of synchronization expressions, for each a 2 we associate symbols a s and a t to denote, respectively, the start and termination of the process. Also, we denote s = fa s j a 2 g; t = fa t j a 2 g: The synchronization languages satisfy the condition that the start of an occurrence of a process always precedes the termination of the same occurrence. The condition is dened formally as follows. For a 2 let p a : ( s [ t )?! fa s ; a t g be the morphism determined by the conditions ( x; if x 2 fas ; a t g; p a (x) = ; if x 62 fa s ; a t g: A word w 2 ( s [ t ) is said to satisfy the start-termination condition (or st-condition for short) if for all a 2, p a (w) 2 (a s a t ). If w satises the st-condition, then w belongs to the shue of languages ((a 1 ) s (a 1 ) t ),..., ((a k ) s (a k ) t ) where a i 2, i = 1; : : :k. The set of all words over satisfying the st-condition is denoted W st called st-languages. st and subsets of W The synchronization expressions 2 SE() and the languages denoted by the expressions are dened inductively as follows. Denition 2.1 The set of synchronization expressions over an alphabet, SE(), is the smallest subset of ( [ f;!; &; j; k; ; (; )g) dened inductively by the following rules. The synchronization language denoted by 2 SE() is L(). (i) [ fg SE(). L() = ; and L(a) = fa s a t g when a 2. (ii) If 1 ; 2 2 SE() then ( 1! 2 ) 2 SE() and L( 1! 2 ) = L( 1 ) L( 2 ). are 3

4 (iii) If 1 ; 2 2 SE() then ( 1 k 2 ) 2 SE() and L( 1 k 2 ) =!(L( 1 ); L( 2 )) \ W st. (iv) If 1 ; 2 2 SE() then ( 1 j 2 ) 2 SE() and L( 1 j 2 ) = L( 1 ) [ L( 2 ). (v) If 1 ; 2 2 SE() then ( 1 & 2 ) 2 SE() and L( 1 & 2 ) = L( 1 ) \ L( 2 ). (vi) If 2 SE() then 2 SE() and L( ) = L(). The original denition of synchronization expressions required that the expressions appearing as arguments of the parallelization operator must be over disjoint alphabets. The set of restricted synchronization expressions, SE r (), is dened as in Denition 2.1 by substituting SE r () everywhere for SE() and modifying the condition (iii) as follows. We denote by alph() the set of symbols of appearing in the expression. (alph() can naturally be dened inductively following Denition 2.1.) (iii)' If 1 ; 2 2 SE r () and alph( 1 ) \ alph( 2 ) = ; then ( 1 k 2 ) 2 SE ( ) and L( 1 k 2 ) =!(L( 1 ); L( 2 )). When dening the interpretation of the parallelization operator in Denition 2.1 we use intersection with the set of st-words. If we would allow arbitrary shues, this would produce words like a s a s a t a t that do not have any meaningful interpretation. In restricted synchronization expressions, always when 1 k 2 is dened every word of!(l( 1 ); L( 2 )) satises the st-condition so actually we do not need the intersection with the set W st. The family of synchronization languages L(SE) (respectively, restricted synchronization languages L(SE r )) consists of all languages L() where alpha 2 SE() (respectively, alpha 2 SE r ()) for some alphabet. Directly from the denition it follows that L(SE r ) L(SE). Furthermore, the inclusion is strict since, for instance, the expression (b! a ) k (a! c) denotes a language that is not a restricted synchronization language [13, 16]. 3 Partial Characterization Results Synchronization languages are regular languages satisfying the st-condition and furthermore they are closed under certain types of semi-commutation rules and their extensions. It would be very useful if we could exactly characterize the synchronization languages in terms of closure under some simple rewriting rules. A characterization could yield more ecient algorithms for testing the equivalence of SE's since in many cases it would be easy to test whether a give nite automaton accepts a language satisfying the given semi-commutation properties. Denition 3.1 Let be an alphabet. We dene the rewriting system R ( s [ t ) ( s [ t ) to consist of the following rules, where a; b 2, a 6= b: 4

5 (i) a s b t! b t a s, (ii) a s b s! b s a s, (iii) a t b t! b t a t. The set S is dened to consist of all rules (1) (a 1 ) t (a i ) t (a 1 ) s (a i ) s (b 1 ) t (b j ) t (b 1 ) s (b j ) s! (b 1 ) t (b j ) t (b 1 ) s (b j ) s (a 1 ) t (a i ) t (a 1 ) s (a i ) s ; where where a 1 ; : : :; a i ; b 1 ; : : :; b j are pairwise distinct elements of, i; j 1. Then we denote R 0 = R [ S : Note that the rules R dene a semi-commutation relation on [4]. By symmetry the rules (i) and (ii) could be written also as two-directional rules. If R is a rewriting system over and L we denote R (L) = fu 2 j (9v 2 L)v! R ug. We say that L is closed under R if L = R (L). The following results hold. Theorem 3.1 Let L. (a) [16] If L is a synchronization language, then L is closed under R. (b) [8, 9] If L is a restricted synchronization language, then L is closed under R 0. The intuitive explanation why restricted synchronization languages are closed also under rules (1) is that if we have a subword of the form : : : a t a s b t b s : : : (or the given more general form), then all the following pairs of the given occurrences of the symbols are parallel: (a t ; b t ), (a s ; b s ) and (a s ; b t ), i.e., they correspond to symbols occuring in dierent arguments of the parallelization operator. On the other hand, since the dierent arguments may not contain occurrences of the same symbol of, the only possibility is that the symbols a t ; a s correspond to occurrences in one of the arguments, and b t ; b s in the other argument. It was conjectured [9] that closure under the rewriting system R 0 together with the st-condition exactly characterizes the restricted synchronization languages. The conjecture was proved in [5] for alphabets corresponding to two actions. Theorem 3.2 [5] A language L fa s ; a t ; b s ; b t g is a restricted synchronization language if and only if L is regular, satises the st-condition and is closed under R 0. At the same time [5, 13] established that the conjecture does not hold in general. The counterexample given there is the language L 1 = R 0 (b s (a s a t ) c s b t (a s a t ) c t ) 5

6 which is a regular st-language and it can be shown that L 1 is not a restricted synchronization language. The intuitive idea is that restricted synchronization expressions cannot dierentiate in L 1 between instances of the action a that occur during b and during c, respectively. Formally the fact that L 1 62 L(SE r ) is proved by establishing a so called switching property for restricted synchronization languages [5, 13]. Another undesirable property of the restricted synchronization languages is that the corresponding rewriting rules (1) do not, in general, preserve regularity of st-languages. Consider the language L 2 = a s b s (a t a s b t b s ) b t a t. Using the rule a t a s b t b s! b t b s a t a s (and the semi-commutation rules of Denition 3.1) every word of L 2 can be rewritten to a word (b s b t ) m (a s a t ) m+1, and this observation easily implies that R 0 (L 2 ) is not regular. For the above reasons it is natural to consider the more general denition of SE's given in Denition 2.1. This allows us to drop the rules (1) from the rewriting system describing closure properties of the synchronization languages Using the fact that the rules (i){(iii) of Denition 3.1 are semi-commutations and the general properties of semi-commutations [4] we can prove: Proposition 3.1 [16] If L ( s [ t ) is a regular st-language, then R (L) is also regular. Also using the more general denition, in the case of nite languages we can strengthen the result of Theorem 3.1(a) into an \if and only if" condition. Theorem 3.3 [16] Assume that L is a nite language over s [ t. Then L 2 L(SE) if and only if L is an st-language closed under R. We conjecture that in general a regular st-language is a synchronization language if and only if it is closed under R, i.e., that we could drop the niteness condition from Theorem 3.1. However, we do not have a proof for this conjecture. 4 Implementation of SEs in concurrent programming languages In this section, we explain how the ideas of SEs and SLs can be used and implemented in a programming language that is designed for a parallel or/and distributed computing environment. The implementation strictly follows our semantic interpretation of SEs using SLs. More specically, for an SE, we construct a nite automaton that accepts the prex language of the SL denoted by the SE at compile time. Then the constructed automaton is used to impose the synchronization constraints specied by the SE at runtime. In the following, we will use examples written in the ParC concurrent programming language [7]. The examples will be explained in detail assuming that the reader knows the C programming language but not ParC. In ParC, (simple or compound) statements are considered as the basic elements of synchronization. Statements that are involved in synchronization are represented in 6

7 SEs by statement tags. In other words, the alphabet of an SE is a set of statement tags. This is a design decision specic to ParC and need not be true in general. Especially in an objectoriented concurrent programming language, it may be more appropriate that object operations rather than statements should be the basic elements of synchronization specied by SEs. However, the implementation principle described below would still be applicable as long as a symbol in an SE represents an entire execution of a process. We provide in the following a simple example to show how a ParC program with synchronization expressions is translated into a Sequent C program with system calls [12]. We rst give the ParC program with a detailed explanation. Then we give the generated code in Sequent C with system calls. main(){ shared int w; int r; int f(); tag a, b; restrict (a->b)*; pexec{ {/*... */ b:: r = w; /*... */ {/*... */ a:: w = f(); /*... */ We rst look at the pexec statement, i.e., the parallel execution statement. This language construct denotes that all statements that are directly under the scope can be executed in parallel. In the above program, there are two compound statements directly under the pexec statement, which can be considered as two parallel processes. In the rst process, the statement \r = w;" is tagged with b, and in the second process, \w = f();" is tagged with a. We assume that each of the two statements is in a loop. The restrict statement above the pexec statement species a synchronization expression (a->b)*, meaning that the a and b statements can be executed only in the following sequence: a, b, a, b, : : :, i.e., the ith instance of b cannot start its execution before 7

8 the ith instance of a nishes and the (i + 1)th instance of a cannot start its execution before the ith instance of b nishes, i 1. Also in the declarations, w is declared as a shared integer variable, which means that the two appearances of w in the two parallel processes, respectively, are the same variable. The integer variable i is not shared. So, it has dierent copies in dierent parallel processes in the scope. And the statement tag a, b; declares that both a and b are statement tags. An deterministic nite automaton (DFA) is built according to the SE a->b, which accepts the prex language of the SL dened by the SE. The DFA is shown in Figure 1. b t init as at bs Figure 1: DFA for the SE (a->b)* To ensure that the the state update can only be performed exclusively by one process, we build a macro called wait and set(int state; int i 1 ; j 1 ; : : :; int i n ; j n ). for n > 0. The macro waits until the condition \state == i t ", for some t, 1 t n, becomes true and then sets \state = j t ". Instead of using a variable-length list int i 1 ; j 1 ; : : :; int i n ; j n, the actual implementation of wait and set may use a pointer to a table (an array) for the transitions. Here. we use the list for easy to comprehend. The macro is an indivisible (exclusive) operation and can be implemented using primitive synchronization mechanisms of the system. Then the state transitions of the DFA correspond to the following Sequent C statements or macros: Initialization state = 1; The a s transition wait and set( state; 1, 2); The a t transition wait and set( state; 2, 3); The b s transition wait and set( state; 3, 4); 8

9 The b t transition wait and set( state; 4, 1); The following is the code generated from the ParC program: #include<parallel/microtask.h> #include<parallel/parallel.h> #include<sys/wait.h> #include<sys/types.h> #include<stdio.h> main() { shared int w; int k, r; shared int _state=1; int f(); { int _pw, _pid; if ((_pid=fork()) == 0){ /*... */ wait_and_set(_state; 3, 4); r = w; wait_and_set(_state; 4, 1); /*... */ exit(0); else if (_pid < 0){ printf("fork error\n"); exit(1); /*... */ wait_and_set(_state; 1, 2); w = f(k); wait_and_set(_state; 2, 3); /*... */ 9

10 For a slightly more complicated SE \(a b)->c", a corresponding DFA is shown in Figure 2. init 1 a s b s 2 3 a t a s b t 5 b s b a s t 7 b t 4 b t 6 a s 8 a t 9 cs 10 ct 11 Figure 2: DFA for the SE (a b)->c Then the code generated for the a statement would be wait_and_set(_state; 1, 2; 3, 4; 6, 8);... /* the a statement itself */ wait_and_set(_state; 2, 5; 4, 7; 8, 9); Similarly, the code generated for b statement would be wait_and_set(_state; 1, 3; 2, 4; 5, 7);... /* the b statement itself */ wait_and_set(_state; 3, 6; 4, 8; 7, 9); And the following is the code for c: wait_and_set(_state; 9, 10);... /* the c statement itself */ wait_and_set(_state; 10, 11); With the above two simple examples, the basic idea of implementing SEs using SLs should be clear. There are many other issues concerning implementation. We mention several of them briey in the following. The rst is the size-explosion problem of DFA. For many practical synchronization problems, the sizes of the DFA can be too large to implement. We suggest the use of alternating nite automata (AFA) [2, 11] instead of DFA in the implementation of SE. The use of AFA can signicantly increase the space eciency. The checking of states may become the bottleneck of synchronization since it is done sequentially. This is not necessarily true. Note that SEs within dierent concurrent blocks, respectively, can be implemented by automata that actually run concurrently. 10

11 Conicting synchronization constraints and deadlock conditions caused by the denitions of SEs in the same scope can be examined by checking the intersection of the SLs dened by the SEs and the execution sequences dened by the program ow. The precise semantic denition of SEs makes such checking conceptually clear and practically possible to implement. References [1] R. V. Book, F. Otto: String-Rewriting Systems, Texts and Monographs in Computer Science, Springer-Verlag, [2] H. Cheung, K. Salomaa, X. Wu, S. Yu: An Ecient Implementation of Regular Languages Using r-afa. Proceedings of the Second International Workshop on Implementing Automata (WIA'97) 1997, [3] G. Ciobanu, K. Salomaa, S. Yu: Synchronization languages and ST semantics, manuscript in preparation. [4] M. Clerbout, M. Latteux and Y. Roos, Semi-commutations. In: The Book of Traces. (V. Diekert, G. Rozenberg, eds.) Chapter 12, pp. 487{552, World Scientic, Singapore, [5] M. Clerbout, Y. Roos, I. Ryl: Synchronization languages. Theoret. Comput. Sci., to appear. [6] V. Diekert and Y. Metivier, Partial commutation and traces. In: Handbook of Formal Languages, Vol. III. (G. Rozenberg, A. Salomaa, eds.) pp. 457{533, Springer-Verlag, [7] R. Govindarajan, L. Guo, S. Yu and P. Wang, ParC Project: Practical constructs for parallel programming languages. Proc. of the 15th Annual IEEE International Computer Software & Applications Conference, 1991, pp. 183{189. [8] L. Guo, K. Salomaa and S. Yu, Synchronization expressions and languages. Proc. of the 6th IEEE Symposium on Parallel and Distributed Processing, (Dallas, Texas). IEEE Computer Society Press, 1994, pp. 257{264. [9] L. Guo, K. Salomaa and S. Yu, On synchronization languages. Fundamenta Inform. 25 (1996) 423{436. [10] M. Hennessy: Algebraic Theory of Processes, The MIT Press, Cambridge, Mass., [11] S. Huerter, K. Salomaa, X. Wu, S. Yu: Implementing Reversed Alternating Finite Automaton (r-afa) Operations. Proceedings of the Third International Workshop on Implementing Automata (WIA'98) 1998,

12 [12] A. Osterhaug edited: Guide to Parallel Programming On Sequent Computer Systems, Prentice Hall, Englewood Clis, New Jersey, [13] I. Ryl, Y. Roos, M. Clerbout: Partial characterization of synchronization languages. Proc. of 22nd International Symposium on Mathematical Foundations of Computer Science (MFCS'97), Lect. Notes Comput. Sci (1997) 209{218. [14] I. Ryl, Y. Roos, M. Clerbout: About synchronization languages. Proc. of 23rd International Symposium on Mathematical Foundations of Computer Science (MFCS'98), Lect. Notes Comput. Sci (1998) 533{542. [15] A. Salomaa: Formal Languages, Academic Press, [16] K. Salomaa, S. Yu: Synchronization expressions with extended join operation. Theoret. Comput. Sci. 207 (1998) 73{88. [17] V. Sassone, M. Nielsen, G. Winskel: Models of concurrency: Towards a classication, Theoret. Comput. Sci. 170 (1996) 297{348. [18] S. Yu, Regular languages. In: Handbook of Formal Languages, Vol. I. (G. Rozenberg, A. Salomaa, eds.) pp. 41{110, Springer-Verlag,