Reinhard v. Hanxleden 1, Michael Mendler 2, J. Aguado 2, Björn Duderstadt 1, Insa Fuhrmann 1, Christian Motika 1, Stephen Mercer 3 and Owen Brian 3

Transcription

1 Sequentially Constructive Concurrency * A conservative extension of the Synchronous Model of Computation Reinhard v. Hanxleden, Michael Mendler 2, J. Aguado 2, Björn Duderstadt, Insa Fuhrmann, Christian Motika, Stephen Mercer 3 and Owen Brian 3 * to appear at DATE, Grenoble, March 23 University of Kiel, 2 University of Bamberg, 3 National Instruments von Hanxleden, et al. Synchron 22, Port aux Rocs, 2..2

2 Motivation (Taming Concurrency) Synchronous Languages Esterel, Lustre, Signal, Clocked, cyclic schedule by default: single iter per cycle, all reads initialised on demand: separate multiple assignments by clock barrier (pause, wait) Declarative all micro-step sequential control flow descriptive resolved by scheduler Sequential Languages C, Java, Asynchronous schedule by default: multiple concurrent readers/iters on demand: single assignment synchronisation (locks, semaphores) Imperative all sequential control flow prescriptive resolved by programmer von Hanxleden, et al. Synchron 22, Port aux Rocs,

3 Motivation (Taming Concurrency) Synchronous Languages Esterel, Lustre, Signal, Clocked, cyclic schedule deterministic concurrency and deadlock freedom Heavy restrictions by constructiveness analysis Sequential Languages C, Java, Asynchronous schedule No guarantees of determinism or deadlock freedom Intuitive programming paradigm Sequentially Constructive Model of Computation (SC MoC) all micro-step concurrent control flow descriptive resolved by scheduler all micro-step sequential control flow is prescriptive resolved by programmer von Hanxleden, et al. Synchron 22, Port aux Rocs,

4 Outline. Example 2. Threads and Concurrency 3. Sequential Constructiveness (SC) 4. Analysing SC 5. Notions of Constructiveness

5 A Sequentially Constructive Program Control Threads checkreq Request grant Dispatch req pend grant free von Hanxleden, et al. Synchron 22, Port aux Rocs,

6 A Sequentially Constructive Program Control checkreq grant req pend grant free von Hanxleden, et al. Synchron 22, Port aux Rocs,

7 A Sequentially Constructive Program F T F F T Imperative Program Order (Sequential access to share variables): ite-after-ite can change value sequentially (multi-iter) fully deterministic at thread level but not permitted in standard synchronous MoC von Hanxleden, et al. Synchron 22, Port aux Rocs,

8 A Sequentially Constructive Program SC MoC: Intra-instant (micro-step) thread scheduling prohibits race conditions... Concurrency Scheduling Constraints (access to shared variables): ite-before-read for concurrent ite/reads ite-before-ite for concurrent & conflicting ites (see later) von Hanxleden, et al. Synchron 22, Port aux Rocs,

9 Outline. Example 2. Threads and Concurrency 3. Sequential Constructiveness (SC) 4. Analysing SC 5. Notions of Constructiveness

10 Sequential Concurrent Program Graph (SCG) entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

11 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

12 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

13 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

14 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

15 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

16 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

17 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

18 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

19 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

20 Intra-Instant Concurrency entry exit von Hanxleden, et al. Synchron 22, Port aux Rocs,

21 Intra-Instant Concurrency Definition: Two node instances and are concurrent in a macro tick, denoted, iff they appear in the micro ticks of they belong to statically concurrent threads their threads have been instantiated by the same instance of the associated least common ancestor fork. von Hanxleden, et al. Synchron 22, Port aux Rocs,

22 Outline. Example 2. Threads and Concurrency 3. Sequential Constructiveness (SC) 4. Analysing SC 5. Notions of Constructiveness

23 Sequential Admissibility Remember Sequentially ordered variable accesses exhibit no races cannot be reordered by the compiler Only concurrent ites to the same variable generate potential data data races must be resolved by the compiler can be ordered under multi-threading The following applies to concurrent variable accesses only... von Hanxleden, et al. Synchron 22, Port aux Rocs,

24 Organising Concurrent Variable Accesses concurrent, single iter, multi reader variables identical absolute ites confluent relative ites reads von Hanxleden, et al. Synchron 22, Port aux Rocs,

