[PPT] - A Super-Simple Run-Time for CSP-Based Concurrent Systems Michael PowerPoint Presentation

SLIDE 1

A Super-Simple Run-Time for CSP-Based Concurrent Systems

Michael E. Goldsby Sandia National Laboratories Livermore, California USA August, 2015

1

SLIDE 2

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

2

SLIDE 3

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

3

SLIDE 4

What is MicroCSP?

A run-time system written in C
Supports CSP constructs

– Point-to-point synchronous channels – Alternation (including timeouts) – Dynamic process creation (fork)

Implements preemptive priority scheduling

4

SLIDE 5

What is MicroCSP?

Targeted at microcontrollers

– Prototype runs over Linux

Uses stack very efficiently

– Does context switch only on interrupt

Single processor

– Multicore implementation appears possible

5

SLIDE 6

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

6

SLIDE 7

Why MicroCSP?

To provide a good set of constructs for

writing embedded systems software

Written under the assumption that hard

real-time requires preemptive scheduling

– A pervasive belief in my environment – May not be true -- investigating…

7

SLIDE 8

Why MicroCSP?

Written for systems with limited memory

– Allocating a stack per process rapidly uses up the memory of a small system – MicroCSP uses a single stack

8

SLIDE 9

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

9

SLIDE 10

How MicroCSP Works

Initialization and cycle logic of a process are

contained in a C function

– Function called when the process is scheduled – Function runs to completion unless preempted – How is this compatible with process orientation?

Any CSP process can be put in normal form:

– Some initialization logic – A single alternation repeated within a loop – Normal form provides bridge between process

rientation and C function (“code function”)

10

SLIDE 11

How MicroCSP Works

Normal form: ..initialization.. WHILE TRUE ..guard.. ..etc.. ..guard.. ..etc.. ..guard.. ..etc.. …

11

SLIDE 12

How MicroCSP Works

The MicroCSP scheduler:

– Handles the ALT and its events

Including data transfer

– Provides the iteration

As the result of repeated scheduling
The C function

– Implements the logic in the branches of the ALT

..and the initialization logic

12

SLIDE 13

How MicroCSP Works Preemption

Code function runs with interrupts disabled
Connect interrupt to channel

– Interrupt looks like normal channel input – Priority scheduling provides preemptive response

Interrupted context restored only when

return to interrupted priority level

– But interrupts re-enabled immediately

13

SLIDE 14

How MicroCSP Works Normal Form

Normal form may be called “event-oriented”

– Analogy from simulation field:

Process-oriented simulation versus
Event-oriented simulation
“Turn process inside out” to get equivalent

event form

Or write logic in event form to begin with

14

SLIDE 15

How MicroCSP Works Normal Form

PROC Element (CHAN INT in?, out!) WHILE TRUE INT x: SEQ in ? x

ut ! x

:

15

SLIDE 16

How MicroCSP Works Normal Form

PROC Element (CHAN INT in?, out!) PROC Element (CHAN INT in?, out!) WHIWHILE TRUE INITIAL BOOL receiving IS TRUE: INT x: INT x: SEQ WHILE TRUE in ? x ALT

ut ! x

receiving & in ? x : receiving := NOT receiving NOT receiving & out ! x receiving := NOT receiving :

16

SLIDE 17

How MicroCSP Works Normal Form

Scheduler supplies the iteration:

PROC Element (CHAN INT in?, out!) PROC Element (ELEMENT.RECORD proc) HI WHILE TRUE ALT INT x: proc[receiving] & proc[in] ? proc[x] SEQ proc[receiving] := FALSE in ? x NOT proc[receiving] & proc[out] ! proc[x]

ut ! x

proc[receiving] := TRUE : :

17

SLIDE 18

How MicroCSP Works Normal Form

enum {IN=0, OUT=1}; PROC Element (CHAN INT in?, out!) void Element_code (Element *proc) WHIWHILE TRUE switch(selected()) { INT x: case IN: // received a value SEQ deactivate(&proc->guards[IN]); in? x activate(&proc->guards[OUT]);

ut ! x

break; : case OUT: // sent a value activate(&proc->guards[IN]);

ut ! x

deactivate(&proc->guards[OUT]); break; }

18

SLIDE 19

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

19

SLIDE 20

API System Initialization

Initialize system

void initialize(unsigned int memlen);

Establishes memory for dynamic allocation
Allow system to run

void run();

20

SLIDE 21

API Process Creation

Define a process type

PROCESS(MyProcName) … parameters and local variables ENDPROC

Create a process

MyProcName myProcess; … initialize myProcess parameters START(MyProcName, &myProcess, priority);

21

SLIDE 22

API Process Creation

