2.13 Module 14: operating system support

1. introduction to operating system (os)

The Operating System is the software that control the execution of programs on a processor and that manages the computer’s resources

• Operating System

– The Operating System (OS) is the program that manages the resources, provides

services to programmer, schedules execution of other programs.

– The OS masks the details of the hardware from the programmer

– The OS provides programmer a good interface for using the system that consists the new instructions are called system calls

– The OS mediates programmer and application programs requests for facilities and services

• Services provided

– Program creation -- general utilities

– Program execution -- loading, device

initializing, etc.

– Standardized access to I/O devices

– Controlled access to files

– Overall system access control

• Types of Operating System

– Interactive OS

User directly interacts with the OS through a keyboard / terminal

– Batch OS

User programs are collected together (“off line”) and submitted to the OS in a batch by an operator

Print-out results of the program execution is returned to the user

This type of OS is not typical of current machines

This type is used in the mainframes of 60-70s when the cost of hardware was such that you wanted to keep it busy all thetime

O/S was really a monitor program that focused on job scheduling

• Multiprogramming / time sharing

- An OS is said to be multiprogramming if it supports the simultaneous execution of more than 1 job. In this case a queue of pending jobs is maintained

- Current job is swapped out when it is idled waiting for I/O and other devices

Next pending job is started

- Time sharing is the term formultiprogramming when applied to an interactive system

Either requires much more sophistication than a typical batch OS: Memory management and Scheduling

2. os scheduling

• In multiprogramming OS, multiple jobs are held in memory and alternate between

using the CPU, using I/O, and waiting (idle)

• The key to high efficiency with multiprogramming is effective scheduling

– High-level

– Short-term

– I/O

• High-level scheduling

– Determines which jobs are admitted into the system for processing

– Controls the degree of multiprocessing

– Admitted jobs are added to the queue of pending jobs that is managed by the short-termscheduler

– Works in batch or interactive modes

• Short-term scheduling

– This OS segment runs frequently and determines which pending job will receive the

CPU’s attention next

– Based on the normal changes of state that a job/process goes through

– A process is running in the CPU until:

+It issues a service call to the OS (e.g., for I/O service)

+ Process is suspended until the request is satisfied. Process causes and interrupt and is Suspended. External event causes interrupt

– Short-term scheduler is invoked to determine which process is serviced next.

Figure 14.1 Scheduling queues

- Queues are simply lists of jobs that are waiting for some type of service (e.g., CPU cycles, I/ etc.). Once job has been admitted into the system by the high-level scheduler, it is allocated its portion of memory for its program and data requirements

- The objective of the short-term scheduler is to keep the CPU actively working on one of the pending jobs -- maximize the used CPU cycles

- Problem:

+ The high-level scheduler will admit as many jobs as possible (constrained by

system resources such as available memory)

+ Despite many jobs in the system, the speed of the CPU (compared to peripherals) might be such that all jobs are waiting for (slow) I/O and thus the CPU is idled (no jobs in the ready queue)

+ Use memory management to solve this

3. os memory management

One of important task of OS is to menage the memory system. To avoid having the CPU idle because all jobs are waiting, one could increase the memory size to hold more jobs

– Memory is expensive costly solution to the problem

– Programs’ sizes (process sizes) tend to expand to take up available memory

A better approach is to use a mechanism to remove a waiting job from memory and

replace it with one that (hopefully) will run on the CPU in the short term

– This is the idea of swapping

– Idle processes are removed from the memory and placed in an intermediate queue

– Replace idled job with a “ready” one from the front of the intermediate queue or with a new job

– Swapping uses I/O operations to read and write to disk.

The virtual memory will be presented in the next section.