Notes - MIECT
Sistemas Operativos E De Tempo-real
Notes - MIECT
Sistemas Operativos E De Tempo-real
  • Sistemas Operativos e de Tempo-real
  • Basic Concepts About Real-Time Systems
    • Preliminaries
    • Definitions
    • Objective of the Study of RTS
    • Requirements of Real-Time Systems
  • Real Time Model
    • Real Time Model
    • Temporal Control
    • Task states and execution
    • Kernel/RTOS Architecture
      • Time Management Functions
    • Examples of RTOS
  • Practical Class 01
    • Real-Time Services in Linux
    • Using the Linux real-time services
  • Scheduling Basics
    • Basic concepts
    • Scheduling Algorithms
      • Basic algorithms
    • Static Cyclic Scheduling
    • Exercise
  • Fixed Priority Scheduling
    • Online scheduling with fixed priorities
    • Schedulability tests based on utilization
      • Deadline Monotonic Scheduling DM
    • Response-time analysis
  • Practical Class 2
    • Xenomai brief introduction
    • API
    • Developing an application
  • Dynamic Priority Scheduling
    • On-line scheduling with dynamic priorities
    • Analysis: CPU utilization bound
    • Analysis: CPU Load Analysis
    • Other deadline assignment criteria
  • Exclusive Access to Shared Resources
    • The priority inversion problem
    • Techniques for allowing exclusive access
    • Priority Inheritance Protocol
    • Priority Ceiling Protocol
    • Stack Resource Policy
    • Notes
  • Aperiodic Servers
    • Joint scheduling of periodic and aperiodic tasks
    • Aperiodic Servers
    • Fixed Priority Servers
    • Dynamic Priority Servers
  • Limited preemption, release jitter and overheads
    • Non-preemptive scheduling
    • Impact of Release Jitter
    • Accounting for overheads
    • Considerations about the WCET
  • Profiling and Code Optimization
    • Code optimization techniques
      • CPU independent optimization techniques
      • Cache impact
      • Optimization techniques dependent on memory architecture
      • Architecture-dependent optimization techniques
    • Profiling
  • Multiprocessor Scheduling, V1.2
    • Introduction
    • Definitions, Assumptions and Scheduling Model
    • Scheduling for Multicore Platforms
    • Task allocation
Powered by GitBook
On this page
  • Task creation
  • Task execution
  • Task States
  1. Real Time Model

Task states and execution

PreviousTemporal ControlNextKernel/RTOS Architecture

Last updated 2 years ago

Task creation

Association between executable code (e.g. a “C” language function) to a private variable space (private stack) and a management structure - task control block (TCB).

Task execution

Concurrent execution of the task’s code, using the respective private variable space, under control of the RTOS kernel. The RTOS kernel is responsible for activating each one of the task’s jobs, when:

  • A period has elapsed (periodic).

  • An associated external event has occurred (sporadic).

Task States

Execution of task instances (jobs).

  • After being activated, task’s jobs wait in a queue (the ready queue) for its time to execute (i.e., for the CPU).

  • The ready queue is sorted by a given criterion (scheduling criterion). In real-time systems, most of the time this criterion is not the arrival order!

  • Task instances may be waiting for execution (ready) or executing. After completion of each instance, tasks stay in the idle state, waiting for its next activation.

  • Thus, the basic set of dynamic states is: idle, ready and execution.

  • Other states: blocked.

    • Whenever an executing task tries to use a shared resource (e.g. a memory buffer) that is already being used in exclusive mode, the task cannot continue executing. In this case it is moved to the blocked state. It remains in this state until the moment in which the resource is released. When that happens the task goes to the ready state.

  • Other states: self suspension (sleep).

    • In certain applications tasks need to suspend their execution for a given amount of time (e.g. waiting a certain amount of time for a packet acknowledgment), before completing their execution. In that case, tasks move to the suspended state.