Must supply function:

void MyProcName_code(void); – Called each time process is scheduled

Any number of MyProcName processes

– Each with its own struct

Can create process at start-up or within

running process

Like fork -- there is no PAR

22

SLIDE 23

API Process Initialization, Termination

To learn if is first call to _code function:

_Bool initial();

To end itself, process calls:

void terminate();

23

SLIDE 24

API Channels

Initialize a channel:

void init_channel(Channel *chan);

Get channel ends:

ChanIn in(Channel chan); ChanOut out(Channel chan);

All data transfer done via Alternation

–No read, write (more about this later…)

24

SLIDE 25

API Time

Time (in this implementation) is 64-bit

unsigned integer

– Nanoseconds since start of program

To get current time:

Time Now();

25

SLIDE 26

API Alternation

Each process has exactly one Alternation
All event processing and data transfer are

done via the Alternation

– More on this later…

To initialize the Alternation:

void init_alt(Guard guards[], int size);

26

SLIDE 27

API Alternation

Guard may be input, output, timeout, SKIP:

void init_chanin_guard( Guard g, ChanIn c, void dest, unsigned len); void init_chanout_guard( Guard g, ChanOut c, void src); void init_timeout_guard( Guard g, Timeout t, Time time); void init_skip_guard(Guard g); void init_chanin_guard_for_interrupt( Guard g, ChanIn c, void dest);

27

SLIDE 28

API Alternation

To receive interrupts through a channel:

void connect_interrupt_to_channel( ChanIn *c, int intrno);

To learn the selected branch:

int selected();

28

SLIDE 29

API Alternation

Each Guard has a Boolean precondition:

void activate (Guard g); void deactivate(Guard g); _Bool is_active(Guard g); void set_active(Guard g, _Bool active);

Output Guard must be only active guard

–Behaves as a committed output

29

SLIDE 30

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

30

SLIDE 31

Implementation Scheduling

The scheduler walks the process through

its Alternation:

31

SLIDE 32

Implementation Scheduling

Process in INITIAL state only at inception

– Scheduler calls _code function and advances to QUIESCENT

Gives process chance to do initialization
initial() function returns true

32

SLIDE 33

Implementation Scheduling

If process QUIESCENT, scheduler advances to

ENABLING and enables branches of the Alternation

If finds ready branch while enabling, scheduler

advances process to READY

I/O partner WAITING
Timeout expired
SKIP branch (always ready)
If finds no ready branch, advances to WAITING

and selects another ready process

33

SLIDE 34

Implementation Scheduling

If advances to READY:

– Disables branches of Alternation – Discovers selected branch – Performs data transfer if any – Advances I/O partner to READY if necessary – Calls process’s _code function

The _code function calls selected() to learn

ready branch and behaves accordingly

34

SLIDE 35

Implementation Scheduling

Priority scheduling:

– When make I/O partner ready, if partner’s priority higher:

Scheduler calls itself with argument = higher priority
Returns when no ready process at that level or higher
Preemptive scheduling:

– Interrupt handler makes receiving process ready – If readied process’s priority higher than that of interrupted process, act as above

35

SLIDE 36

Implementation Scheduling

Run queue for each priority level

– Round-robin scheduling within each level

When process not executing:

– Either in run queue – Or there is pointer to it in one or more channels or timeout requests

36

SLIDE 37

Implementation Data Structures

Process record

next Pointer to next process in run queue code Pointer to code function alt Alternation record memidx Implies memory size of process record pri Priority state Scheduling state

37

SLIDE 38

Implementation Data Structures

Alternation record:

guards Pointer to array of guards nrGuards Size of guard array index Current or selected branch count Running branch count prialt True if priority alt, false if fair alt

38

SLIDE 39

Implementation Data Structures

Process record and application process

structure contiguous in single allocation:

Process record Application process data

39

SLIDE 40

Implementation Stack Usage

Stack space usage limited to:

– Working stack needed by application – One interrupt context per active priority level

Example:

– In Ring program, suppose 512 bytes adequate for working stack plus interrupt context – Never need more than 512 bytes for stack no matter number of processes (single priority level)

Need dynamic memory for process records, though

40

SLIDE 41

Implementation Miscellaneous

Hardware interface is narrow: 10 functions
Current version is prototype over Linux

– Uses only main thread (no threads package) – Implements h/w interface with Linux services – Simulates interrupts using signals

Current implementation for single

processor

– Disable interrupts for critical sections

41

SLIDE 42

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

42

SLIDE 43

Performance

nsec per communication/context switch

ring mtring commstime

ccam/ccsp

24 25 22 C/ccsp 37 33 Transterpreter 127 129 117 go 239 238 216 MicroCSP 272 273 353

