• No results found

END-TO-END TIMING ANALYSIS OF TASK-CHAINS

N/A
N/A
Protected

Academic year: 2021

Share "END-TO-END TIMING ANALYSIS OF TASK-CHAINS"

Copied!
34
0
0

Loading.... (view fulltext now)

Full text

(1)

aster˚

as, Sweden

Thesis for the Degree of Master of Science in Engineering

-Embedded Systems 15.0 credits

END-TO-END TIMING ANALYSIS OF

TASK-CHAINS

Shijie Zhu

szu16001@student.mdh.se

Zhiqun Jin

zjn16001@student.mdh.se

Examiner: Saad Mubeen

alardalen University, V¨

aster˚

as, Sweden

Supervisor: Matthias Becker

alardalen University, V¨

aster˚

as, Sweden

(2)

Abstract

Many automotive systems are real-time systems, which means that not only correct operations but also appropriate timings are their main requirements. Considering the influence that end-to-end delay might have on the performance of the systems, the calculation of it is of necessity. Abundant techniques have actually been proposed, and some of them have already been applied into practical systems. In spite of this, some further work still needs to be done. The target of this thesis is to evaluate and compare two end-to-end timing analysis methods from different aspects such as data age, consumption time, and then decide which method is a prior choice for end-to-end timing analysis. The experiments can be divided into three blocks, system generation and end-to-end delay calculation by two methods respectively. The experiments focus on two kinds of performance parameters, data age and the consumption time that these two methods cost during their execution. By changing the system generating parameters like task number and periods, the changes of performances of the two methods are analyzed. The performances of the two different methods are also compared when they are applied into the same automotive systems. According to the results of the experiments, the second method can calculate more accurate data age and consume less time than the first method does.

(3)

Table of Contents

1 Introduction 3

2 Problem Formulation 5

3 Background and Motivation 6

3.1 System Model . . . 6

3.2 Register Communication . . . 6

3.3 End-to-End Timing Constraints - Data Age . . . 7

3.4 Motivation . . . 7

4 Related Work 9 5 Method 10 6 End-to-End Delay Analysis 12 6.1 Method 1 . . . 12

6.2 Method 2 . . . 14

7 System Generation 17 7.1 Benchmark Generation . . . 17

7.2 Communication Pattern . . . 18

7.3 Calculation of Worst Case Execution Time . . . 20

7.4 Cause-Effect Chains . . . 21

7.5 Algorithm for System Generation . . . 22

8 Results and Evaluation 23 8.1 Experiment Settings . . . 23

8.2 Experiment Results . . . 24

8.3 Result Analysis and Evaluation . . . 26

8.3.1 Analysis and Evaluation of Data Age . . . 26

8.3.2 Analysis and Evaluation of Time Consumption . . . 26

9 Conclusion 29

10 Future Work 30

Acknowledgements 31

(4)

1

Introduction

With the utilization of newer hybrid engines, applications of stricter emission norms and assisting driving systems with higher safety and efficiency requirements, automotive systems are becoming more complex. Distributed systems are widely used in recent years, which on one hand optimize the performance of the systems, however on the other hand increase the complexity of timing analysis of automotive systems. With functionalities distributed, the whole system can be separated into several sets of tasks which perform specific system behaviors by cooperation and synchronization. This is where event chains come from, different task instances in one event chain executed with data propagating through to make a correct response to the system input. In order to make a correct actuation and to satisfy the basic performance requirements, some time constraints to both the execution of tasks and the propagation of data must be satisfied in an event chain. The timing analysis includes the analysis of response times [1] and data propagation time. There are already some works focusing on the calculation of end-to-end delays in automotive systems [2,3,4].

Data age is defined as the time interval from the generation of data to a corresponding output produced at the end of an event chain, which is a specific form of end-to-end delay. In real-time systems, time is always one of the most important factors that should be considered. Hence, the delay of data propagation sometimes can be a vital factor to the performance of automotive systems. So during the design phase and performance analysis of an automotive system, the end-to-end delay must be considered.

Register communication is now one common form of task communication in automotive systems [5,6]. In this communication, a register is shared by both sending tasks and receiving tasks. The sending tasks can write a value to the register, and the receiving task reads the value from it. By this way, the receiving task can always read the newest value. Considering the wide application of register communication, the calculation of data age under this communication semantic is taken into account in this thesis.

However, the analysis of data age is sometimes not so easy. In an event chain, the periods of tasks are not always the same. Multi-rate systems may have the problem of over- and under-sampling, which means that some data might be over-written by the new data before they are consumed by the reading tasks, while some data might be consumed more than once before new data arrives. This increases the complexity of the timing analysis of the system and the calculation of the maximum data age.

Task activation pattern is also of significance to the performance of the systems. Generally, task activation can be classified into two types: time-triggered and event-triggered. One task chain may contain a mixture of time-triggered tasks and event-triggered tasks, which makes the timing analysis much more complicated. So the task triggering pattern is another factor that cannot be ignored. The end-to-end delays with the existence of event-triggered tasks are analyzed in [3, 7]. In this thesis, we consider only time-triggered tasks.

Therefore, not only the schedulability of individual tasks is of importance, but also the end-to-end delay when data propagates through a chain of independently triggered tasks matters. Considering that related analysis methods have been proposed in previous work [8, 9, 10], it is necessary to compare different methods’ performances in different situations like task scheduling knowledge levels. This is the main focus of this work.

For readers without related background understanding this thesis easily, some basic concepts are described below.

• Task: a sequential program executed to perform a certain computation. Tasks can commu-nicate with each other.

• Task Period: some tasks are activated periodically. The time interval between activation time of two task instances is the period of the task.

• Worst Case Execution Time (WCET): the longest time interval from the start point of one task’s execution to the point that the task finishes its execution without considering any interference.

• Worst Case Response Time (WCRT): the possible longest time interval between the release time of the task instance and the finishing time of its execution with considering interference

(5)

from other tasks in the system.

The rest of the thesis is arranged as following. In Section 2, the main problem to be solved in this thesis is described. Then in Section 3, some background knowledge and the research motivation are introduced. Some related works that have been done are described in Section 4. The two methods for end-to-end delay analysis are demonstrated in Section 5. Section 6 introduces research methodology through a flowchart. The mechanism of system generation is demonstrated in Section 7. Section 8 involves the settings and results of the experiments as well as the evaluation of them. Lastly in Section 9 the conclusion is made, based on the results and evaluation in the former section.

(6)

2

Problem Formulation

In order to calculate the end-to-end delay of a chain composed by independently triggered tasks, two approaches [8,10] are proposed.