25 Types of Writes Given two ites to x, distinguish Confluent ites, where the order of the ites does not matter This implies that there are no side effects Non-confluent ites, where the order of the ites matters Given one ite to x, distinguish Absolute ites ( initialisation ) x = e Expression e does not constitute relative ite (see below) Eg, x =, x = 2*y + 5, x = f(z) Relative ites ( increments ) x = f(x, e) Combination function f such that f(f(x, e ), e 2 ) = f(f(x, e 2 ), e ) Hence schedules "x = f(x, e ); x = f(x, e 2 )" and "x = f(x, e 2 ); x = f(x, e )" yield same result for x the ites are confluent Sufficient condition: f is a commutative and associative Eg, x++, x = 5*x, x = x Also distinguish Effective ites, which change value of x Ineffective ites, that do not change value of x von Hanxleden, et al. Synchron 22, Port aux Rocs,

26 Sequential Admissibility Definition: A run for a SCG G = (N,E) is S-admissible if, for all ticks in this run, and for all concurrent node instances (n, i ), (n 2, i 2 ), with i i 2 and n R n 2 none of the following occurs: n and n 2 perform non-confluent ites on the same variable n reads a variable, on which n 2 then performs an effective ite n performs a relative ite to a variable, on which n 2 then performs an absolute ite. von Hanxleden, et al. Synchron 22, Port aux Rocs,

27 Sequential Constructiveness The existence of an S-admissible run does not guarantee by itself determinism! if!x entry x = false; y = false true y = true exit if!y true x = true This program has two S-admissible runs. Depending on which conditional is scheduled first, The resulting memory would be either: [x=true, y=false] or [x=false, y=true] von Hanxleden, et al. Synchron 22, Port aux Rocs,

28 Sequential Constructiveness Definition: A program is sequentially constructive (SC) if for each initial configuration and input:. there exists an S-admissible run 2. every S-admissible run generates the same, determinate sequence of macro responses in bounded time. von Hanxleden, et al. Synchron 22, Port aux Rocs,

29 Outline. Example 2. Threads and Concurrency 3. Sequential Constructiveness (SC) 4. Analysing SC 5. Notions of Constructiveness

30 Conservative Static Approximation Use a relation n j n 2 to over-approximate n j R n 2, i.e., what statements are concurrently invoked in the same tick, by considering only static control flow, or ignoring dependency on initial conditions, or by falsely considering nodes to be in the same tick. Over-approximate what ites are relative and confluent absolute and confluent by not evaluating expressions (combination function). von Hanxleden, et al. Synchron 22, Port aux Rocs,

31 Analysing Sequential Constructiveness In addition to and the following static node relations are introduced: iff and there exists a variable on which and perform non-confluent ites (e.g., non-identical absolute ites or relative ites with different combination function). iff and performs an absolute ite to a variable that is read by. iff and performs an absolute ite to a variable on which performs a relative ite. von Hanxleden, et al. Synchron 22, Port aux Rocs,

32 Analysing Sequential Constructiveness iff and performs an relative ite to a variable that is read by. iff or or. This contains the constraints induced by concurrent ite/increment/read accesses. iff or that is, if there is any control-flow or concurrent-access-induced ordering constraints. von Hanxleden, et al. Synchron 22, Port aux Rocs,

33 Analysing Sequential Constructiveness Definition: A program is acyclic SC (ASC) schedulable if in its SCG:. There are no statement nodes, with 2. There is no cycle that contains edges induced by. Lemma: Every ASC schedulable program is sequentially constructive. For a ASC program, an S-admissible schedule is one which executes concurrent statements in the order induced by!. Such schedule may be implemented by associating a priority with each statement node... von Hanxleden, et al. Synchron 22, Port aux Rocs,

34 Analysing Sequential Constructiveness Priorities and S-admissible schedule: checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface priority priority surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

35 Analysing Sequential Constructiveness Priorities and S-admissible schedule: checkreq = req grant = false pend && grant checkreq && free true pend = false surface true grant = true surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

36 Analysing Sequential Constructiveness Priorities and S-admissible schedule: checkreq = req grant = false pend && grant checkreq && free true pend = false true grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

37 Analysing Sequential Constructiveness Priorities and S-admissible schedule: checkreq = req grant = false pend && grant checkreq && free true pend = false true grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

38 Analysing Sequential Constructiveness Priorities and S-admissible schedule: checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

39 Analysing Sequential Constructiveness Priorities and S-admissible schedule: 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

40 Analysing Sequential Constructiveness Priorities and S-admissible schedule: (variables are true initially) 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

