CP1300 Operating Systems

History

• Early systems
  • Had only hardware
  • Input on tape/card, output on tape/card/printer
  • Programmer was an operator
  • Time sharing by booking time
  • Common programs to ease development (assemblers, linkers, etc)
  • Libraries of common functions (IO, etc)
  • To run a FORTRAN program ...
  • Low CPU usage
• Batch systems
  • Resident batch monitor
  • Read JCL cards to run jobs
  • Only one part of the machine busy at a time
• Offline operation
  • Online: card -> CPU -> printer
  • Offline : card -> tape; tape -> CPU -> tape; tape -> printer
• Buffering bulk transfers data to and from IO devices, using interrupts
• Multitasking batched systems
  • System keeps a job queue
  • Admits multiple tasks onto the machine to run concurrently
  • While some are doing IO, one uses the CPU
• Timesharing systems
  • Multitasking on demand by multiple users
• Personal computer systems
  • Single user, multitasking
• Real time systems
  • Single user, single task

Operating System Functions and Operations

• OS tasks
  • Load and control when programs may run (process management)
  • Memory allocation for programs
  • I/O control, e.g., disk, printer
  • File system management
  • User validation and security

• Process management
  • Loading processes
    • Machine code is on disk in a file
    • Machine code is copied into RAM (see memory management)
    • Process is ready to run
  • Information about process is kept in a PCB
    • Where in memory
    • What it's doing
    • Other information
  • A process may be
    • Running - using the CPU
    • Ready - waiting for the CPU
      • Scheduler keeps the ready process PCB ordered in a queue
    • Blocked - waiting for something, e.g., keyboard
      • Blocked process PCBs are kept in queues for each "thing"
  • Process switching
    • OS schedules small amounts of time (milliseconds) for programs to use the CPU
    • Process uses CPU until
      • Interrupted by clock
      • Needs some resource
      • Interrupted by IO completion
      • Process completes
    • Process state is saved and OS code executes
    • Clock interrupt
      • Process is rescheduled
    • Resource request
      • Done by trap to OS
      • OS code runs to form request
      • If not immediately satisfied, PCB is placed on blocked queue
    • I/O interrupt
      • Blocked process becomes ready
    • Completion - PCB is discarded
    • Dispatcher swaps processes onto the CPU
      • Running process is made ready and rescheduled
      • First process on ready queue is placed on CPU
    • Switching of programs gives the impression of all programs running together (on a fast computer!)
    • For example, 3 programs running: pine, pico, tcsh

        Time (ms)       Running Program         Waiting Program(s)
        0.000           tcsh                    pine, pico
        0.002           pine                    pico, tcsh
        0.003           pico                    tcsh, pine
        0.006           tcsh                    pine, pico
      

      • This is called round-robin scheduling
      • There are many different way of scheduling programs.
    • The Life of a Process (picture)

• Memory management
  • Memory allocation
    • Programs execute in their own block of memory
    • When a program ends, the OS reclaims the block
    • Example: Two programs need to be allocated memory: xgdb needs 3MB, pine needs 1MB. Memory initially contains the OS, a graphics buffer, and device drivers.

        Address  0   1   2   3   4   5   6   7   8
        Contents OS  GB  DD  DD  FM  FM  FM  FM  FM
      

      The OS allocates xgdb and then pine (biggest program first):

        Address  0   1   2   3   4   5   6   7   8
        Contents OS  GB  DD  DD  XG  XG  XG  PI  FM
      

      Then xgdb finishes, and the OS reclaims the 3MB:

        Address  0   1   2   3   4   5   6   7   8
        Contents OS  GB  DD  DD  FM  FM  FM  PI  FM
      

      Then two copies of lynx, each requiring 2MB, are started. The first is allocated:

        Address  0   1   2   3   4   5   6   7   8
        Contents OS  GB  DD  DD  L1  L1  FM  PI  FM
      

      How can the second copy be accomodated?

  • Dynamic relocation
    • pine has to be relocated to address 7

        Address  0   1   2   3   4   5   6   7   8
        Contents OS  GB  DD  DD  L1  L1  PI  L2  L2
      

  • Swapping
    • Another copy of pine is started. Where does it go?
    • If, e.g., L1 is blocked, it can be swapped out to disk

        Address  0   1   2   3   4   5   6   7   8          DISK
        Contents OS  GB  DD  DD  P2  FM  PI  L2  L2         L1 (2MB)
      

    • A copy of g++ (4MB) is started. Where does it go?
    • Maybe only part of g++ (1MB) is needed in memory:

        Address  0   1   2   3   4   5   6   7   8          DISK
        Contents OS  GB  DD  DD  P2  G+  PI  L2  L2         L1 (2MB)   G+ (3MB)
      

      The disk space is called virtual memory. VM allows processes larger than the real memory.

  • Protection
    • Processes must be prevented from corrupting each others memory block

• I/O Control
  • Devices that need to be controlled include
    • Terminals
    • Printers
    • Disk
    • CD ROM
  • Many resources can only be used one at a time (eg. printer).
  • The OS must schedule system resource usage. How?
  • Device access
    • Call OS routine with needed information
    • Request is added to a priority queue of requests
      • Allow high priority programs first access to resources
      • Allocate resources in the order they are requested
      • Allocate only the fastest/smallest requests first
    • Device driver deals with requests
    • Devices use interrupts to signal completion

• File system management
  • Files are stored in secondary storage (eg. disk drives)
  • Files change over time and occupy various parts of a disk
  • Each disk surface is divided into tracks, and each track into sectors
  • Files are allocated sectors
  • A file look-up table records where the file is stored

    

  • OS tasks include
    • File creation, deletion, reading, writing
    • Controlling simultaneous access
    • Symbolic names for files
    • Access control
    • Providing fault tolerance
  • Direct access to the device is done by a device driver

• User validation and security
  • User processes may not damage or control the computer, OS, system resources (memory, disk, devices, etc)
  • Only valid users must have access to the computer and specified resources
  • Violations must cause appropriate reaction, e.g., error messages

Self assessments

• Operating Systems

Tutorial Questions

• Operating Systems (Answers)

Exam style questions

1. What is the broad reason for the existence of operating systems?
2. State four major tasks of an operating system.
3. Describe the term "timesharing". Give a simple example of timesharing.
4. What is the MMU? What are its tasks?
5. Assume that an abstract computer has 4MB of memory. The computer is running with 1.5MB device drivers and 0.5MB of OS. Given the following activation/deactivation sequence: start xview [1.2MB], start ghostscript [0.4MB], stop xview, start ghostview [0.6MB]. Give an example of how the OS might organize the remaining active programs.
6. What are some of the specific tasks an OS performs to maintain secondary storage.
7. What are some techniques an OS may used to schedule access to IO devices?
8. What is an interrupt handler? Why is polling necessary? What happens when an interrupt is activated?
9. What is the advantage of using interrupts?
10. Should it be possible for a user process to directly control system resources? What should happen in that event?