In [8], the authors build a framework of end-to-end delay calculation of task chains under distinguished semantics such as First-to-First, First-to-Last, Last-to-First and Last-to-Last, for multi-rate systems with register communication.

In [10], data age, which is under the Last-to-Last semantic in [8], is focused on. A framework of the computation of data age with different levels of information such as exact schedule knowledge, Worst Case Response Time(WCRT), LET Model and so on, is provided. This is an extension of the end-to-end delay analysis among multi-rate effect chains presented in [9].

Both methods in [8, 10] have already been verified as effective approaches in the aspect of timing analysis, but there is no conclusion having been made that which one can have a better performance.

In order to make a qualitative comparison of the different analysis methods, we need to analyze the results of experiments where different timing analysis techniques are applied into a large number of system cases.

(7)

3

Background and Motivation

3.1

System Model

We base our application model on standard automotive applications which can be described by a task set Γ. A task in task set considered Γ can be either time-triggered or event-triggered. A time-triggered task τi is periodically triggered by a system clock, which is denoted by the tuple

{Ti, Ci}, where Ti denotes the period of τi, and Ci is the Worst Case Execution Time. We suppose

that all the tasks release at the same time, so offset is no longer a question to be considered. We further assume implicit deadlines, i.e. Di = Ti. An event-triggered task τj which does not have a

fixed period is triggered by the signal released by another task τi or an extern event. We use the

tuple {τi1, τi2, ..., Cj} to describe an event-triggered task τj, where τix, x = 1, 2, .. are tasks which

can trigger τj, and Cj is the WCET of τj. For all the tasks, the kth job of τj is denoted as τjk.

In this thesis, we focus on applications with time-triggered tasks. The least common multiple of all tasks periods is called hyper period denoted by HP. Communication among tasks is realized via shared registers which will be explained in detail in subsection 3.2; The hardware platform is assumed to be either a single- or multi-core processor with shared memory to allow for the introduced communication model.

3.2

Register Communication

In this thesis, we target on automotive systems where tasks communication is realized by shared registers, which can be found in many industrial application areas [5, 6, 11]. A sending task produces a new message and writes it to the shared register, and a receiving task reads the value of the shared register. In such a communication model, no signaling is needed between tasks, and the reading task can always read the newest data.

In order to increase determinism, tasks are executed on the read-execute-write model. In this model, a task firstly reads the value of the input register and puts it into local copies when it starts its execution, and then uses only the local copied variants in the process of execution. After the execution, some new data is produced and written to another register which might be read by another task. This is a common execution form found in several industrial standards (i.e. in AUTOSAR this model is defined as the implicit communication [12], and the standard IEC 61131-3 for the automation systems also defines similar communication mechanisms [11]).

In order to make the description of system communication model more understandable, here we have an example model Γ = {τ1, τ2, τ3, τ4}, where τ2 and τ3 are event-triggered tasks, and

the other two are periodical tasks with different periods 2, 3 respectively. The execution time of the tasks are 1,2,3,2 respectively. The HP of the system is the LCM of the periods, which is 6. All the tasks operate on read-execute-write model. The task-execution and communication are demonstrated in Figure 1. On this figure, once τ2 is released, it will read the value of register

R2, which is propagated to its local copies. After register reading, specific functionality will be

executed, and new data will be produced and written into R3 waiting for the reading of τ3. The

other tasks operate in the same model as τ2.

(8)

3.3

End-to-End Timing Constraints - Data Age

For cause-effect chains in automotive systems [5,6], many end-to-end timing constraints are speci-fied, among which data age is one of the most important metrics for control systems [8]. The data age is defined as the interval time from reading data at the beginning of the cause-effect chain till the last time this data has influence on the output of the cause-effect chain. For different systems, data age has different semantics. Maximum data age usually has special meaning for systems where an actuation is required to be finished in one maximum time bound. In this thesis, we concentrate on the analysis of maximum data age, and the analysis methods will be explained in section 6.

Figure 2: Data propagation paths and maximum data age

Figure 2 shows an example of a cause-effect chain with four tasks τ1, τ2, τ3 and τ4 and the

meaning of maximum data age. Note that τ1, τ3 and τ4 are activated with a period of T = 2, 6

and 2 respectively, while τ2is an event-trigger task activated only after τ1finishing its execution.

According to Figure2, over- and under-sampling between the different tasks are quite common. • over-sampling

Over-sampling is when the consumer is activated with less frequency than the producer. In this example, the data that is produced by the second and third instance of τ2 is updated

by the data that is produced by the forth instance, before the second instance of τ3 has the

chance to consume it. • under-sampling

Under-sampling is when the consumer is activated with higher frequency than the producer. τ3 cannot update the data before the second and third instances of τ4 starts to consume it,

so the data consumed by the first, second and third instances of τ4is all the same one unless

the second instance of τ3is executed and renews the data.

In this example, the maximum data age is from sampling of the first instance of τ1 to the last

consumption of the data at the output of the third instance of τ4.

3.4

Motivation

Because of the significance of correct temporal behavior in automotive systems, the accuracy of timing analysis of tasks can influence the result enormously. This means that not only the execution time should be considered, but also the time invested in data propagation should also be taken into account. Actually, there are already researches about end-to-end delays being conducted, and affluent results have been produced. In front of the abundant analyzing methods, what we need to do is to choose the optimal methods in different situations. If there is some data about the performance( like CPU utilization, memory cost and timing analysis accuracy) of each method conducted under different conditions, it might be more efficient for people to find an appropriate

(9)

analyzing method for a specific project or a development phase. Starting from this point, we decide the target of this thesis is comparing the performance of two end-to-end delay analyzing methods with several aspects of evaluation.

(10)

4

Related Work

Timing analysis for automotive system can be divided into two parts: local task or message schedu-lability analysis [13,14,15] and end-to-end timing analysis of event chains [8,10,16,17]. End-to-end timing analysis can be traced to 1994, Tindell et al [15] firstly proposed adding task offsets to response time analysis, and mentioned the end-to-end time analysis for event-triggered paths of tasks. Then Sun et al [18] improved the basic end-to-end response time bounding methods by considering the precedence between tasks and taking the influence caused by task instances with lower priority into account. For distributed automotive systems, Davare et al [19] automatically assign task and data periods by formulating the deadlines on response times and end-to-end delays as constraints into problems. All of these end-to-end delays analysis methods require calculating WCRT of the event chain, and the tasks in one chain should be activated in sequence, which cannot be applied to systems with tasks triggered independently well. Based on compositional scheduling models, the chains’ WCRT calculation can be replaced by WCRT calculation of local individual tasks, which makes end-to-end timing analysis of tasks chains with time-triggered tasks possible [8,20].

