1. 1 Notation and Specification of Concurrency n Concurrency Topics  1. Sequential programming notation  2. Expressing concurrency with co and process  3. States and hardware  4. Atomic actions  5. Inter-leavings and histories  6. The finite progress assumption

2. 2 Notation and Specification of Concurrency n Programming Notation  Start with sequential constructs, such as:  1. Declarations  2. Statements  3. Procedures  Basic Elements  Identifier - A letter followed by an optional sequence of letters, digits and underscores  x, fred_one, timer2  Keyword - Symbol with a fixed meaning  var, if, const  Operator - Special characters such as =, +, -  Comments – The # character will be used to denote single line comments and /* … */ to denote multiple line comments (Note Java comment // is used as the separator between arms of concurrent statements

3. 3 Notation and Specification of Concurrency  Declarations  Basic - Basic types: bool, int, real, char, string,  Variables - Introduced similar to Java (type followed by names and may be initialised):  e.g int n; int m=10; int x,y=2;  e.g. string s = “hello”; char c1 = ‘C’;  Arrays  Add a range specification (for each dimension) to an identifier in a variable declaration:  (Default values for a[n] range from a[0] to a[n - 1])  double a[10];  int matrix[n,n];  int c[1:n]; #array of n integerss, c[1]… c[n]  int c[1:n] = ([n] 0); #vector of zeroes  int matrix[n,n] = ([n] ([n] 1)); #matrix of ones  array elements:  a[i], matrix[i, j]

4. 4 Notation and Specification of Concurrency  Statements  1. skip “empty” statement - has no effect  2. assignment (=)  x = e; ( Evaluates expression e and assigns it to x)  3. Compound  S1; S2; S3 Sequence of statements. They are executed sequentially.  4. Alternative - if  if (condition) #surround the statements by {} if more than 1 statement;  5. Iterative -while  while (condition) #surround the statements by {} if more than 1 statement;

5. 5 Notation and Specification of Concurrency  6. For loop for [i = 0 to n-1] a[i] = i; for [i = 0 to n-1] for [j = 0 to n-1] matrix[i, j] = 1; for [i = 0 to n-1, j = 0 to n-1] matrix[i, j] = 1;  2 more examples of quatifiers: [i = 1 to n by 2] #odd values from 1 to n [i = 0 to n-1 st i != x] #every value except i==x Assume a[n] is an array of integers. This initialises each element to i Assume m[n,n] is an integer matrix. This initialises each element to 1. This example uses nested statements Same as before using two quantifiers Quantifier

6. 6 Notation and Specification of Concurrency  7. Procedures - defined and used the same way as in C/Java. int square(int y) { return y*y; } int factorial(int n) { if (n < 0) return = -1; else if (n == 0 or n == 1) return 1; else (n > 1) return (n * factorial(n -1)); }

7. 7 Notation and Specification of Concurrency n Specifying Concurrent Execution  There are two main ways of specifying a concurrent execution.  The first way is by using the co statement and is sometimes known as fork- and-join.  In the second method we use the process statement. This is sometimes known as fork-and-continue.  The co statement  Let S[i]: 1  i  n be a collection of sequential programs. To program the S[i] for concurrent execution the following statement is used: co S[i] // S[2] //... // S[n] oc  Each of the executing S[i] is called a process. Execution of the co statement completes when all the S[i] have completed.  (The effect is some history of the atomic actions of the S[i] - see later for an explanation...)

