1. Concurrency Design Patterns
By:
Kalpana Nallavolu
Nestor Rivera
Feras Batarseh

2. Design Patterns
A design pattern is a formal way of documenting successful solutions to problems.
Reusability, modularity, win time.
Resign Pattern
Ex: fatal, misbehavior.

3. Contributors
Christopher Alexander
GoF

4. Concurrency Design Patterns
Concurrency Pattern
Message Queuing Pattern
Interrupt Pattern
Guarded Call Pattern
Rendezvous Pattern
Cyclic Executive Pattern
Round Robin Pattern
Static Priority Pattern
Dynamic Priority Pattern

5. Background Thread Concurrency Concurrency Architecture Active Object
Passive objects

6. Collaboration Of Objects

7. Collaboration Of Objects 2
The active object accept messages and delegate them to the internally contained application objects for processing.
The issues around the concurrency management are varied depending
1) The threads are completely independent
2) The threads are not really independent.

8. Message Queuing Pattern

9. Message Queuing Pattern
It provides a simples means of communication among threads.
It uses asynchronous communication.
Information shared among threads is passed by value to the separate thread.
Advantages and disadvantages

10. Pattern Structure

11. Sample Model

12. Interrupt Pattern

13. Interrupt Pattern
In many real-time applications, certain events must be responded quickly and efficiently regardless of what system is doing.
This method is rarely used as only concurrency strategy
Advantages and disadvantages.

14. Pattern Structure

15. Sample Model

16. Guarded Call Pattern

17. Guarded Call Pattern – Abstract
Problem with Message Queuing Pattern…? Asynchronous & slow
What if urgency? Alternative -> synchronously invoke a method of an object
Data integrity is key -> mutual exclusion
Need to avoid ->synchronization & deadlock problems

18. Guarded Call Pattern – Collaboration Roles I
Server Thread: <<active object>>
Server Object
Shared Resource
Protection with Mutex
Client Thread: <<active object>>
Client object
Synchronously invoke method

19. Guarded Call Pattern – Collaboration Roles II
Boundary Object
Protected interface to server objects with operations
Mutex
Mutual exclusion semaphore object
Permits only single caller through time
Safer if invoked by relevant operations
Locks and unlocks shared resource
Blocks client threads

20. Guarded Call Pattern – Collaboration Roles III
Server
Uses the shared resource object
Provides the service to client across the thread boundary
Shared Resource
Provides data or service
Shared by multiple servers
Integrity must be protected => serialization of access

21. Guarded Call Pattern - Consequences
Timely response (unless services are locked)
Simplification: no interaction among servers => boundary object, contain shared resource & one mutex/server

22. Guarded Call Pattern – Related Patterns
Message Queuing, Interrupt, Guarded Call & Rendezvous could be mixed
Race conditions may appear
If server is stateful, monitor on server may be needed

23. Guarded Call Pattern – Class Diagram

24. Guarded Call Pattern Example - Structure

25. Guarded Call Pattern Example - Scenario

26. Rendezvous Pattern

27. Rendezvous Pattern
Simplified form of Guarded Call Pattern (synchronize threads)
Rendezvous Object => means for synchronization (synchronization point, policy or precondition)

28. Rendezvous Pattern - Abstract
Precondition => specified to be true prior to an action/activity
Behavioral model => each thread registers with Rendezvous class and blocks until released

29. Rendezvous Pattern – Collaboration Roles I
Callback: holds address of client thread
Client Thread
At synchronization points, register
Pass their callbacks
i.e. notify() called once condition met

30. Rendezvous Pattern – Collaboration Roles II
Manages thread synchronization
Has register() operation
Sync Policy
Reifies set of preconditions into single concept i.e. Registration count (Thread Barrier Pattern)

31. Rendezvous Pattern – Class Diagram

32. Rendezvous Pattern – Sync Policy State Chart

33. Rendezvous Pattern Example - Structure