Feiertag et al [8] proposed a framework of end-to-end delay calculation for automotive systems where tasks in one event chain communicate by registers and have varied periods. This method is based on the end-to-end delays calculation of valid timed paths. By removing timed paths with backwards time travel and overwriting, all the valid timed paths are acquired. Based on this end-to-end delay calculation framework, only the information of the first task instance and the last task instance in one timed path is needed, while the timing analysis of the middle tasks can be avoided. The precondition of the applicability of the framework in [8] is the known WCRT of the tasks. However, during the early designing phase of systems, the information of the system is always not complete. Becker et al [10] proposed an end-to-end delay calculation method which can be applied based on four distinguished system knowledge levels. The validation of one data path is determined by the interaction of read intervals and data intervals of the tasks. The definitions of read intervals and data intervals will be provide in section 6. In this thesis, we apply the two methods in [8,10] into systems with different setup to compare the performances of them.

In addition, before doing the timing analysis, the methods for system generation are of im-portance. Generally, it is hard to obtain detailed system information from industrial companies due to the intellectual property protection. Simon et al [21] described an extraction tool which can convert real-world application into characteristic information. Based on characteristic infor-mation, system benchmarks are able to be generated for free. Our systems applied in experiments are generated based on the method from that paper.

(11)

5

Method

In this research, we read related works according to the problem formulation, and then do the implementation. Through observation and analysis, we will make a conclusion in the end. If the final result does not match our expectation, we will locate the problem and revise it in related phases. The procedure of our research methodology is shown as Figure3.

Figure 3: Flow Diagram of Research Method

1. Problem Formulation

To clarify the problem formulation and make the importance and necessity of this research clear.

2. Related Work Reading

In order to guarantee the smooth processing of the latter work, basic knowledge and related work are required as follows:

• The core theories and mechanisms of the timing analysis methods mentioned in [8,9,10]; • The main attributes of the methods that are utilized to do comparison and evaluation; • MECHAniSer-tool for Timing Analysis and Synthesis [22];

• System generation based on the mechanism in [21]. 3. Implementation

To do the programming for the system generation and the timing analysis methods. 4. Observation

To measure the results of the experiments implemented from the Implementation Step and collect the data like data age, time consumption and memory consumption to analyze the performance in the next step.

(12)

5. Analysis

To analyze the data collected from the Observation Step and do comparison and evaluation for the results of the two timing analysis methods. Besides, the final result in this step will be compared to the expected result before getting a conclusion. If the final result matches the expected result, we do the conclusion in the next step; otherwise, revision needs to be done as follows:

• Related Work Reading: Defects or misunderstanding from the related work can result to definitely different conclusions. Rereading related work or searching more papers to compensate the lack of knowledge will be prior to any other work.

• Implementation and Observation: If the theories and mechanisms are undoubtedly cor-rect, the program in the implementation and observation steps should be revised. Gen-erally, bugs in the program mainly impact the results.

6. Conclusion

(13)

6

End-to-End Delay Analysis

For today’s automotive systems, functions are usually distributed to different Electronic Control Units. One control loop is usually separated into parts like state sensing, controlling and actuation, where the tasks constitute a data path from sensing points to actuation points. The propagation of data between tasks can be realized by CAN, Buses and the others, but whichever we use takes time. For automotive systems, timing is sometimes one of the most important factors that can influence the performances of the systems. Sometimes, even one millisecond’s time difference can make a different result. So timing analysis should be as accurate as possible, which means that the calculation of end-to-end delays should also be as accurate as possible.

In this thesis, we choose two kinds of calculation methods which can be applied into similar system models. The details of the two methods is described in this section.

6.1

Method 1

Feiertag et al [8] proposed a framework of end-to-end delay calculation. If the scheduling of the tasks is known, we can easily locate which task instance is executed at a certain time point, and then get the sequence of the reading and writing of the registers. Through the register communication, the data can propagate through a timed path tp. Figure4 demonstrates how a timed path can be determined, each number on the picture means one task releasing. The read-execute-write model ensures that the position of reading and writing operations in one task instance is fixed. This means that as long as a timed path is determined, the end-to-end delay can be defined as time interval between the start point of the first task instance on the path and the end point of the last task instance on the path, while the execution details of the middle tasks can be ignored.

Figure 4: Timed Paths

However, there is usually more than one timed path in one system, for example, during the time interval shown in Figure4, there should be 6 ∗ 4 ∗ 11 = 264 timed paths. Each of the paths has an end-to-end delay. What we focus on in this thesis is the maximum end-to-end delay. So searching for the longest path among all these timed paths should be considered firstly. The first step is to remove the timed paths that can not be realized in real world, which is actually a process of verifying the reachability of timed paths and can reduce the time consumption of end-to-end delay calculation. For the validation of a timed path, one of the aspects is forward reachability, which means that there is no backwards time travel in the timed path. From this, we can not only exclude timed paths where reading task instances finish before writing task instances, but also

(14)

timed paths where the writing task instances are preempted by the reading task instances. Figure

5shows 4 possible situations during the execution of the tasks. In path 1, the writing instance is finished before the activation of the reading instance. Path 2 shows the situation where the reading instance is activated before the writing instance is finished, while it has to wait until the end of the writing instance. So path 1 and path 2 are valid. Similar to path 2, the reading instance in path 3 is also activated before the end of the writing instance, while it can preempt the execution of the writing instance. For time path 4, the writing instance is finished before the releasing of the reading instance. Obviously, both path 3 and path 4 should be excluded because of the backwards time travel.

Figure 5: 4 Types of Timed Paths

Except for forward reachability, overwriting can also cause the invalidation of a timed path. Overwriting occurs when the period of the reading task is larger than that of the writing task. For example, the first instance of the writing task writes a value V1 to the register, but before the reading task is released, the second instance of this writing task comes, who writes another value V2 to the register. Then, the reading task comes, but it can only read V2. This is because V1 was already covered by V2. Figure6 shows the situation of overwriting in one hyper period. The black bold lines represent the valid paths, while the blue lines denote the invalid paths caused by under-sampling. In this figure, task 1 is released more frequently than task 2 is, so before the second instance of task 2 can read the register, the value sent by the first three instances of task 1 have already been covered by the value of their next instances. This means that the first three instances arrive at a dead end, and paths including them should be excluded.

After these two steps, we exclude all the invalid paths. The rest job is to calculate the data age of each valid timed path, and then choose the largest one as the final result. Just like figure6, the valid path in the black circle is the longest timed path with the largest end-to-end delay. For the end-to-end delay calculation, we have a framework.