8. 8 Notation and Specification of Concurrency  The process statement The second method of programming concurrent execution is to specify that another sequential program starts execution at a certain point.  main() { for [i = 0 to n-1] { rowOp[i]; for [j = 0 to n-1] { a[i,j] = i + j; b[i,j] = i*j; }  process rowOp[i = 0 to n -1] { for [j = 0 to n -1] { c[i,j] = 0; for [k = 0 to n-1] c[i,j] = a[i,k]*b[k,j]; }  The “main” program which calls the process statement “rowOp[i]” continues executing after the call (both may be executing). { rowOp[i] process starts executing concurrently with the other code in this main segment }

9. 9 Notation and Specification of Concurrency  Hardware Assumptions  1. Variables are stored in memory elements. Read from memory and write to memory of the basic variable types are atomic. (So if the computer writes a four-byte integer to memory all four bytes in memory get changed to the new value.)  2. To use a variable, x. - Read x from memory and load it into a register, manipulate it inside the registers, store the results back in memory.  3. Each process has private registers and a private stack which are saved whenever there is a process switch. Processes can’t read or alter each others registers or private stack or local variables.  4. Shared Memory Assumption - Processes Si execute concurrently in a concurrent program in which they share memory as follows:  Variables declared outside the scope of the Si are global variables. Any of the Si can change a global variable.  A variable declared inside an Si is a local variable and can’t be changed by code outside the Si.  Processes share global variables. (Shared memory model) X=X+1; R1  X (read) R1=R1+1 X  R1 (write) R1 is a register a: Global S1: p=a+1; S2: a:q-7 S1and S2 communicate via global variable a

10. 10 Notation and Specification of Concurrency n Process State  A process is the execution of a sequential program.  It can be modelled as a finite state machine which transits from state to state by executing a sequence of atomic actions.  It is assumed that each process which is executing in a concurrent system can be described by the values of various registers and memory variables.  The state of a concurrent system is described by:  1. Specifying the values of all variables in memory  2. Specifying the values of all registers currently in use by each process.  3. Specifying the values of the programme counters of all the processes which are currently active.

11. 11 Notation and Specification of Concurrency  Atomic Actions  Atomic actions are at the heart of concurrent programming  An atomic action is a programming instruction (or sequence of instructions) which changes the state of a computer system indivisibly.  For example once an atomic action has commenced execution then if it reads a variable, x, it can be assumed that if it subsequently reads the variable again, no other process will have changed the variable, x, in the meantime.  Hence:  Every Sequential Program can be rewritten as a set of atomic actions.  Instructions involving only local variables are atomic.  Instructions involving shared variables can be rewritten as a sequence of atomic reads from memory, atomic manipulations of register contents, and atomic writes to memory. P=2*Q; S=3+P; Atomic If declared ATOMIC then no other process can see inside

12. 12 Notation and Specification of Concurrency  Example Consider the following program: x = 0 y = 0 co x = y + 1 // y = x + 1 oc  The co statement is of the form: co S1 // S2 oc S1: x = y + 1 can be rewritten, using register R1: R1 = y R1 = R1 + 1 x = R1 S2: y = x + 1 can be rewritten, using register R2: R2 = x R2 = R2 + 1 y = R2  Each of these sequential programs can be rewritten as a pair of atomic actions (t1, t2) and (u1, u2) by including the register addition with one of the other actions. t1 t2 Two Atomic Actions t1 and t2 u1 u2 Two Atomic Actions u1 and u2

13. 13 Notation and Specification of Concurrency  This is because each register is private to the process using it. t1: R1 = y t2: R1 = R1 + 1; x = R1 u1: R2 = x u2: R2 = R2 + 1; y = R2  Interleaving An interleaving of a concurrent programme is a list of the atomic actions of its sequential programs. Within the interleaving each sequential programme is listed in correct order, but the actions of different sequential components can be intermixed. For example: are all inter-leavings of the co statement above. Atomic (t1, t2, u1, u2) (t1, u1, t2, u2) (t1, u1, u2, t2) (u1, u2, t1, t2) (u1, t1, u2, t2) (u1, t1, t2, u2) Note that for a concurrent program with n processes each with m atomic actions the number of different histories is given by: (m.n)!/(m! n ) i.e. n=2 (processes), m=2(atom act.) (2*2)!/(2! 2 ) = 6 Note that for a concurrent program with n processes each with m atomic actions the number of different histories is given by: (m.n)!/(m! n ) i.e. n=2 (processes), m=2(atom act.) (2*2)!/(2! 2 ) = 6

14. 14 Notation and Specification of Concurrency  History of a Concurrent Program A history of a concurrent programme is a possible interleaving of its atomic actions.  There are six different histories of the program above, corresponding to six different inter-leavings of t1, t2, u1, and u2.  As a result there are three different possible outcomes when the programme is run. (t1, t2, u1, u2)  (R1=y) (R1=R1+1; x=R1) (R2=x) (R2=R2+1; y=R2)  R1=0) (R1=1; x=1) (R2=1) (R2=2; y=2)  x=1; y=2; (Note. Other combinations may give different results!) (t1, u1, t2, u2)  (R1=y) (R2=x) (R1=R1+1; x=R1 ) (R2=R2+1; y=R2)  R1=0) (R2=0) (R1=1; x=1) (R2=1; y=1)  x=1; y=1; (A different results!) (Check out the others)  Finite Progress Assumption  We assume that we can’t tell how fast the sequential components of a concurrent programme execute.  In other words there is non-determinism about which actual history of atomic actions will be executed.

15. Notation and Specification of Concurrency n Execution History and Dependency 15 A1 A2 A3 Process A B1 B2 B3 Process B C1 C2 C3 Process C History 1 History 2 A1 B1 A2 C1 B2 C2 C3 B3 A3 A1 A2 C1 B1 A3 B2 B3 C2 C3 History 3 (etc) (Execution History) (Atomic Actions)  If there is a dependency between B1 and A2 which requires that B1 must be executed before A2 then History 1 (is desirable) and correct, however History 2 (is undesirable) and incorrect. This History execution will give an incorrect program result,  This illustrates the potential for “non-determinism ” – different results for different execution runs of the program  This is where a programming notation for concurrent programs can be deployed to ensure that only correct execution histories can occur.

16. 16 Notation and Specification of Concurrency n Revision Questions Program S consists of the statements s1; s2; Program T consists of the statements t1; t2; Assume that all statements are atomic actions Consider the concurrent program C generated by allowing S and T to execute concurrently. (a)All possible histories of C can be shown on a binary tree in which each node is a statement from either S or T. Thus the leftmost path down the tree corresponds to first doing s1, then doing s2. Similarly, the third path corresponds to first doing t1 then doing s1. Complete the tree. (b)Each history is a path from the root of the tree to a leaf. By inspection, state how many histories of C there are. List the histories.

17. 17 Notation and Specification of Concurrency n Summary  Topics addressed  1. Sequential programming notation  2. Expressing concurrency with co and process  3. States and hardware  4. Atomic actions  5. Inter-leavings and histories