1 / 16

Operating Systems

This slideshow by Professor Ian G. Harris explores the concepts of operating systems that allow processors to perform multiple tasks simultaneously. It covers topics such as task scheduling, sharing global resources, memory management, and scheduling algorithms.

laurend
Download Presentation

Operating Systems

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Slides created by: Professor Ian G. Harris Fwd Left Right Back 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris Application Application Library Functions Microconrtoller System Calls Microconrtoller 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris Memory Management • Programs can request memory dynamically with malloc(); int valarr[10]; 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris Context switch time Task execution 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. Slides created by: Professor Ian G. Harris High Priority Low priority 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris 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. Slides created by: Professor Ian G. Harris 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

More Related