CS2013-final-report

OS
PD
Core-Tier2:
• Articulate the need for protection and security in an OS (cross-reference
IAS/Security Architecture and Systems Administration/Investigating Operating
Systems Security for various systems).
• Summarize the features and limitations of an operating system used to provide
protection and security (cross-reference IAS/Security Architecture and Systems
Administration).
• Explain the mechanisms available in an OS to control access to resources (crossreference
IAS/Security Architecture and Systems Administration/Access
Control/Configuring systems to operate securely as an IT system).
• Carry out simple system administration tasks according to a security policy, for
example, creating accounts, setting permissions, applying patches, and arranging
for regular backups (cross-reference IAS/Security Architecture and Systems
Administration).
Core-Tier1:
• Distinguish using computational resources for a faster answer from managing
efficient access to a shared resource.
• Distinguish multiple sufficient programming constructs for synchronization that
may be inter-implementable but have complementary advantages.
• Distinguish data races from higher level races.
• Explain why synchronization is necessary in a specific parallel program.
• Use mutual exclusion to avoid a given race condition.
• Explain the differences between shared and distributed memory.
Core-Tier2:
• Identify opportunities to partition a serial program into independent parallel
modules.
• Write a correct and scalable parallel algorithm.
• Parallelize an algorithm by applying task-based decomposition.
• Parallelize an algorithm by applying data-parallel decomposition.
• Write a program using actors and/or reactive processes.
• Give an example of an ordering of accesses among concurrent activities (eg,
program with a data race) that is not sequentially consistent.
• Give an example of a scenario in which blocking message sends can deadlock.
• Explain when and why multicast or event-based messaging can be preferable to
alternatives.
• Write a program that correctly terminates when all of a set of concurrent tasks
have completed.
• Use a properly synchronized queue to buffer data passed among activities.
• Explain why checks for preconditions, and actions based on these checks, must
share the same unit of atomicity to be effective.
• Write a test program that can reveal a concurrent programming error, for
example, missing an update when two activities both try to increment a variable.
- 219 -