### Modeling Example "Client-Server without Reply"

This system architecture pattern extends the modeling example “Purely Periodic without Communication” by adding an one-way communication between tasks. It consists of two tasks T1, and T2. Task T1 sends a message to Task T2 before runnable R1 is called. In 20% of the cases Message 1, in 30% of the cases Message 2, in 20% of the cases Message 3, in 15% of the cases Message 4, and in 15% of the cases any other message than the previously mentioned ones is sent. Task T2 reacts on the contents of the message by calling different runnables. In case of Message 1 runnable R2,1, in case of Message 2 runnable R2,2, in case of Message 3 runnable R2,3, in case of Message 4 runnable R2,4, and in case of any other message than the previous mentioned ones runnable R2,x is called as default.

The table below gives a detailed specification of the tasks and their parameters. The tasks are scheduled according fixed-priority, preemptive scheduling and if not indicated otherwise, all events are active in order to get a detailed insight into the system’s behavior.

Task | Priority | Preemption | Multiple Task Activation Limit | Activation | Execution Time
--- | --- | --- | --- | --- | ---
T1 | 2 | FULL | 1 | Periodic | R1 | Uniform
Offset = 0 | Min = 9.9 * 106
Recurrence = 100 * 106 | Max = 10 * 106
T2 | 1 | FULL | 1 |  | R2,x | Uniform
Min = 99
Max = 100
R2,1 | Uniform
Min = 990
Max = 1 * 103
Periodic | R2,2 | Uniform
Offset = 15 * 106 | Min = 49.5 * 103
Recurrence = 60 * 106 | Max = 50 * 103
| R2,3 | Uniform
Min = 990 * 103
Max = 1 * 106
R2,4 | Uniform
Min = 39.6 * 106
Max = 40 * 106

In order to show the impact of changes to the model, the following consecutive variations are made to the model:

1) Initial Task Set
  As defined by the table above.

2) Exclusive Area
  For this variation, all data accesses are protected by an exclusive area. Therefore, the data accesses in T1 as well as all runnables in T2 (R2,x, R2,1, R2,2, R2,3, and R2,4) are protected during their complete time of execution via a mutex and priority ceiling protocol. That way, blocking situations appear.

3) Inter-process Activation
  As from this variation on, task T2 gets activated by an inter-process activation from task T1 instead of being activated periodically. The interprocess activation is performed right after the message message is written in T2 and consequently before the runnable R1 is called. That way, a direct connection between T1 and T2 is established.

4) Priority Ordering
  As from this variation on, the priority relation between task T1 and T2 is reversed. As a consequence, the priority of task T1 is set to 1 and the priority of task T2 is set to 2. That way, a switch from asynchronous to synchronous communication is considered.

5) Event Frequency Increase
  As from this variation on, the periodicity of T1 is shortened. For this, the value for the period of task T1 is cut in half to 50 * 106 time units. That way, the utilization of the system is increased.

6) Execution Time Fluctuation
  As from this variation on, the execution time distribution is widened for both tasks. Therefore, the maximum of every uniform distribution is increased by 1 percent so that they vary now by 2 percent. That way, the utilization of the system is increased, which results in extinct activations.

7) Activation
  As from this variation on, the maximum number of queued activation requests for both tasks is set to 2. That way, the problem with extinct activations resulting from the previous variation is solved.

8) Accuracy in Logging of Data State I
  For this variation, the data accesses in task T1 and task T2 are omitted. Instead, the runnable entities R2,x, R2,1, R2,2, R2,3, and R2,4, each representing the receipt of a specific message, are executed equally random, meaning each with a probability of 20%. That way, only a limited insight into the system’s runtime behavior is available.

9) Accuracy in Logging of Data State II
  For this variation, just task events are active. That way, only a limited insight into the system’s runtime behavior is available.