Real Time Terms - Revision history

Dougher: fix capitalization

2012-09-13T23:48:44Z

fix capitalization

Show changes

Glenn: catspec Category:Linux

2008-02-10T20:51:54Z

catspec Category:Linux

Glenn: +Category:Community

2008-02-10T19:07:24Z

+Category:Community

TimBird at 01:18, 4 September 2007

2007-09-04T01:18:13Z

TimBird: adjust scheduling latency definition

2007-09-04T01:14:04Z

adjust scheduling latency definition

TimBird: fix some stuff

2007-09-04T01:03:27Z

fix some stuff

TimBird: add sched_fifo explanation

2007-09-04T00:51:35Z

add sched_fifo explanation

TimBird: /* Time Periods */ expand notes on time periods

2007-06-08T18:45:46Z

‎Time Periods: expand notes on time periods

TimBird: Add timing model

2007-06-08T18:35:45Z

Add timing model

TimBird: fix formatting

2007-06-07T22:27:03Z

fix formatting

← Older revision		Revision as of 20:51, 10 February 2008
Line 100:		Line 100:
	* granularity (above definition is weak)		* granularity (above definition is weak)

−	[[Category:~~Categories~~]]	+	[[Category:Linux]]

← Older revision		Revision as of 19:07, 10 February 2008
Line 99:		Line 99:
	* precision		* precision
	* granularity (above definition is weak)		* granularity (above definition is weak)
		+
		+	[[Category:Categories]]

@@ Line 34: / Line 34: @@
 ; Mutual exclusion : prevent multiple tasks or ISRs from accessing the same data concurrently. Mutual exclusion is used to protect the integrity of the data.
-; Preemption : a running thread or process can be temporarily suspended. The state of the thread or process (including e.g., program counter, and register values) is saved. Until the thread is resumed, it remains runnable (active, ready). When the process or thread is later resumed, the saved state is restored.
+; Preemption : a running thread or process can be temporarily suspended. The state of the thread or process (including e.g., program counter, and register values) is saved. When the process or thread is later resumed, the saved state is restored.
-; Priority inheritance : if a high priority-task blocks for a critical section, a low-priority task that has holds the lock for the section gets a priority boost. It inherits the priority of the blocked task. This prevents the unbounded priority inversion that could occur if medium priority tasks would preempt the lower-priority task that holds the lock. Note that, with priority inheritance, the medium-priority tasks suffer priority inversion as well. But, and this is important in real-time systems, the priority inversion for all tasks is bounded (can be determined without knowing the exact run-time schedule)
+; Priority inheritance : if a high priority-task blocks for a critical section, a low-priority task that holds the lock for the section gets a priority boost. It inherits the priority of the blocked task. This prevents the unbounded priority inversion that could occur if medium priority tasks preempt the lower-priority task that holds the lock. Note that, with priority inheritance, the medium-priority tasks suffer priority inversion as well. But, and this is important in real-time systems, the priority inversion for all tasks is bounded (can be determined without knowing the exact run-time schedule)
 ; Priority inversion : the highest priority task is not running. There can be several reasons for priority inversion. One of them is the absence of full preemption. Priority inversion is one of the main reasons for deadlines being missed.
@@ Line 82: / Line 82: @@
   Note that sometimes this term is used to refer to the time from A to C (from interrupt assertion to process start)
 ; Processing time : The time from C to D (from process start to completion of processing)
-; Response latency : The time from A to D (total time from interrupt assertion to delivery of processed data)
+; Response time : The time from A to D (total time from interrupt assertion to delivery of processed data)
 Often, these or similar terms are used with less accuracy to describe the closest

@@ Line 65: / Line 65: @@
 === Events ===
 * A - hardware interrupt assertion
 ** This is the time when the hardware interrupt line for an event is raised
 * B - Interrupt service routine starts execution
-* C - Process starts execution
+* B' - Task is scheduled
 * D - Result is received from processing the event
@@ Line 77: / Line 79: @@
 Here are some common terms, expressed relative to those events:
 ; Interrupt latency : The time from A to B (from hardware interrupt assertion to ISR start)
-; Scheduling latency : The time from B to C (from ISR start to process start)
+; Scheduling latency : The time from B' to C (from time of task scheduling to process start)
   Note that sometimes this term is used to refer to the time from A to C (from interrupt assertion to process start)
 ; Processing time : The time from C to D (from process start to completion of processing)

@@ Line 14: / Line 14: @@
   Note: Fixed priority scheduling is typically designed to be used for a single coherent application.
-; Granularity : the time range of a certain interval. We can talk about the granularity of a timing requirement, of a non-interruptible code segment, etc.
+; Granularity : the time range of a certain interval. We can talk about the granularity of a timing requirement, of a non-interruptible code segment, etc. ''Needs fixing''
 ; Hard deadline requirement : missing the deadline is considered an error.
@@ Line 20: / Line 20: @@
 ; Hard real-time system : system with hard real-time requirements.
-; Hybrid real-time system : system with both hard and soft real-time requirements. CE systems are expected to be of this kind. The challenge in designing a hybrid real-time system is to get good soft real-time performance while meeting the hard real-time requirements. This is typically achieved by using a technique called reservation.
+; Hybrid real-time system:  This refers to a system where a real-time kernel is used in conjunction with a (mostly) unmodified Linux kernel, to provide real-time services to a subset of tasks on the system.  This is often also referred to as the "multi-kernel" approach.
 ; Interrupt latency : time passed between interrupt occurrence and activation of interrupt handler.
