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.