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
  • Internal Architecture of a Real-Time OS/Kernel
  • Management structures
  • The TCB (task control block)
  • TCB structure
  • SCB structure
  1. Real Time Model

Kernel/RTOS Architecture

PreviousTask states and executionNextTime Management Functions

Last updated 2 years ago

Internal Architecture of a Real-Time OS/Kernel

Basic services:

  • Task management (create, delete, initial activation, state).

  • Time management (activation, policing, measurement of time intervals).

  • Task scheduling (decide what jobs to execute in every instant).

  • Task dispatching (putting jobs in execution).

  • Resource management (mutexes, semaphores, etc.).

Management structures

The TCB (task control block)

This is a fundamental structure of a kernel. It stores all the relevant information about tasks, which is then used by the kernel to manage their execution.

Common data (not exhaustive):

  • Task identifier.

  • Pointer to the code to be executed.

  • Pointer to the private stack (for context saving, local variables, ...).

  • Periodic activation attributes (task type (periodic/sporadic), period, initial phase, etc).

  • Criticality (hard, soft, non real-time).

  • Other attributes (deadline, priority).

  • Dynamic execution state and other variables for activation control, e.g. SW timers, absolute deadline, ...

TCB structure

TCBs are often defined in a static array, but are normally structured as linked lists to facilitate operations and searches over the task set.

E.g., the ready queue (list of ready tasks sorted by a given criteria) is maintained as a linked list. These linked lists may be implemented e.g. through indexes. Multiple lists may (and usually do) coexist!

SCB structure

Similarly, the information concerning a semaphore is stored in a Semaphore Control Block (SCB), which contains at least the following three fields:

  • A counter, which represents the value of the semaphore.

  • A queue, for enqueueing the tasks blocked on the semaphore.

  • A pointer to the next SCB, to form a list.