∆ = αn+ rtn− α1 (1)

where ∆ denotes the data age; αn and α1 are activation times of the last task instance and the

first task instance of the timed path respectively; rtn denotes the response time of the last task

(15)

Figure 6: Invalid Paths Caused by Overwriting

6.2

Method 2

During the designing phase of one automotive system, the information of the system, like the schedule or the response time of the tasks, is usually incomplete. However, these kinds of absent information may have effects on the system timing analysis, one of which is the end-to-end delay calculation. In order to avoid potential timing problem and redesigning, our target is to get the data age as accurate as possible during the designing process of the system. Hence, how to calculate end-to-end delays based on different levels of system information is a direction deserving spending time on. Becker et al [10] proposed a framework of end-to-end calculation under four different system knowledge level: knowledge of offsets, knowledge of scheduling algorithm, knowledge of exact schedule, knowledge of the communication semantic.

In spite of the same system definition, the methods for calculating end-to-end delays are quite different, and one of the most obvious aspects can be found in the calculation of valid paths (or cause-effect chains). In method 1, we can get all the valid timed path by excluding backwards time travel and overwriting, while in method 2 [10], we can do it in a different way.

For one task instance on the chain, it has a read interval which is a time period [Rmin, Rmax]

when this task instance can read the data from the register potentially. Correspondingly, it also has a data interval [Rmin, Rmax] when the data produced by it can potentially be read by the task

instance following it. The cause-effect chain is valid only when all the read interval of each task instance on the chain have interaction with the data interval of the task instance before it.

Based on different knowledge levels, the definitions of the read interval and the data interval are different. For cases where only offsets of tasks are known, the read interval of a task instance starts from the beginning of the period until the last point when τij can start executing without

violating its deadline. The data interval begins Ci (the execution time of τij) later than the start

of its read interval. We use the equation2 - 5to describe the read interval and data interval with only offsets known:

Rmin(τi,k) = Ψi+ (k − 1) ∗ Ti (2)

Rmax(τi,k) = Rmin(τi,k+1) − Cir (3)

Dmin(τi,k) = Rmin(τi,k) + Ci (4)

Dmax(τi,k) = Rmax(τi,k+1) − Ci (5)

(16)

τi. Figure 7 shows the read interval and data interval of the tasks. The blue solid lines are read

intervals, and the black dotted lines denote data intervals. It should be noticed that the definition of data interval for the first instance of tasks should be modified if it is not the first instance on the event chain. In Figure7, because of Dmin(τj1) < Dmin(τi1) + Ci, the start point of τj1should

be modified to Dmin(τj1) < Dmin(τi1) + Ci. This is because τj1 can only read a value after τi1

finishing its writing.

Figure 7: Read and Data Interval Based on Offset

When the worst case response time(WCRT) of the system is known, the period of the read intervals and the data intervals can be narrowed. Because under this situation, the last finishing time in one period for each task is known, so the last potential point of the read interval and the data interval is earlier than that of cases without WCRT known. After modification, the definitions of the read interval and the write interval is described in equations6 - 9.

Rmin(τi,k) = Ψi+ (k − 1) ∗ Ti (6)

Rmax(τi,k) = Rmin(τi,k) + Ri− Ci (7)

Dmin(τi,k) = Rmin(τi,k) + Ci (8)

Dmax(τi,k) = Rmax(τi,k+1) − Ci (9)

where Ri is the WCRT of task τi. Figure8 shows the modified periods of read interval and data

interval.

Figure 8: Read and Data Interval Based on WCRT

The width of the read interval and the data interval can further be narrowed by providing the exact task schedule. In an exact task schedule, we know exactly when each task starts and ends its execution. This means that the read interval of the task can shrink from a period to an exact point. The period of tasks’ data interval is more specific. For the kth instance of task τi, its data

(17)

mathematic equations10 - 13to describe it.

Rmin(τi,k) = start(τi,k) (10)

Rmax(τi,k) = Rmin(τi,k) (11)

Dmin(τi,k) = end(τi,k) (12)

Dmax(τi,k) = end(τi,k+1) (13)

where start(τi,k) is the start execution time of task instance τik, end(τi,k) is the end execution

time of task instance τik. Figure9shows the read interval and data interval of a task.

Figure 9: Read and Data Interval Based on Exact Task Schedule

If the system is designed in LET model, then the execution of tasks cannot have any influence on the periods of tasks’ read intervals and data intervals. On LET model, the input reading of a task instance is operated at the beginning of the period, and the output writing is operated at the end of the period. With the fixed reading and writing time, the read interval of a task becomes a point, and the data interval becomes an exact time period. So we can describe the read interval and data interval in equations14 - 17:

Rmin(τi,k) = (k − 1) ∗ Ti (14)

Rmax(τi,k) = Rmin(τi,k) (15)

Dmin(τi,k) = (k) ∗ Ti (16)

Dmax(τi,k) = (k + 1) ∗ Ti (17)

Figure 10 demonstrates the read intervals and data intervals of a tasks when system is running on LET model. In one event chain, we usually have more than 2 tasks’ instances. In order to calculate all the valid data paths, we can start from the first task on the chain by calculating all the potential path from all of its instances in one hyper period to all the instance of the second task. Then do this operation further through the event chain until the last task on the chain.

(18)

7

System Generation

7.1

Benchmark Generation

Before analyzing the systems with two analysis methods, system generation should be the first step. However, there exists quite large numbers of automotive system applications, so it is impossible to analyze all of them. The alternative is to classify the task chains in automotive applications with several properties and generate a certain number of benchmarks automatically and randomly according to the properties, which is a method of sampling analysis and can obtain the similar principles for all the applications. The main properties of the task chains in automotive applications are shown as follows.

• Task Components: in this paper, as mentioned in Section II, each task can consist of the reading unit, the execution unit and the sending unit.

• Task Trigger Patterns: The main trigger patterns of tasks are time-trigger and event-trigger. In this paper, tasks with time-trigger are focused on. Typical event-triggered tasks can also be converted to time-triggered tasks.

• Communication Pattern: Based on whether the data communication occurs within one single task or between two tasks, there exists two communication patterns: intra- and inter-task communication.

• Timing Requirements: The required deadline of each task, as mentioned in Section II, is equivalent to the period of that. Tasks with WCET are of interest and designed in this paper, and response time is also calculated based on WCET. The maximum end-to-end latency is another typical and important type of timing requirement, which is also called maximum data age for system with Last-to-Last Semantic [8].

Figure 11: Benchmark Generation