@@ Line 92: / Line 92: @@
 But it may be that timing these individual operations at a finer granularity requires
 instrumentation or hardware support not reasonably available for a test.

@@ Line 10: / Line 10: @@
 ; Deadline requirement : a real-time requirement that requires the response to be completed within a fixed time interval from the triggering event. A ''relative deadline'' is the duration of the above mentioned interval; an ''absolute deadline'' is the moment in time at which the response must be completed.
-; Fixed priority preemptive scheduling : the task with the highest priority is always running. If a task with a higher priority becomes runnable, the running task will be preempted immediately. The priority of a task, process or Interrupt Service Routine (ISR) is explicitly determined at creation, or by an explicit set-priority command.  No implicit priority changes by the scheduler are assumed. For an exception to this rule see '''Priority inheritance.'''
+; Fixed priority preemptive scheduling : the task with the highest priority is always running. If a task with a higher priority becomes runnable, the running task will be preempted immediately. The priority of a task, process or Interrupt Service Routine (ISR) is explicitly determined at creation, or by an explicit set-priority command.  No implicit priority changes by the scheduler are assumed. For an exception to this rule see '''Priority inheritance.''' The scheduling policy of SCHED_FIFO in Linux implements fixed priority preemptive scheduling.
   Note: Fixed priority scheduling is typically designed to be used for a single coherent application.

← Older revision		Revision as of 18:35, 8 June 2007
Line 59:		Line 59:

	; Soft real-time system : system with soft real-time requirements		; Soft real-time system : system with soft real-time requirements
		+
		+	== Timing Model ==
		+	It is relatively well-established that the following events and time periods are of interest
		+	when measuring realtime performance:
		+
		+	=== Events ===
		+	* A - hardware interrupt assertion
		+	** This is the time when the hardware interrupt line for an event is raised
		+	* B - Interrupt service routine starts execution
		+	* C - Process starts execution
		+	* D - Result is received from processing the event
		+
		+	=== Time Periods ===
		+	Real time performance is often expressed in terms of the maximum, minimum and average duration
		+	for certain time periods defined by the events above.
		+
		+	Here are some common terms, expressed relative to those events:
		+	; Interrupt latency : The time from A to B
		+	; Scheduling latency : The time from B to C (this is sometimes referred to as the time from A to C)
		+	; Processing time : The time from C to D
		+	; Response latency : The time from A to D
		+
		+	Often, these or similar terms are used with less accuracy to describe the closest
		+	approximation one can get to these, with a particular test framework and instrumentation set.
		+
		+	For example, Response latency may be reported as "response time", and refer to the time from
		+	when a host program records the time, previous to transmitting a piece of data which will cause
		+	an interrupt on the target machine, to the time when a host program records the time after
		+	receiving some signal from the target that processing is completed. Of course, time is taken
		+	in the operations of recording time, tranmissing data, and detecting signals on the host machine.
		+	But it may be that timing these individual operations at a finer granularity requires
		+	instrumentation or hardware support not reasonably available for a test.

@@ Line 32: / Line 32: @@
 ; Jitter – relative : deviation of the interval between two successive occurrences of an event (e.g. completion of frame) from expected interval.
-; Mutual exclusion : prevent multiple tasks or ISRs from accessing the same data
+; Mutual exclusion : prevent multiple tasks or ISRs from accessing the same data concurrently. Mutual exclusion is used to protect the integrity of the data.
- concurrently. Mutual exclusion is used to protect the integrity of the data.
 ; Preemption : a running thread or process can be temporarily suspended. The state of the thread or process (including e.g., program counter, and register values) is saved. Until the thread is resumed, it remains runnable (active, ready). When the process or thread is later resumed, the saved state is restored.
@@ Line 45: / Line 44: @@
 ; Real-time system : system with one or more real-time requirements.
-; Response time (worst-case) : (worst-case) time passed between event occurrence
+; Response time (worst-case) : (worst-case) time passed between event occurrence and completion of the response to that event. The event may be an interrupt. The response typically involves an interrupt handler and one or more synchronized tasks.
- and completion of the response to that event. The event may be an interrupt.
- The response typically involves an interrupt handler and one or more synchronized tasks.
 ; Runnable task : (also ready/active task) a task that can run from a logical perspective, but is prevented from running physically.
@@ Line 53: / Line 50: @@
 ; Semaphore : a synchronization primitive often used to achieve mutual exclusion.
-; Soft deadline : missing deadlines is sometimes acceptable. Compared to hard
+; Soft deadline : missing deadlines is sometimes acceptable. Compared to hard deadlines, where there is no reason to consider the value of a late result, the value of a late result for a soft deadline is of interest.  The value of the result may, for instance, decrease linearly after the deadline.
- deadlines, where there is no reason to consider the value of a late result,
- the value of a late result for a soft deadline is of interest.  The value of
- the result may, for instance, decrease linearly after the deadline.
 ; Soft real-time requirement : soft deadline, or average-case response time requirement.