41 Analysing Sequential Constructiveness Priorities and S-admissible schedule: (variables are true initially) 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

42 Analysing Sequential Constructiveness Priorities and S-admissible schedule: (variables are true initially) 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

43 Analysing Sequential Constructiveness Priorities and S-admissible schedule: (variables are true initially) 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

44 Analysing Sequential Constructiveness Priorities and S-admissible schedule: (variables are true initially) 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

45 Analysing Sequential Constructiveness Priorities and S-admissible schedule: (variables are true initially) 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

46 Analysing Sequential Constructiveness Priorities and S-admissible schedule: (variables are true initially) 2 checkreq = req grant = false pend && grant checkreq && free true true pend = false grant = true surface surface von Hanxleden, et al. Synchron 22, Port aux Rocs,

47 Analysing Sequential Constructiveness Lemma: A program is ASC schedulable if in its SCG:. There are no statement nodes, with. 2. All statement priorities are finite. ) Longest Weighted Path Problem NP hard in presence of non-zero weighted cycles However: non-zero cycles indicate causality problem (reject) ASC constructive programs have zero cycles factorises: (a) Strongly Connected Components, (b) Max Path in DAG ) linear complexity von Hanxleden, et al. Synchron 22, Port aux Rocs,

48 Outline. Example 2. Threads and Concurrency 3. Sequential Constructiveness (SC) 4. Analysing SC 5. Notions of Constructiveness

49 A Game of Constructiveness and Schedulability logically reactive program programmer compiler run-time system Programmer defines the rules prescribes sequential execution order leaves concurrency to compiler and run time Free Schedules deadlocks, oscillation, non-determinism, metastability Compiler = Player determines winning strategy restricts concurrency to ensure determinacy and deadlock freedom Admissible Schedules Run-time = Opponent tries to choose a spoiling execution from admissible schedules von Hanxleden, et al. Synchron 22, Port aux Rocs,

50 X-Constructiveness Definition: A program is X-constructive (XC) if for each initial configuration and input:. there exists an X-admissible run 2. every X-admissible run generates the same, determinate sequence of macro step responses in bounded time. von Hanxleden, et al. Synchron 22, Port aux Rocs,

51 Alternative Notions of Constructiveness Cyclic concurrent dependencies. Concurrent ites S constructive Static cycles, dynamic scheduling Speculate on absence P constructive B constructive Ineffective ites Speculate on absence or presence L constructive Out-of-order schedule von Hanxleden, et al. Synchron 22, Port aux Rocs,

52 Alternative Notions of Constructiveness S constructive Static cycles, dynamic scheduling Acyclic S constructive Sequence of values All programs without the fork-par-join operator are S constructive but many fail to be B constructive B constructive von Hanxleden, et al. Synchron 22, Port aux Rocs,

53 Alternative Notions of Constructiveness S constructive Static cycles, dynamic scheduling If (x) then x = Acyclic S constructive Sequence of values If (!x) then x = If (x & y) then x = If (x) then x = else x = B constructive P constructive L constructive von Hanxleden, et al. Synchron 22, Port aux Rocs,

54 Alternative Notions of Constructiveness S constructive Static cycles, dynamic scheduling Acyclic S constructive Sequence of values fork y = x par if (!x) then x = join B constructive P constructive L constructive von Hanxleden, et al. Synchron 22, Port aux Rocs,

55 Alternative Notions of Constructiveness S constructive Static cycles, dynamic scheduling fork if (x) then y = z par if (!x) then z = y join Acyclic S constructive Sequence of values B constructive von Hanxleden, et al. Synchron 22, Port aux Rocs,

56 Alternative Notions of Constructiveness S constructive Static cycles, dynamic scheduling fork if (x) then y = z par if (!x) then z = y join Acyclic S constructive Sequence of values B constructive x = ; fork if (x) then y = par if (y) then x = join von Hanxleden, et al. Synchron 22, Port aux Rocs,

57 Conclusion This Talk Clocked synchronous model of execution for imperative, shared-memory multi-processing Recovers and relaxes Esterel-style synchrony Future Plans Full-scale implementation within PRETSY (Precision-timed Synchronous Processing) Develop approximating algorithms for SC-analysis: Constructiveness + WCRT Detailed semantical study of the class of SC programs vis-a-vis other classes (Pnueli & Shalev, Berry, Signal, ) von Hanxleden, et al. Synchron 22, Port aux Rocs, 2..2

58 Questions Thank you! von Hanxleden, et al. Synchron 22, Port aux Rocs, 2..2