Generally, benchmarks are necessary but also hard to obtain. Considering intellectual property (IP) protection, it is quite difficult to obtain benchmarks of the automotive system models from the real-world industry [21]. Even few companies are willing to provide any detailed information and data, especially for free. Therefore, some extractions tools are required to be used in order to convert IP-critical real-world applications into IP-non-critical characteristics information. After

(19)

the detailed information of characteristics is provided, we are able to design the system generator to generate benchmarks for all the system cases.

In [23], there is an extraction tool that can calculate the characteristics in IP-non-critical benchmark for the systems with the model called AMALTHEA.

7.2

Communication Pattern

According to different components included in one task, there are three types of accesses, which are the read-only mode, the write-only mode and the read-write mode. In this paper, we focus on the tasks with the read-write mode, which means all the tasks in the task chain can read at the beginning of the execution and writing message in the end.

To fulfill the communication in one task or between each two tasks in the task chain, there are two types of communication cases as follows:

• Intra-task communication: the communication occurs in the same task in the task chain. With different sequences, intra-task communication also has two modes. One is Forward intra-task communication, which represents the tasks whose writing units run before their reading units. On the contrary, the other mode is Backward intra-task communication, which means the reading units in the task are executed prior to their writing units.

• Inter-task communication: the communication occurs between two tasks in the task chain. Compared to the two modes of intra-task communication, inter-task communication is a more frequent one.

In this thesis, we are more interested in inter-task communication.

Since event-triggered tasks are not of interest in this thesis, time-triggered tasks that have predefined periods are the main object we analyze. The inter-task communication possibly occurs between two tasks with different periods, which results to the difference on the amount of com-munication. The relationship between the sender and the receiver is shown in Table1, where the senders are listed in the rows and the receivers in the columns. There are six levels when it comes to the amount of communication. Communication can occur if the level is between Level I and Level VI, and the higher the level is, the more amount of communication there exists between the sender and the receiver. Nevertheless, no communication occurs if there is no level marked in the corresponding cell in the table. For instance, there is no communication between the sender with the period of 1 millisecond(ms) and the receiver with the period of also 1 millisecond. In our the-sis, the concrete level of communication is not necessarily taken into account, but the task chain will not be generated if there is no communication between senders and their receivers. When generating the benchmarks for the systems, this rule should be followed, which is the necessary condition for reachable communication.

Period 1ms 2ms 5ms 10ms 20ms 50ms 100ms 200ms 1000ms 1ms - - - I I - I - -2ms - - - I I - I - -5ms - I IV IV II II I - -10ms II II II VI IV II IV II III 20ms I I I IV VI II IV I II 50ms - - II II II III I - -100ms - I I V IV II VI II III 200ms - - - I I - I I I 1000ms - - - III II - III I IV

(20)

Additionally, the typical periods applied in this work are 1ms, 2ms, 5ms, 10ms, 20ms, 50ms, 100ms, 200ms and 1000ms. However, in automotive system, there also exists communication with special period, such as angle synchronous communication, which is explained concretely in [21]. According to that paper, the distribution among periods is shown as Table2. According to the table of the distribution, tasks with periods of 10ms and 20ms are the most frequent cases.

Period Share 1ms 3% 2ms 2% 5ms 2% 10ms 25% 20ms 25% 50ms 3% 100ms 20% 200ms 1% 1000ms 4% angle 15%

Table 2: Task Distribution Among Periods with angle-synchronous

Angle-synchronous tasks are not involved in this paper, and only tasks with predefined periods from the period set {1ms, 2ms, 5ms, 10ms, 20ms, 50ms, 100ms, 200ms and 1000ms} will be generated in this thesis. Therefore, the table of distribution should be modified, as Table3shown.

Period Share 1ms 3.5% 2ms 2.4% 5ms 2.4% 10ms 29.4% 20ms 29.4% 50ms 3.5% 100ms 23.5% 200ms 1.2% 1000ms 4.7%

Table 3: Task Distribution Among Periods without angle-synchronous

When generating the systems, tasks are created automatically and randomly but followed the specified distribution. Moreover, as Simon et al [21] mentions, the cyclic transition, for example 2ms⇒ 5ms⇒ 2ms, is not allowed. All in all, the rules mentioned in this Subsection 7.2 have to be followed during the system generation, as shown in Figure12.

(21)

7.3

Calculation of Worst Case Execution Time

The execution times of the tasks , which as Table4shows can be specified to Minimum Execution Time, Average Execution Time and Maximum Execution Time, are generated based on Weibull distribution. As Simon et al [21] mentioned, the Average Execution Time is what the tasks in the system benchmarks have to be matched with.

Period Minimal(µs) Average(µs) Maximum(µs)

1ms 0.34 5.00 30.11 2ms 0.32 4.20 40.69 5ms 0.36 11.04 83.38 10ms 0.21 10.09 309.87 20ms 0.25 8.74 291.42 50ms 0.29 17.56 92.98 100ms 0.21 10.53 420.43 200ms 0.22 2.56 21.95 1000ms 0.37 0.43 0.46

Table 4: Average Execution Times

WCET is more widely and frequently considered in timing analysis, so WCET is chosen in our project rather than BCET. worst case has a range from minimum WCET to maximum WCET, as Figure13shows. A certain WCET depends on the given hardware platform, but also belongs to that range. If we want to calculate WCETs for the tasks, we need to multiply the Average Execution Time by a factor. The minimum execution time is calculated by multiplying average with fmin while the maximum execution time with fmax, as shown in Figure5. In this paper, the WCET is randomly picked in the range [minimum WCET, maximum WCET] for each task, where the minimum WCET and maximum WCET is shown in Table5. By picking the factor randomly in the range [ fmin, fmax ], we can get the WCET for the task.

Figure 13: Execution Time Calculation

Generally, the unit for WCET is microsecond(µs), but in order to optimize the time consump-tion and CPU utilizaconsump-tion of the two methods of timing-analysis, nanosecond(ns) is applied in this paper. This is because, if we use microsecond to define the WCET, the data format of real floating point or even double-precision is necessary. This format will consume much time when the CPU does some numerical operations. If we use nanosecond to define the WCET, the data format of long is recommended. Compared to float and double, numerical operations with the format of long can be more simple and consumes less time. Since time consumption of the methods is one of the aspects for evaluations, nanosecond(ns) is the better choice.

(22)

Period fmin fmin*Average(µs) fmax fmax*Average(µs) 1ms 1.30 6.50 29.11 145.55 2ms 1.54 6.47 19.04 79.97 5ms 1.13 12.48 18.44 203.58 10ms 1.06 10.70 30.03 303.00 20ms 1.06 9.26 15.61 136.43 50ms 1.13 19.84 7.76 136.27 100ms 1.02 10.74 8.88 93.51 200ms 1.03 2.64 4.90 12.54 1000ms 1.84 0.79 4.75 2.04