43

SLIDE 44

Performance

Fewer than 1400 lines of source code

– Excluding pure comment and blank lines

Around 5400 bytes of executable code

– 32-bit Intel x86 architecture – With empty hardware interface

Size of data structures:

– Process record 20 bytes – Channel 8 bytes – Guard 16 bytes

44

SLIDE 45

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

45

SLIDE 46

Availability

Source code available at: https://github.com/megoldsby/microcsp

46

SLIDE 47

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

47

SLIDE 48

Example: Single-Token Ring Definitions and Declarations

#include "microcsp.h" // SENDS SINGLE TOKEN AROUND A RING #include <stdbool.h> #include <stdio.h> // underlying system is Linux #define RING_SIZE 256 // # of processes in ring #define REPORT_INTERVAL 1000000 #define NS_PER_SEC 1000000000ULL Channel channel[RING_SIZE]; // channels connecting the ring static Time t0; //starting time PROCESS(Element) // THE RING ELEMENT'S LOCAL VARIABLES Guard guards[2]; //................................... ChanIn *input; //................................... ChanOut *output; //................................... int token; //................................... _Bool start; //................................... ENDPROC //...................................

48

SLIDE 49

Example: Single-Token Ring Code Function - Part 1

void Element_code (void *local) // THE RING ELEMENT'S LOGIC { enum { IN=0, OUT }; // branch 0 for input, 1 for output Element *element = (Element *)local; if (initial()) { // exactly one guard active init_alt(element->guards, 2); // at any one time init_chanin_guard(&element->guards[IN], element->input, &element->token, sizeof(element->token)); init_chanout_guard(&element->guards[OUT], element->output, &element->token); element->token = 0; // if starter, start with o/p else i/p set_active(&element->guards[IN], !element->start); set_active(&element->guards[OUT], element->start);

49

SLIDE 50