34. Rendezvous Pattern Example - Scenario

35. Cyclic Executive Pattern

36. Cyclic Executive Pattern
Very small systems (execution predictability is crucial)
Easy to implement
Can run in memory constraint systems (no RTOS)
Executes tasks in turn, from first to last and starts over again (cycle)

37. Cyclic Executive Pattern – Collaboration Roles
Abstract Thread
Super class for concrete thread
Interface to the scheduler
Concrete Thread
<<active object>>
Contains passive objects
Scheduler
Initializes system (loads tasks)
Runs each of them in turn in perpetuity

38. Cyclic Executive Pattern – Properties of Applications
Constant number of tasks
Amount of task time is unimportant or consistent
Tasks are independent
Usage of shared resources complete after each task
Sequential ordering of tasks is adequate

39. Cyclic Executive Pattern – Pros and Cons
Primary advantage => simplicity
Primary Disadvantages
Lack of flexibility
Non-optimality
Instability to violation of its assumptions
Response to incoming event: deadline >= cycle time
No criticality or urgency: all threads are equally important.

40. Cyclic Executive Pattern – Class Diagram

41. Cyclic Executive Pattern Example - Structure

42. Cyclic Executive Pattern Example - Scenario

43. Round Robin Pattern

44. Introduction Hardcore real time deadline!
A “fairness” scheduling method.
All tasks progress than specific deadline to be met.
Entire set movement.

45. The Model Abstract thread: super class, associates with scheduler.
Concrete thread: (active thread) real work of the system.
Scheduler: initialize the tasks and run them.
Stack: control and data; variables, return variables
Task control block
Timer: ticks for scheduler, front end to the hardware timer, switch task();

46. Pros and Cons All tasks get the chance to run.
Misbehaving task wont ruin the system.
Scale up better to big systems.
Higher switching time…
All tasks take the same time slice!
Priority?

47. Related Patterns More complex than cyclic executive
Less complex than priority patterns, discussed next.
Special kind that gives each task its time.

48. Static Priority Pattern

49. Introduction Priorities predefined.
Common approach, simple, large number of tasks.
Urgency (time) + Criticality (importance)

50. The Model Abstract thread
Blocked queue: queue for TCB, blocked tasks in, out to ready queue.
Concrete thread
Shared resources
Mutex: semaphore object that allows one caller object (thread) to access shared resources.
Mutex ID, entry point.

51. The Model 2 Ready queue: reference to tasks ready to execute next.
even running tasks could be interrupted by looking at the RQ.
Scheduler: calls start address of higher and ready thread.
Stack: parameters for threads.
Task control block: priority and entry address

52. Pros and Cons Simplicity Stability
Changing conditions, reallocation? (DPP)
Low priority tasks?

53. Dynamic Priority Pattern

54. Introduction Automatically update of tasks priorities.
Urgency over criticality, thus Earliest deadline first.
Sets priority as time remaining function.

55. The Model Abstract thread
Blocked queue: queue for TCB, blocked tasks in, out to ready queue.
Concrete thread
Ready queue: reference to tasks ready to execute next, closest to deadline on top.
even running tasks could be interrupted by looking at the RQ.

56. The Model 2
Scheduler: computes the priority dynamically due to closest deadline.
Stack: return addresses and parameters for threads.
Task control block: priority and entry address after scheduler computations.
Shared resources
Mutex: semaphore object that allows one caller object (thread) to access shared resources.

57. Pros and Cons Flexible Optimal Scales well to large systems Not stable
Complex

58. Related Patterns
Not as common as SPP
More complex than other patterns

59. References
[book] Real time design patterns: Patterns: robust scalable architecture for real-time systems
[book] Design patterns: Elements of reusable object-oriented software
Gomma, Hassan Software Design Methods for concurrent and real timeSystems, Reading , Addison-Wesley 1993
IEEE Papers Database
wikipedia.com...and a couple of other websites

60. Thank you for your attention.
Questions?