Table 5: Factors For Determining Worst Case Execution Times

7.4

Cause-Effect Chains

In typical engine control application, most of the cause-effect chains have runnables with merely one activation pattern involved. The other cause-effect chains might have 2 or 3 patterns involved. The distribution is shown in Table6.

Involved Activation Pattern Share

1 70%

2 20%

3 10%

Table 6: Involved Activation Patterns Per Cause-Effect Chain

Number of Runnables Share

2 30%

3 40%

4 20%

5 10%

(23)

Each activation pattern can have a certain number of runnables. In typical engine control applications, the number of runnables in per activation pattern is from two to five, the distribution of which is shown in Table7.

For example, there are three activation patterns in one cause-effect chain and each of the patterns has 3 runnables, 2 runnables and 2 runnables respectively.

Figure 14: cause-effect chain with 3 patterns

Apart from tasks that have communication in the cause-effect chains, there are also many tasks not included in the timed path. The latter tasks have little influence in dataage but a great impact when it comes to calculation of the response time. In this paper, each taskset contains one third of tasks that have communication and are included in times path. For example, if there are 6 tasks in the cause-effect chain, this taskset should have 18 tasks included.

7.5

Algorithm for System Generation

The system-generating algorithm should follow the three rules mentioned in Subsection 7.2 and calculate the execution time according to the method in Subsection 7.3. The algorithm below describes the main mechanism. In this paper, each system has one cause-effect chain, the number of tasks in the taskset in the system is three times as many as the number of tasks in the cause-effect chain.

Algorithm of System Generation: TaskGeneration(int NumberOfTask, int iteration) 1 for iteration (from 0 to 1000){

2 indexnext = taskInitial();

3 patternNum = getPatternNumber(NumberOfTask);

4 generationTaskChain(patternNum);

5 generateOtherTasks(NumberOfTask*2);

6 }

The algorithm of system generation depends on two inputs. One is the number of the tasks included in one task chain (normally from 3 tasks to 15 tasks), while the other is the number of the cases this type of system will have(default is 1000). The type of variable patternNum (Line 3) is int[ ], the length of which can be 1, 2 and 3. The length of variable patternNum represents the number of activation patterns involved in the cause-effect chain, which is set according to the pattern distribution in Table 6. The value of each row in variable patternNum represents the number of each activation pattern, which is set according to the runnable distribution in each pattern in Table7. For example patternNum is [2, 3, 3], which means this cause-effect chain has three activation patterns, which have 2 runnables, 3 runnables and 3 runnables respectively.

After that, the task chain is generated by function generationTaskChain(patternNum)(Line 4), where the period of each runnable is picked randomly and automatically according to the rule of inter-task communication in Table1and the distribution of period in Table3. In this algorithm, as Table3shows, periods are predefined based on the period set{1ms, 2ms, 5ms, 10ms, 20ms, 50ms, 100ms, 200ms and 1000ms}.

During the task generation, some characteristics will be checked in order to guarantee that all the tasks meet the rules like cyclic transition constraint, inter-task communication table and task distribution among periods, in Subsection 7.2.

(24)

8

Results and Evaluation

8.1

Experiment Settings

As it has been mentioned before in this paper, our target is to analyze the performance of two end-to-end delay calculation methods [8, 10] under different system settings. The experiments designing is shown in Figure 15, which is composed by 3 parts: system generation, calculation and evaluation. Firstly, systems with different settings are generated, and then calculate their data age by the 2 methods. After getting the results, the performance of the 2 methods will be evaluated.This thesis will make evaluations from the following aspects:

1. Data Age of a cause-effect chain

2. Time Consumption of the methods for the time analysis

Figure 15: Diagram of the Project

For the generation of the system, each system has one event chain which includes specific number of tasks, and the chain scale (task number) is 1 third of the whole system’s scale. The periods of tasks are selected from period set{ 1ms, 2ms, 5ms, 10ms, 20ms, 50ms, 100ms, 200ms, 1000ms} according to the predefined portion of each period value. The task number is from 3 to 15 in one task chain, and for each specific number of tasks, 1000 system cases are applied. The generated systems are sent to two calculation blocks, which calculate end-to-end delays by method 1 [8] and method 2 [10] respectively. The tasks are all in time-triggered type, and the priorities of the tasks are assigned according to Rate Monotonic. For tasks with equal periods, the priority’s distribution is arbitrary.

By calculating the average value of data age of systems with each certain number of tasks and the average calculation time, we analyze the influence of task number in one chain for the performance of the two methods. And also by comparing the values of the two methods when they are applied into the same systems, we can compare the performance of each method under different system settings, which can help us to choose the optimal method for each kind of system.

Table 8: Hardware Environment Setting

System-Hardware Information

Processor AMD A8-6500 APU @ 3.10GHz

System Type 64-bit Operation System

GPU Radeon(tm) HD Graphics

Memory 4GB RAM

Additionally, to guarantee the comparability, both methods run under the same computer environmental settings (both hardware and software), as the Table8and9show. The first method for analysis runs with C code under the Visual Studio Environment, and the second method runs

(25)

Table 9: Software Environment Setting

System-Software Information

Operation System Windows 10 Ultimate 64-bit

C Compile Environment Visual Studio Education 2017 Java Compile Environment Eclipse Oxygen 4.7.0

with Java code under the Eclipse Environment. The time consumption of each method includes only the interval from the beginning of the time delay analysis process to the end of that, but excludes the time consumed in the loading of the system and the calculation of Response Time.

8.2

Experiment Results

After the benchmarks have been generated by the system generation unit, the two methods are able to run and the results of the experiment are demonstrated in the following tables.

Table10describes the average values of data age for systems with 3-15 tasks based on 3 different system knowledge levels by Method 2. The comparison of these experiment results is demonstrated in the next Subsection 8.3.

Table 10: The Average Data Age Calculated by Method 2 (ms)

Task Number \

Knowledge Level No Information WCRT LET

3 159.35 106.37 46.43 4 218.50 159.86 167.96 5 285.86 223.61 230.30 6 484.96 356.74 408.23 7 534.97 412.09 464.88 8 680.04 540.44 604.48 9 862.18 703.59 769.67 10 1040.65 865.58 937.77 11 1417.70 1172.79 145.42 12 1553.97 1288.37 1395.47 13 1841.32 1554,58 1692.83 14 2131.72 1828.75 1979.95 15 2334.50 2024.60 2177.00

