Slides created by: - PowerPoint PPT Presentation

About This Presentation
Title:

Slides created by:

Description:

Allow the processor to perform several ... Atomic Updates Mutual Exclusion Semaphores Critical Regions ... exclusive Each critical region ... – PowerPoint PPT presentation

Number of Views:44
Avg rating:3.0/5.0
Slides: 17
Provided by: Tria734
Category:

less

Transcript and Presenter's Notes

Title: Slides created by:


1
Operating Systems
  • Allow the processor to perform several tasks at
    virtually the same timeEx. Web Controlled Car
    with a camera
  • Car is controlled via the internet
  • Car has its own webserver (http//mycar/)
  • Web interface allows user to control car and see
    camera images
  • Car also has auto brake feature to avoid
    collisions

Web interface view
2
Multiple Tasks
  • Assume that one microcontroller is being used
  • At least four different tasks must be performed
  • Send video data - This is continuous while a user
    is connected
  • Service motion buttons - Whenever button is
    pressed, may last seconds
  • Detect obstacles - This is continuous at all
    times
  • Auto brake - Whenever obstacle is detected, may
    last seconds
  • Detect and Auto brake cannot occur together
  • 3 tasks may need to occur concurrently

3
Prioritized Task Scheduling
  • Sending Video Data and Detecting Obstacles must
    happen concurrently
  • Both tasks never complete
  • Servicing Motion Buttons must be concurrent with
    Sending Video Data
  • Video should not stop when car moves
  • CPU must switch between tasks quickly
  • Some tasks must take priority
  • Auto Brake must have highest priority

4
Sharing Global Resources
  • Global resources may be required by mulitple
    tasks
  • ADC, comparators, timers, I/O pins
  • Shared access must be controlled to avoid
    interference
  • Ex. Task 1 and Task 2 need to use the ADC
  • They cannot use the ADC at the same time
  • One task must wait for the other
  • Operating system guarantees that resource
    conflicts are resolved

5
Layered OS Architecture
  • OS provides an abstraction to hide details of
    hardware
  • Ex. delay(int) library function might setup a
    timer-based interrupt
  • Using Library functions incurrs overhead

6
Processes vs. Threads
  • Context of a task is its register values, program
    counter, and stack
  • All tasks have their own context
  • Context switch is when on task stops and the next
    starts
  • - Must save the old context and load the new
  • - This is time consuming
  • OS typically gives tasks access to memory (i.e
    malloc)
  • Processes each have their own private memory
  • - Requires memory protection
  • Threads share memory
  • RTOS usually implement tasks as threads

7
Memory Management
  • Programs can request memory dynamically with
    malloc()

int valarr10
int valarr valarr (int ) malloc(10
sizeof(int))
  • Dynamically allocated memory must be explicitly
    released
  • - statically allocated memory is released on
    function return

free(valarr)
  • Dynamic memory allocation is flexible but harder
    to deal with
  • - Must free the memory manually
  • - Cannot access freed memory

8
OS Memory Management
  • A program cannot know the dynamic memory
    allocation
  • - Which memory locations are used and which are
    available?
  • Operating system keeps tables describing which
    memory locations are available
  • The program must request memory from the OS
  • - OS may deny request if there is no memory
    available
  • OS also protects memory
  • - Enforce memory access permissions

9
Scheduler
  • OS manages the execution state of each task
  • 3 main states
  • 1. Running The task is currently running
  • 2. Ready The task is not running but it is
    ready to run
  • 3. Blocked The task is not ready because it is
    waiting for an event
  • Only one task can be running at a time
  • A task can only run if it is first ready (not
    blocked)
  • Scheduler must keep track of the state of each
    task
  • Scheduler must decide which ready task should run

10
Preemption
  • A non-preemptive scheduler allows a task to run
    until it gives up control of the CPU
  • - Task may call a library function (sleep) to
    quit
  • - Needs to be awakened by an event, like an
    interrupt
  • - Not much flexibility for OS to meet deadlines
  • A preemptive scheduler allows the OS to stop a
    running task and start another task
  • - OS has the power to influence the completion
    of tasks
  • - OS must be awakened periodically to make
    scheduling decisions
  • - May implement the OS kernel as a high priority
    timer-based interrupt

11
Scheduling Algorithms
  • Round-Robin
  • Scheduler keeps an ordered list of ready tasks
  • First task is assigned a fixed-size time slice to
    execute
  • After time slice is done, task is placed at the
    end of the list and next task executes for its
    time slice
  • Very simple, no priorities

Task 1
Task 2
12
Prioritized Scheduling
  • Fixed Priority Preemptive
  • Scheduler keeps an ordered list of ready tasks,
    ordered by priority
  • First task is assigned a fixed-size time slice to
    execute
  • After time slice is done, scheduler chooses
    highest priority ready task for next time slice
  • Next task might be the same as the previous task,
    if it is high priority
  • Starvation may occur

13
Atomic Updates
  • Tasks may need to share global data and resources
  • For some data, updates must be performed together
    to make sense
  • Ex. Our system samples the level of water in a
    tank
  • tank_level is level of water
  • time_updated is last update time
  • tank_level // Result of computation
  • time_updated // Current time
  • These updates must occur together for the data to
    be consistent
  • Interrupt could see new tank_level with old
    time_updated

14
Mutual Exclusion
  • While one task updates the shared variables,
    another task cannot read them

Task 1
Task 2
tank_level ? time_updated ?
printf (i i, tank_level, time_updated)
  • Two code segments should be mutually exclusive
  • If Task 2 is an interrupt, it must be disabled

15
Semaphores
  • A semaphore is a flag which indicates that
    execution is safe
  • May be implemented as a binary variable, 1
    continue, 0 wait

TakeSemaphore() If semaphore is available (1)
then take it (set to 0) and continue If semaphore
is note available (0) then block until it is
available ReleaseSemaphore() Set semaphore to 1
so that another task can take it
  • Only one task can have a semaphore at one time

16
Critical Regions
Task 1
Task 2
TakeSemaphore() tank_level ? time_updated
? ReleaseSemaphore()
TakeSemaphore() printf (i i, tank_level,
time_updated) ReleaseSemaphore()
  • Semaphores are used to protect critical regions
  • Two critical regions sharing a semaphore are
    mutually exclusive
  • Each critical region is atomic, cannot be
    separated
Write a Comment
User Comments (0)
About PowerShow.com