CS 330
TO ALL INSTRUCTORS AND STUDENTS:
This course must include coverage of the following topics from the IEEE-CS/ACM Computing Curricula 2001:
This course contains the following IEEE-CS/ACM Computing Curricula core topics:
v OS1. Overview of operating systems
v OS2. Operating system principles
v Some of SE2. Explain the value of application programming interfaces (APIs) in software development, and design, implement, test, and debug programs that use large-scale API packages.
v OS3. Concurrency
v OS4. Scheduling and dispatch
v OS5. Memory management
v PL2. Virtual machines
v AL4. Distributed algorithms
The coverage must include at least the specified number of hours (50-minute hours) of instruction, assignments or labs related to the topics, and required examination questions on these topics.
OS1. Overview of operating systems [core]
Minimum core coverage time: 2 hours
Topics:
Role and purpose of the operating system
History of operating system development
Functionality of a typical operating system
Mechanisms to support client-server models, hand-held devices
Design issues (efficiency, robustness, flexibility, portability, security, compatibility)
Influences of security, networking, multimedia, windows
Learning objectives:
1. Explain the objectives and functions of modern operating systems.
2. Describe how operating systems have evolved over time from primitive batch systems to sophisticated multiuser systems.
3. Analyze the tradeoffs inherent in operating system design.
4. Describe the functions of a contemporary operating system with respect to
convenience, efficiency, and the ability to evolve.
5. Discuss networked, client-server, distributed operating systems and how they differ from single user operating systems.
6. Identify potential threats to operating systems and the security features design to guard against them.
7. Describe how issues such as open source software and the increased use of the Internet are influencing operating system design.
OS2. Operating system principles [core]
Minimum core coverage time: 2 hours – 2 hours in CS330
Topics:
Structuring methods (monolithic, layered, modular, micro-kernel models)
Abstractions, processes, and resources
Concepts of application program interfaces (APIs)
Application needs and the evolution of hardware/software techniques
Device organization
Interrupts: methods and implementations
Concept of user/system state and protection, transition to kernel mode
Learning objectives:
1. Explain the concept of a logical layer.
2. Explain the benefits of building abstract layers in hierarchical fashion.
3. Defend the need for APIs and middleware.
4. Describe how computing resources are used by application software and managed by system software.
5. Contrast kernel and user mode in an operating system.
6. Discuss the advantages and disadvantages of using interrupt processing.
7. Compare and contrast the various ways of structuring an operating system such as object-oriented, modular, micro-kernel, and layered.
8. Explain the use of a device list and driver I/O queue.
SE2. Using APIs [core]
Minimum core coverage time: 5 hours – 3 hours in CS230 and 2 hours in CS330
Topics:
API programming
Class browsers and related tools
Programming by example
Debugging in the API environment
Introduction to component-based computing
Learning objectives:
1. Explain the value of application programming interfaces (APIs) in software
development.
1. Use class browsers and related tools during the development of applications using
APIs.
2. Design, implement, test, and debug programs that use large-scale API packages.
OS3. Concurrency [core]
Minimum core coverage time: 6 hours – 6 hours in CS330
Topics:
States and state diagrams
Structures (ready list, process control blocks, and so forth)
Dispatching and context switching
The role of interrupts
Concurrent execution: advantages and disadvantages
The “mutual exclusion” problem and some solutions
Deadlock: causes, conditions, prevention
Models and mechanisms (semaphores, monitors, condition variables, rendezvous)
Producer-consumer problems and synchronization
Multiprocessor issues (spin-locks, reentrancy)
Learning objectives:
1. Describe the need for concurrency within the framework of an operating system.
2. Demonstrate the potential run-time problems arising from the concurrent operation of
many separate tasks.
3. Summarize the range of mechanisms that can be employed at the operating system
level to realize concurrent systems and describe the benefits of each.
4. Explain the different states that a task may pass through and the data structures
needed to support the management of many tasks.
5. Summarize the various approaches to solving the problem of mutual exclusion in an
operating system.
6. Describe reasons for using interrupts, dispatching, and context switching to support
concurrency in an operating system.
7. Create state and transition diagrams for simple problem domains.
8. Discuss the utility of data structures, such as stacks and queues, in managing
concurrency.
9. Explain conditions that lead to deadlock.
OS4. Scheduling and dispatch [core]
Minimum core coverage time: 3 hours – 3 hours in CS330
Topics:
Preemptive and nonpreemptive scheduling
Schedulers and policies
Processes and threads
Deadlines and real-time issues
Learning objectives:
1. Compare and contrast the common algorithms used for both preemptive and nonpreemptive
scheduling of tasks in operating systems, such as priority, performance
comparison, and fair-share schemes.
2. Describe relationships between scheduling algorithms and application domains.
3. Discuss the types of processor scheduling such as short-term, medium-term, long-term, and I/O.
4. Describe the difference between processes and threads.
5. Compare and contrast static and dynamic approaches to real-time scheduling.
6. Discuss the need for preemption and deadline scheduling.
7. Identify ways that the logic embodied in scheduling algorithms are applicable to other domains, such as disk I/O, network scheduling, project scheduling, and other problems unrelated to computing.
OS5. Memory management [core]
Minimum core coverage time: 5 hours – 5 hours in CS330
Topics:
Review of physical memory and memory management hardware
Overlays, swapping, and partitions
Paging and segmentation
Placement and replacement policies
Working sets and thrashing
Caching
Learning objectives:
1. Explain memory hierarchy and cost-performance tradeoffs.
2. Explain the concept of virtual memory and how it is realized in hardware and software.
3. Summarize the principles of virtual memory as applied to caching, paging, and segmentation.
4. Evaluate the tradeoffs in terms of memory size (main memory, cache memory, auxiliary memory) and processor speed.
5. Defend the different ways of allocating memory to tasks, citing the relative merits of each.
6. Describe the reason for and use of cache memory.
7. Compare and contrast paging and segmentation techniques.
8. Discuss the concept of thrashing, both in terms of the reasons it occurs and the
techniques used to recognize and manage the problem.
9. Analyze the various memory portioning techniques including overlays, swapping, and
placement and replacement policies.
PL2. Virtual machines [core]
Minimum core coverage time: 1 hour
Topics:
The concept of a virtual machine
Hierarchy of virtual machines
Intermediate languages
Security issues arising from running code on an alien machine
Learning objectives:
1. Describe the importance and power of abstraction in the context of virtual machines.
2. Explain the benefits of intermediate languages in the compilation process.
3. Evaluate the tradeoffs in performance vs. portability.
4. Explain how executable programs can breach computer system security by accessing disk files and memory.
AL4. Distributed algorithms [core]
Minimum core coverage time: 3 hours
Topics:
Consensus and election
Termination detection
Fault tolerance
Stabilization
Learning objectives:
1. Explain the distributed paradigm.
2. Explain one simple distributed algorithm.
3. Determine when to use consensus or election algorithms.
4. Distinguish between logical and physical clocks.
5. Describe the relative ordering of events in a distributed algorithm.