(26)

Table11describes the average values of time consumptions for systems with 3-15 tasks based on 3 different system knowledge levels by Method 2.

Table 11: The Average Consumption Time Consumed by Method 2 (ms)

Task Number \

Knowledge Level No Information WCRT LET

3 0.08 0.05 0.07 4 0.27 0.18 0.18 5 0.51 0.19 0.20 6 21.72 11.43 11.33 7 24.58 16.41 16.43 8 167.73 31.36 31.34 9 282.24 23.85 23.94 10 537.62 14.91 14.90 11 2335.27 70.26 70.04 12 6170.56 100.47 99.95 13 8480.31 62.24 61.48 14 18991.91 96.26 96.80 15 26565.08 29.94 32.50

Table12describes the average data age for systems with chains consisted of 3-6 tasks by Method 1 and the corresponding time consumption. The systems with 7 to 15 tasks in one chain have no data. This is because it took too much time for Method 1 to run 1000 system cases in order to calculate the average value, but still hasn’t got results yet. This is because the calculation times in method 1 increase dramatically with the increasing of task number in task chains, which results in the huge jump of calculation time when task number increases.

Table 12: Data Age and Average Time Computation by Method 1(ms)

Items \ Task

Number 3 4 5 6 7

Data Age 106.99 160.01 223.44 2095.83 2328.42

Consumption

(27)

8.3

Result Analysis and Evaluation

8.3.1 Analysis and Evaluation of Data Age

Figure 16: Data Age by two methods

Figure 16 shows the calculated data age for different chains by different methods or under different conditions. According to Figure16, with the task number increasing in task-chain, the maximum data age under most conditions grows approximately with linear trends. Data ages calculated by Method 1 have similar accuracy to the data ages calculated by Method 2 based on the knowledge level of WCRT . Considering from the perspective of system knowledge levels, data ages calculated under WCRT level is always the best, while No Information knowledge level gives the lowest accuracy. This is because the accuracy of data age calculation depends significantly on knowledge level. In method 2, the ranges of read interval and data interval narrow with the increasing of knowledge level, which means some impossible interactions (impossible based on higher knowledge level) on timed paths with longer data age than real one will be excluded. With these timed path excluded, the accuracy of calculated data age will then increase.

8.3.2 Analysis and Evaluation of Time Consumption

Figure 17shows the change of time consumption with the increasing of task number. From the plot, we can find that time consumption under No Information level increases with the increasing of task number, and it is much larger than that under other knowledge levels since 10-tasks chain. Figure 18 demonstrates the changes of time consumption from 3-tasks chain to 6-tasks chain in detail, and we can find that the time consumption of method 1 is always larger than method 2. When task number is 6, the time consumed by method 1 is already more than 10 times larger than time consumed by others. From this aspect, we can say that method 2 is better than method 1. Looking into method 2, figure19 shows the trajectories of time consumption of method 2 under WCRT level and LET model level. Under these two knowledge level, method 2 has similar time consumption, but not like under No Information level, the plots are curved without any obvious upward trend when the task number increases.

The difference between method 1 and method 2 is the determination of valid timed paths. In method 1, the calculation times of this process increases with the rising of task numbers, while there is no such concerns in method 2. So the gap of the time consumption of the two methods broaden rapidly with the increasing of task number. If we consider method 2 only, no knowledge means that there will be larger time intervals, as well as more valid timed path which will consume

(28)

Figure 17: Time Consumption by two methods

(29)

Figure 19: Time Consumption under WCRT and LET model

more time. As for WCRT and LET Model, the difference of the ranges of read intervals and data intervals between WCRT level and LET Model level is small, so the number of valid timed paths on the two knowledge level are close to each other, which can explain the similar trajectories on figure19.

(30)

9

Conclusion

In the development of automotive systems, timing analysis is one of the most importance aspects concerned with system performance. In this thesis, we compare two end-to-end delay calculation methods [8,10] and evaluate their performance from different aspects. In order to get enough valid experiment cases, an automotive system generation tool is developed, as mentioned in Section 7, which can automatically and randomly develop systems with different settings, like task number, task period and WCET. After the system generation, the two methods mentioned are applied to calculate the data age of the cases, and meanwhile the consumption time is recorded. By changing the number of tasks in one system and analyzing the characteristic of the values of the data ages and the consumption time, we get the specific performance of the two methods when they are utilized in different conditions. Besides, the influence of the task numbers to system data ages and the performance of calculation methods are also drawn from the experiment data, both of which are described in Subsection 8.3. According to results and evaluations from the experiments, if defined information about the system is available, Method 2 can work out more accurate data age and consume less time during the analysis than Method 1.

(31)

10

Future Work

In this thesis, we compare the performance of two end-to-end delay calculation methods by applying them into automotive systems with different configurations. Some results are acquired, but there are still some:

• Except for system task number, add more independent experiment variables like number of involved period and period distribution with the same hyper-period;

• Only time-triggered tasks are considered in present work, so the trigger types of tasks and their distribution on one tasks can both be considered in the future work;

• In our existing experiments, all the tasks in one system are in one chain, but in practice, there are usually some other tasks not belonging to the chain. This can actually influence the results of end-to-end timing analysis. So generating systems with tasks not in one chain and doing their timing analysis is also a future target;

(32)

Acknowledgement

To begin with this part, we would want to appreciate our supervisor Matthias Becker and examiner Saad Mubeen for the chance to do this thesis they gave us. Our supervisor Matthias is patient and wise. During the whole process, not only did he give us right guidance at appropriate time, but also helped us without any reservation whenever we asked help.

We also want to thank Mlardalen University (MDH) and East China University of Science and Technology (ECUST) for the chance to study in Sweden. Especially thank our Chinese mentors Ziqiang Sun and Yugang Niu for their support to our decision, and our international coordinator Adnan Causevic for the guidance about study, daily life. The study in MDH is interesting and challenging for us. We are both grateful to the help from all the course teachers and course assistants.

Last but not the least, we want to thank our friends Lili Qi, Yanna Shi, etc. for their compan-ionship and encouragement. During the thesis work, we do learn a lot of things and it is truly a pregnant and interesting experience for us. This will be a valuable asset in our lives and we will cherish these memories forever.

(33)

References

[1] T. H. C. Nguyen, P. Richard, and E. Grolleau, “An fptas for response time analysis of fixed pri-ority real-time tasks with resource augmentation,” IEEE Transactions on Computers, vol. 64, no. 7, pp. 1805–1818, July 2015.