Example: Single-Token Ring Code Function – Part 2

} else { switch(selected()) { case IN: // just read token, maybe report rate if (element->token > 0 && (element->token % REPORT_INTERVAL == 0)) { double sec = (double)(Now() - t0) / NS_PER_SEC; printf("Rate = %g\n", sec / (double)element->token); } element->token++; // incr token, prepare to write it deactivate(&element->guards[IN]); activate(&element->guards[OUT]); break; case OUT: // just wrote, prepare to read activate(&element->guards[IN]); deactivate(&element->guards[OUT]); break; } } }

50

SLIDE 51

Example: Single-Token Ring main Logic – Part 1

int main(int argc, char **argv) { initialize(70*RING_SIZE+24); // initialize the system int i; // initialize the channels for (i = 0; i < RING_SIZE; i++) { init_channel(&channel[i]); } Element element[RING_SIZE]; // instantiate the ring elements Channel *left, *right; // connect the ring elements for (i = 0, left = &channel[0]; i < RING_SIZE; i++) { right = &channel[(i + 1) % RING_SIZE]; element[i].input = in(left); element[i].output = out(right); element[i].start = false; left = right; }

51

SLIDE 52

Example: Single-Token Ring main Logic – Part 2

element[0].start = true; // make first element starter t0 = Now(); // get the starting time for (i = 0; i < RING_SIZE; i++) { // start the ring elements START(Element, &element[i], 1); } run(); // let them run }

52

SLIDE 53

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

53

SLIDE 54

Related Work

Transterpreter

– Very good performance – Portable – Nearly all of occam-π – May be suitable for hard real-time – Released under LGPL

Does not poison commercial or proprietary use

54

SLIDE 55

Related Work

CCSP

– Gold standard for process scheduling – 32-bit Intel only

Not easy to port

– Memory requirements?

55

SLIDE 56

Related Work

C++CSP

– Single processor – Possibly easy to port – Superseded by C++CSP2

C++CSP2

– Many-to-many threading model

multicore

– Linux/Windows – Released under LGPL

56

SLIDE 57

Related Work

RMoX

– Operating system written in occam-π – Intel x86 only – Multicore – Released under GPL

57

SLIDE 58

Related Work

JCSP Micro Edition

– Reduced version of JCSP to fit on microcontroller – Aimed at mobile phones, embedded systems – Requires underlying JVM

Does garbage collection

– 90 KB of class files

JCSP Robot Edition

– Further reduced version of JCSP – Runs on LEGO Brick over LeJOS java kernel and JVM

No garbage collection

58

SLIDE 59

Related Work

ProcessJ

– C/Java-like syntax for occam- π-like language – Compiler can produce various outputs

Transterpreter bytecode (portability)

59

SLIDE 60

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

60

SLIDE 61

Future Work

Depends on my investigation of real-time

cooperative scheduling

– Would prefer higher-level language like

ccam-π
Multicore
Shared channel ends
Barriers
PAR

61

SLIDE 62

MicroCSP

1. What is MicroCSP?
2. Why MicroCSP?
3. How MicroCSP Works
4. API
5. Implementation
6. Performance
7. Availability
8. Example
9. Related Work
10. Future Work
11. Conclusions

62

SLIDE 63

Conclusions

MicroCSP presents a realization of CSP constructs

with the simplicity of implementation and memory efficiency of an event-driven approach

– With working example

Provides benefits of CSP-based development

– Compositional program construction – Race conditions ruled out – No semaphores or locks – Relations between components explicit (channels) – Priority inversion is avoidable – Can check design with FDR

63

SLIDE 64

Questions & Discussion

michaelegoldsby at gmail.com
megolds at sandia.gov

64

A Super-Simple Run-Time for CSP-Based Concurrent Systems

Michael E. Goldsby Sandia National Laboratories Livermore, California USA August, 2015

MicroCSP

MicroCSP

What is MicroCSP?

– Point-to-point synchronous channels – Alternation (including timeouts) – Dynamic process creation (fork)

What is MicroCSP?

– Prototype runs over Linux

– Does context switch only on interrupt

– Multicore implementation appears possible

MicroCSP

Why MicroCSP?

writing embedded systems software

real-time requires preemptive scheduling

– A pervasive belief in my environment – May not be true -- investigating…

Why MicroCSP?

– Allocating a stack per process rapidly uses up the memory of a small system – MicroCSP uses a single stack

MicroCSP

How MicroCSP Works

contained in a C function

– Function called when the process is scheduled – Function runs to completion unless preempted – How is this compatible with process orientation?

– Some initialization logic – A single alternation repeated within a loop – Normal form provides bridge between process

How MicroCSP Works

Normal form: ..initialization.. WHILE TRUE ..guard.. ..etc.. ..guard.. ..etc.. ..guard.. ..etc.. …

How MicroCSP Works

– Handles the ALT and its events

– Provides the iteration

– Implements the logic in the branches of the ALT

How MicroCSP Works Preemption

– Interrupt looks like normal channel input – Priority scheduling provides preemptive response

return to interrupted priority level

– But interrupts re-enabled immediately

How MicroCSP Works Normal Form

– Analogy from simulation field:

event form

How MicroCSP Works Normal Form

How MicroCSP Works Normal Form

How MicroCSP Works Normal Form

Scheduler supplies the iteration:

How MicroCSP Works Normal Form

MicroCSP

API System Initialization

void initialize(unsigned int memlen);

void run();

API Process Creation

PROCESS(MyProcName) … parameters and local variables ENDPROC

MyProcName myProcess; … initialize myProcess parameters START(MyProcName, &myProcess, priority);

API Process Creation

void MyProcName_code(void); – Called each time process is scheduled

– Each with its own struct

running process

API Process Initialization, Termination

_Bool initial();

void terminate();

API Channels

void init_channel(Channel *chan);

ChanIn *in(Channel *chan); ChanOut *out(Channel *chan);

–No read, write (more about this later…)

API Time

unsigned integer

– Nanoseconds since start of program

Time Now();

API Alternation

done via the Alternation

– More on this later…

void init_alt(Guard guards[], int size);

API Alternation

void init_chanin_guard( Guard *g, ChanIn *c, void *dest, unsigned len); void init_chanout_guard( Guard *g, ChanOut *c, void *src); void init_timeout_guard( Guard *g, Timeout *t, Time time); void init_skip_guard(Guard *g); void init_chanin_guard_for_interrupt( Guard *g, ChanIn *c, void *dest);

API Alternation

void connect_interrupt_to_channel( ChanIn *c, int intrno);

int selected();

API Alternation

void activate (Guard *g); void deactivate(Guard *g); _Bool is_active(Guard *g); void set_active(Guard *g, _Bool active);

–Behaves as a committed output

MicroCSP

Implementation Scheduling

its Alternation:

Implementation Scheduling

– Scheduler calls _code function and advances to QUIESCENT

Implementation Scheduling

ChanIn in(Channel chan); ChanOut out(Channel chan);

void init_chanin_guard( Guard g, ChanIn c, void dest, unsigned len); void init_chanout_guard( Guard g, ChanOut c, void src); void init_timeout_guard( Guard g, Timeout t, Time time); void init_skip_guard(Guard g); void init_chanin_guard_for_interrupt( Guard g, ChanIn c, void dest);

void activate (Guard g); void deactivate(Guard g); _Bool is_active(Guard g); void set_active(Guard g, _Bool active);