[2] M. Saksena and S. Hong, “An engineering approach to decomposing end-to-end delays on a distributed real-time system,” in Proceedings of the 4th International Workshop on Parallel and Distributed Real-Time Systems, Apr 1996, pp. 244–251.

[3] R. Obermaisser, “End-to-end delays of event-triggered overlay networks in a time-triggered architecture,” in 2007 5th IEEE International Conference on Industrial Informatics, vol. 1, June 2007, pp. 541–546.

[4] S. Mubeen and T. Nolte, “Applying end-to-end path delay analysis to multi-rate automotive systems developed using legacy tools,” in 2015 IEEE World Conference on Factory Commu-nication Systems (WFCS), May 2015, pp. 1–4.

[5] A. A. Std., “East-adl-domain model specification, east,” 2014. [6] A. Std., “Autosar - spec. of timing extensions,” 2014.

[7] Q. Wang, K. Jaffrs-Runser, Y. Xu, J. L. Scharbarg, Z. An, and C. Fraboul, “Tdma versus csma/ca for wireless multi-hop communications: A comparison for soft real-time networking,” in 2016 IEEE World Conference on Factory Communication Systems (WFCS), May 2016, pp. 1–4.

[8] N. Feiertag, K. Richter, J. Nordlander, and J. Jonsson, “A compositional framework for end-to-end path delay calculation of automotive systems under different path semantics,” in Proceedings of the IEEE Real-Time System Symposium Workshop on Compositional Theory and Technology for Real-Time Embedded Systems, Barcelona, Spain, November 30, 2008, 2008. [9] M. Becker, D. Dasari, S. Mubeen, M. Behnam, and T. Nolte, “Synthesizing job-level de-pendencies for automotive multi-rate effect chains,” in Embedded and Real-Time Computing Systems and Applications (RTCSA), 2016 IEEE 22nd International Conference on. IEEE, 2016, pp. 159–169.

[10] ——, “Analyzing end-to-end delays in automotive systems at various levels of timing informa-tion,” in IEEE 4th International Workshop on Real-Time Computing and Distributed systems in Emerging Applications REACTION’16, 29 Nov 2016, Porto, Portugal, 2016.

[11] I. E. C. Std., “Iec 61131-3,” 2003.

[12] A. Std., “Autosar–specification of rte software v4.2.2,” 2014.

[13] R. I. Davis, A. Burns, R. J. Bril, and J. J. Lukkien, “Controller area network (can) schedulability analysis: Refuted, revisited and revised,” Real-Time Systems, vol. 35, no. 3, pp. 239–272, 2007. [Online]. Available: http://dx.doi.org/10.1007/s11241-007-9012-7

[14] M. Joseph and P. Pandya, “Finding response times in a real-time system,” The Computer Journal, vol. 29, no. 5, p. 390, 1986. [Online]. Available: +http: //dx.doi.org/10.1093/comjnl/29.5.390

[15] K. W. Tindell, A. Burns, and A. J. Wellings, “An extendible approach for analyzing fixed priority hard real-time tasks,” Real-Time Systems, vol. 6, no. 2, pp. 133–151, 1994. [Online]. Available: http://dx.doi.org/10.1007/BF01088593

[16] A. C. Rajeev, S. Mohalik, M. G. Dixit, D. B. Chokshi, and S. Ramesh, “Schedulability and end-to-end latency in distributed ecu networks: Formal modeling and precise estimation,” in Proceedings of the Tenth ACM International Conference on Embedded Software, ser. EMSOFT ’10. New York, NY, USA: ACM, 2010, pp. 129–138. [Online]. Available:

(34)

[17] S. Schliecker and R. Ernst, “A recursive approach to end-to-end path latency computation in heterogeneous multiprocessor systems,” in Proceedings of the 7th IEEE/ACM international conference on Hardware/software codesign and system synthesis. ACM, 2009, pp. 433–442. [18] J. Sun and J. W. Liu, “Bounding the end-to-end response time in multiprocessor real-time

sys-tems,” in Parallel and Distributed Real-Time Systems, 1995. Proceedings of the Third Work-shop on. IEEE, 1995, pp. 91–98.

[19] A. Davare, Q. Zhu, M. Di Natale, C. Pinello, S. Kanajan, and A. Sangiovanni-Vincentelli, “Period optimization for hard real-time distributed automotive systems,” in Proceedings of the 44th annual Design Automation Conference. ACM, 2007, pp. 278–283.

[20] L. Thiele, S. Chakraborty, and M. Naedele, “Real-time calculus for scheduling hard real-time systems,” in Circuits and Systems, 2000. Proceedings. ISCAS 2000 Geneva. The 2000 IEEE International Symposium on, vol. 4. IEEE, 2000, pp. 101–104.

[21] A. H. Simon Kramer, Dirk Ziegenbein, “Real world automotive benchmarks for free,” 2015. [22] M. Becker, D. Dasari, S. Mubeen, M. Behnam, and T. Nolte, “Mechaniser-a timing analysis

and synthesis tool for multi-rate effect chains with job-level dependencies,” in 7th Interna-tional Workshop on Analysis Tools and Methodologies for Embedded and Real-time Systems WATERS’16, 05 Jul 2016, Toulouse, France, 2016.

[23] H. Mackamul, “Amalthea - an open tool platform for embedded multicore systems,” October 2013.

Figure

Figure 2: Data propagation paths and maximum data age
Figure 3: Flow Diagram of Research Method
Figure 4: Timed Paths
Figure 5: 4 Types of Timed Paths
+7

References

Related documents

The aim of this paper is to propose a specific measurement framework and relevant metrics for Company X to measure the performance of the end-to-end Product X supply chain.. Product

Introducing the site concept in the Hive system enables each client to favour a subset n ⊂ N of all the clients in the network which are likely to perform well and be close in

previous novels by McCarthy dreams tend to motivate characters, but dreams in The Road may offer hope of things that have been and can never be again, thus dreams in the

Our four cases are those of Sofia Kovalevskaya, mathematician, the first woman professor in Europe (at Stockholm University, 1898); Maria Sklodowska- Curie, physicist

KEY WORDS: N-Rheme, English, Swedish, contrastive, corpus-based, translation, parallel corpus, Systemic Functional Linguistics, information structure, information density, Rheme,

Burnt bones have the same distribution area as the Middle Neolithic pottery and the burnt flint.. A burnt pig bone has been 14 C-dated to the Middle

Paul Webb Flemmig Juul Christensen.. The European Parliament elections are the most important moment for European democracy as the European Parliame- nt is the only institution in

Together with the Council of the European Union (not to be confused with the EC) and the EP, it exercises the legislative function of the EU. The COM is the institution in charge