OS Midterm

Potential Strategy for Recovering from Deadlock (4)

(1) Abort all deadlocked processes. (2) Back up each deadlocked process to some previously defined checkpoint, and restart all processes. (3) Successively abort deadlocked processes until deadlock no longer exists. (4) Successively preempt resources until deadlock no longer exists.

Disadvantages of ULT's over KLT's

(1) In an OS, system calls are typically blocking. This means that if a thread made a system call, not only would that thread be blocked but all other threads within that process would be blocked; (2) Multithreaded applications with ULT's cannot take full advantage of multiprocessing. Typically one process may happen on one processor at a time. Though this may be sufficient for some applications, others would benefit from being able to run 2 pieces of code at the same time.

Requirements for Mutual Exclusion (6)

(1) Must be enforced! Only one process at a time is allowed into its critical section, among all processes that have critical sections for the same resource or shared object (2)A process that halts in its noncritical section must do so without interfering with other processes (3) It must not be possible for process requiring access to a critical section to be delayed indefinitely: No deadlock or starvation (4) When no process is in a critical section, any process that requests entry to its critical section must be permitted to enter without delay. (5) No assumptions are made about relative process speeds or number of processors (6) A process remains inside its critical section for a finite time only

4 Conditions for Deadlock

(1) Mutual exclusion (2) Hold and wait (3) No preemption (4) Circular wait *** 1-3 just show potential for deadlock, guaranteed deadlock when 4***

What design and management issues are raised by the existence of concurrency?

(1) OS must be able to keep track of the various processes (2) Allocation and deallocation of various resources (3) Protect data and physical resources of each process against unintended interference by other processes (4) Process functionality and the output must be independent of the speed at which the execution is carried out relative to the speed of the other concurrent processes

3 Approaches for Deadlock

(1) Prevention (2) Avoidance (3) Detection

OS Actions when Interrupt Pending

(1) Sets program counter to address of beginning of interrupt handler; (2) Switches to privileged mode to take care of interrupt

4 Basic Thread Operations

(1) Spawn; (2) Block; (3) Unblock; (4) Finish

Benefits of Threads

(1) Takes less time to create a new thread over creating a new process; (2) Takes less time to terminate a thread over a process; (3) It takes less time to switch between threads; (4) Threads within the same process share resources and memory, so there's no issues with communicating between threads whereas for processes to communicate together they must go into kernel mode which takes time

Advantages of ULT's over KLT's

(1) The thread management data structures are contained within the user address space which prevents the thread from having to switch into kernel mode, and this saves a lot of overhead; (2) Scheduling may be controlled by the application without disturbing the underlying OS scheduler; (3) Can be versatile and ULT's may run on any OS

Solaris thread Related Concepts

(1) UNIX process; (2) ULT's; (3) Lightweight process, or mapping between ULTs and KLTs; (4) Kernel threads fundamental and scheduled and dispatched to run on one of the system processors

How an OS creates a process

(1) assign unique process identifier; (2) allocate space for the process; (3) initialize the process control block; (4) set appropriate linkages; (5) create or expand other data structures

Processor

-Controls operation of the computer -Performs data processing functions -Also called 'core'

I/O Modules

-Moves data between the computer and extermal environment -'external environment' is secondary memory, communications equipment, terminals, etc. -Contains internal buffers for temporarily holding data until it an be sent

Secondary Memory

-Non-volatile memory -Also 'disk memory' or 'auxiliary memory'

Volatile Memory

-Once removed from power, all memory is cleared

Classes of Interrupts

-Program Interrupt -Timer Interrupt -I/O Interrupt -Hardware Failure

PSW

-Program Status Word -Contains status information about the currently running process, including memory usage information, condition codes, and other status information, such as an interrupt enable/disable bit and a kernel/user mode bit

System Bus

-Provides communication among processors, main memory, and I/O modules

Main Memory

-Stores data and programs -Typically volatile -Also known as 'real memory' or 'primary memory' -Contains a set of locations defined sequentially numbered address, which can contain either instructions or data

Hit Ratio, H

-The fraction of all memory access that are found in the faster memory. - (T1-T2)/(fraction of accesses involving only level 1)

Central Processing Unit (CPU)

-When there is only one processor

Things to consider about security for OS (4)

1. Availability 2. Confidentiality 3. Data integrity 4. Authenticity

Three Main Objectives of an OS

1. Convenience 2. Efficiency 3. Ability to evolve

Interrupt Processing (steps)

1. Device issues an interrupt signal to the processor. 2. Processor finishes execution of the current instruction before responding to the interrupt. 3. Processor tests for a pending interrupt request, determines that there is one, and sends a acknowledgement signal to the device that issued the interrupt. The acknowledgement allows the device to remove its interrupt signal. 4. Processor needs to prepare to transfer control to the interrupt routine. First, saves information needed to resume current program from when interrupt occurred. Minimally you would need to know the PSW and the location of the next instruction to be executed (contained in the PC) 5. Processor loads program counter with the entry location of the interrupt-handling routine that will respond to this interrupt.If there is more than one interrupt-handling routine, the processor must determine which one to invoke. **At this point PC and PSW relating to interrupted program saved on control stack** 6. Information that is considered part of the state of the executing program, the contents of the processor registers need to be saved. 7. Interrupt-handler processes interrupt. Examines the status information relating to the I/O operation or other event that caused the interrupt. This may also involve sending additional commands or acknowledgements to the I/O device. 8. When interrupt processing complete, saved values are restored back into the register 9. Restore the PSW and PC values from the stack.

Ways to Deal with Multiple Interrupts

1. Disable Interrupts when an interrupt is being processed -Processor ignores any new interrupt request signal -After interrupt-handler routine completes, interrupt are disabled immediately -Does not take into account relative priority or time critical needs 2. Define priorities for interrupts and to allow an interrupt of higher priority to cause a lower priority interrupt handler to be interrupted

Things to consider with Resource Management and Scheduling (3)

1. Fairness (equal access to resources) 2. Differential responsiveness (priorities) 3. Efficiency (maximum throughput)

2 Types of Internal I/O Registers

1. I/O Address Register (I/OAR): specifies particular I/O device 2. I/O Buffer Register (I/OBR): exchanges data between I/O module and processor

2 Types of Internal Processor Registers

1. Memory Address Register (MAR) : specifies the address in memory for the next read or write 2. Memory Buffer Register (MBR) : contains the data to be written into memory or which receives the data read from memory

OS Requirements for Memory Management

1. Process Isolation (prevent independent processes from interfering with each other in memory) 2. Automatic allocation and management (dynamically, should be transparent to the programmer) 3. Support of modular programming 4. Protection and access control (allow portions of memory to be accessible in various ways by various users) 5. Long term storage (nonvolatile memory)

The Four Main Structural Elements of a Computer

1. Processor 2. Main Memory 3. I/O Modules 4. System Bus

Instruction Cycle

1. Processor fetches an instruction from memroy 2. Program counter (PC) holds address of the next instruction to be fetched (typically) 3. Unless instructed otherwise, PC is incremented up 4. Fetched instruction loaded into instruction register (IR) 5. Processor interprets bits and performs required action. Can be the following things *Data may be transferred from the processor to memory or vice versa *Data transferred to or from peripheral device by passing data between processor and I/O module *Processor performs an academic function *An instruction may specify that a sequence of execution be altered (i.e., jump) {See figure 1.2 in text.}

An OS provides services in the following areas... (10)

1. Program development 2. Program execution (handles scheduling duties for the user) 3. Access to I/O devices 4. Controlled access to files (reflect nature of I/O device as well as the structure needed for the data) 5. System access (provides protection of resources and data from unauthorized users) 6. Error detection and response (may respond by ending the program or retrying operation or reporting error to application) 7. Accounting 8. Instruction set architecture (ISA) 9. Application binary Interface (IBA) 10. Application programming interface (API)

Three Techniques for I/O Operations

1. Programmed I/O 2. Interrupt-Driven I/O 3. Direct Memory Access (DMA)

Major Issues with Serial Processing (2)

1. Scheduling -Installations were manual and would waste computer processing time. -User could run into problems, not finish in allotted time, and be forced to stop before resolving the issue 2. Setup Time -If an error occurred when setting up a job, or a single program, the user would have to start over their job, so there was a lot of wasted time setting up a program to run

Deadlocks

2+ programs waiting for each other

Waiting Thread State

3 possibilities (1) it is blocked on an event; (2) voluntarily waits for synchronization purposes; (3) an environment subsystem directs the thread to suspend itself

Pipe

A circular buffer allowing 2 processes tocommunicate on the producer-consumer model

Process

A collection of one or more threads and associated system resources (such as memory containing both code and data, open files, and devices). This corresponds closely to the concept of a program in execution. By breaking a single application into multiple threads, the programmer has great control over the modularity of the application and the timing of the application related events.

Condition Variable

A data type that is used to block a process or a thread until a particular condition is true.

Thread

A dispatchable unit of work. It includes a processor context (which includes the program counter and stack pointer) and its own data area for a stack (to enable subroutine branching). A thread executes sequentially and is interruptible so that the process can turn to a thread.

Atomic Operation

A function or action implemented as a sequence of one or more instructions that appears to be indivisible; in other words,n o other process can see an intermediate state or interrupt the operation. The sequence of instruction is guaranteed to execute as a group, or not execute at all, having no visible effect on system state. Atomicity guarantees isolation from concurrent processes.

Mailboxes/Messages

A means for two processes to exchange information and that may be used for synchronization

Event Flags

A memory word used as a synchronous mechanism. Application code may associate a different event with each bit in a flag. A thread can wait for either a single event or a combination of events by checking one or multiple bits in the corresponding flag. The thread is locked until all of the required bits are set (AND) or until at least one of the bits is set (OR)

Nondeterminate Program Counter

A particular program normally should depend only on the input to that program and not on the activities of other programs in a shared system

Busy Waiting, or Spin Waiting

A process can do nothing until it gets permission to enter its critical section but continues to execute an instruction or set of instructions that tests the appropriate variable to gain entrance

Many-to-One Thread Process

A process defines an address space and dynamic resource ownership. Many threads may be created and executed in that process.

Parent Process

A process that spawns another

Child Process

A process that was spawned by another process

Multithreading

A process while executing an application is divided into threads that can run concurrently

Operating System

A program that controls the execution of application programs and acts as an interface between application and the computer hardware.

Monitor

A programming language construct that encapsulates variables, access procedures, and initialization code within an abstract data type. The monitor's variable may only be accessed via its access procedures and only one process may be actively accessing the monitor at any one time. The access procedures are critical sections. A monitor may have a queue of processes that are waiting to access it.

Dining Philosophers Problem

A round table has 5 chairs, 5 plates of spaghetti, and 5 forks. In order to eat, the guest must have 2 forks. How will the philosophers eat, without preventing deadlock or starvation?

Critical Section

A section of code within a process that requires access to shared resources and tha must not be executed while another process is in a corresponding section of code

Binary semaphore

A semaphore that takes on only the value of 0 or 1.

Starvation

A situation in which a runnable process is overlooked indefinitely by the scheduler; although it is able to proceed, it is never chosen

Race Condition

A situation in which multiple threads or processes read and write a shared data item and the final result depends on the relative timing of their execution

Deadlock

A situation in which two or more processes are unable to proceed because each is waiting for one of the others to do something The permanent blocking of a set of processes that either compete for system resources or communicate with each other

Livelock

A situation in which two or more processes continuously change their states in response to changesi n the other process(es) without doing any useful work

One-to-Many Thread Process

A thread may migrate from one process environment to another. This allows a thread to be easily moved among distinct systems.

Fiber

A unit of execution that must be manually scheduled by the application; run in the context of the threads that schedule them. In general, fibers do not provide advantages overall well-designed multithreaded application. However, using fibers can make it easier to port applications that were designed to schedule their own threads.

Jacketing

A way to overcome blocking. The main purpose is to change a blocking call to a non-blocking call

User-Level Threads (ULT's)

All work is done by the application and the kernel is unaware of the thread; Any application can be multithreaded by using a thread library (Classic ULT); Typically, the application begins with a single thread in the process, but through the thread utility may spawn itself at the instruction of the application

Kernel-Level Threads (KLT's)

All work is done within the kernel; as opposed to thread management at the application level, there is an Application Programming Interface (API) to the kernel thread facility. The kernel may schedule multiple threads to run at the same time, and if one thread is blocked the kernel may generate another copy of the thread so that it may be run on the processor. This is possible because kernel routines themselves are multithreaded. A disadvantage though is switching between threads requires a mode change within the kernel.

Job Object

Allows groups of processes to be managed as a unit, namable, securable, sharable objects that control attributes of the processes associated with them

Deadlock Avoidance

Allows the three necessary conditions but makes judicious choices to assure that the deadlock point is never reached

Semaphore

An integer value used for signaling among processes. Only three operations may be performed on a semaphore, all of which are atomic: initialize, decrement, and increment. The decrement operation may result in the blocking of a process, and the increment operation may result in the unblocking of a process. Also known as 'counting semaphore' or a 'general semaphore'.

Fatal Region

Area in Joint Progress Diagram where deadlock is inevitable.

Time Slicing

At each clock interrupt, the OS regained control and could assign the processor to another user

Swappable Space

Blocks of memory on secondary storage for use in swapping processes

DDR3 Memory Controller

Brings the memory controller for the double data rate (DDR) main memory onto the chip

Key Elements of Cache Design

Cache size, block size,mapping function, replacement algorithm, write policy, number of cache levels

Replacement Algorithm (referring to cache)

Chooses within the constraints of the mapping function which block to replace when a new block is to be loaded into the cache and the cache already has all shots filled with other blocks.

Circular wait

Closed chain of processes exist, each waiting for a resource that the other is holding onto while waiting for another, etc.

Many-to-Many Thread Process

Combination of One-to-Many and Many-to-One approaches

Hybrid Threading

Combination of coarse threading and fine threading Depending on the different applications

Multicore Computer, or Chip Multiprocessor

Combines 2+ processor (called cores) on a single piece of silicon (called a die).

Process Control Block

Consists of several components: identifier, state, priority, program counter, memory pointers, context data, I/O status information, accounting information

Deadlock Prevention

Contain resource requests to prevent at least one of the four conditions of dead lock, either indirectly (preventing mutual exclusion, hold and wait, or no preemption), or directly (preventing circular wait)

Application

Contains multiple processes

Kernel, or Nucleus

Contains the most frequently used functions in the OS and other portions of the OS currently in use

Process State Information

Contents of processor registers; while process running, the information is in the registers, however, when process is interrupted, all information in the register must be saved so that it can be restored when the process resumes

Mapping Function (referring to cache)

Determines which cache location the block will occupy. The more flexible the mapping function the more scope we have to design a replacement algorithm to maximize the hit ratio and the more complex is the circuitry required to search the cache to determine if a given block is in the cache.

Write Policy

Dictates when the memory write takes place. This can range from writing every time a block is updated to writing only when the block is replaced. Troubles with writing only when block replaced: -Minimizes memory write operation -Leaves main memory obsolete -Interferes with multiple-processor operation and direct memory access by I/O

Resource Allocation Graph

Directed graph that depicts a state of the system of resources and processes, with each process and each resource represented by a node.

Set of Data

Essential part of process; Associated with the program code

Program Code

Essential part of process; May be shared between many different processes

I/O Table

For OS to keep track of all I/O devices

Hardware Failure Interrupt

Generated by a failure, such as a power failure or memory parity error.

Timer Interrupt

Generated by a timer within the processor. This allows the operating system to perform certain functions on a regular basis.

I/O Interrupt

Generated by am I/O controller, to signal normal completion of an operation or to signal a variety of error conditions.

Program Interrupt

Generated by some condition that occurs as a result of an instruction execution, such as arithmetic overflow, division by zero, attempt to execute an illegal machine instruction, and reference outside a user's allowed memory.

Multiprocess Application

HAve many single threaded processes

Multithreaded Native Application

Have a small number of highly threaded processes

Hold and Wait

Holding onto resources while waiting for the next necessary resource

Interrupt and Instruction Cycle Interaction

I/O module for the device will send an interrupt request signal to the processor. The processor will then suspend their operation and service that I/O device. If no interrupts are pending, the processor proceeds to the fetch stage and fetches the next instruction of the current program. If an interrupt is pending, the processor suspends execution of the current program and executes an interrupt-handler routine. {See Figure 1.7 in text.}

Programmed I/O

I/O module performs the requested action and then sets the appropriate bits in the I/O status register but takes no further action to alert the processor. Does not interrupt the processor. After I/O instruction invoked, processor takes some active role in determining when I/O instruction was completed, which means that the processor has to wait for the I/O operation to be ready for either transmission or reception of more data.

Running State

If the process is currently running

Joint Progress Diagram

Illustrates the progress of 2 processes competing for 2 resources. Each process needs exclusive use of both resources for a certain period of time.

Object oriented design

Implements a modular design for dynamic modification

Ready State

In main memory, available for execution

Blocked State

In main memory, waiting on an event to occur in order to execute

I/O Status Information

Includes outstanding I/O requests, I/O devices assigned to the process, a list of files in use by the process and so on.

Coarse Threading

Individual modules are assigned to individual processors

Execution context, or Process State

Internal data by which the OS is able to supervise and control the process

ISR

Interrupt Service Routine

Memory Hierarchy

Largest ===========> Smallest Magnetic Tape (off-line storage) => Magnetic disk/disk memory (outboard storage) => Main memory (inboard storage) => cache (inboard storage) => registers (inboard storage)

Trace

List of the sequence of instructions that execute for the process; Processor behavior can be characterized by showing how the traces of the various processes are interleaved.

Fine Threading

Many similar or identical tasks are distributed over many processors

Ready Thread State

May be scheduled for execution. Kernel dispatcher keeps track of all ready threads and schedules them in priority order

Atomic

May not be interrupted

Locality of Reference

Memory references by the processor, for both the instructions and data, tend to cluster.

Direct Addressing

Messages are sent directly from the sender to the receiver

Indirect Addressing

Messages are sent to a shared data structure consisting of queues that can temporarily hold messages (often referred to as mailboxes)

Resident Monitor

Monitor controls the sequence of events, so therefore must always be in the main memory and available for execution. Consists of utilities and common functions that are loaded as subroutines to the user program at the beginning of any job that requires them. The monitor reads in jobs one at a time from the input device. As it is read in, the current job is placed in the user program area and the control is passed to this job. When the job is done, control is returned to the monitor, which immediately reads in the next job.

Failed mutual exclusion

More than one user of program will attempt to make use oof a shared resource at the same time

Direct Memory Access (DMA)

Most efficient when moving large volumes of data. Performed by a separate module on the system bus or it can be incorporated into an I/O module. Module receives the following information: -Whether a read or write is requested -The address of the I/O device involved -The starting location in memory to read data from or write data to -The number of words to be read or written Processor then continues to to do other work. Processor only involved at the beginning and end of data transfer.

Java Applications (regarding multithreading)

Multithreaded applications that embrace multithreaded processes with its own scheduling and memory management

Spinlocks

Mutual exclusion mechanism in which a process executes in an infinite loop waiting for the value of a lock variable to indicate availability.

Reasons for Process Creation

New Batch Job (OS is provided with a batch job control stream, usually by secondary memory; when the OS is prepared to take on new work, it will read the next sequence of job control commands); Interactive Log-on (User action); Created by OS to provide a service (OS creates a process on behalf of a user program without the user having to wait); Spawned by existing process (for modularity or to exploit parallelism)

No Preemption

No resources can be forcibly removed from a process holding it

Reasons for Process Termination (14)

Normal completion, time limit exceeded (could pertain to total elapsed time, amount of time spent executing , or the amount of time since the user last provided input), Memory unavailable, bounds violation memory location denied access), protection error (process attempts to use a resource that they are not allowed to use or tries to use a resource in an improper fashion such as writing to a read only file), arithmetic error, time overrun (waited more for event to occur than maximum allowed), I/O failure, invalid instruction, privileged instruction, data misuse, operator or OS intervention, parent termination, parent request

Temporary Intermediate Fault

Occurs multiple unpredictable times but is not present all the time for all operating conditions (i.e., loose connection)

Improper Synchronization

Often the case that a routine must be suspended awaiting an event elsewhere in the system

Permanent Fault

Once it occurs, it is always present until faulty component is replaced or repaired

Running Thread State

Once the kernel dispatcher performs a thread switch, the standby thread enters the running state and begins execution and continues execution until it is preempted by a higher priority thread

Unsafe State

One in which a sequence of resource allocations to processes results in deadlock

Safe State

One in which there is at least one sequence of resource allocations to processes that does not result in a deadlock

Temporary Transient Fault

Only occurs once and is not present all the time for all operating conditions (i.e., impulse noise)

QuickPath Interconnect

Point to point link electrical interconnect specification, which enables high speed communication among connected processor chips.

Preemption

Process A is in running and Process B, which is of higher priority, is blocked. The OS may choose to give priority and place Process B in the running state such that it jumps in front of Process A such that Process B is run first.

Cooperation by Communication

Processes are directly aware of each other. The results of a process may depend on information obtained by another process, and therefore this could affect the timing. Some potential control problems of this are deadlock (consumable resource) and starvation.

Cooperation by Sharing

Processes are indirectly aware of each other (i.e., they may be sharing an object). The results of one process may depend on the results of another and therefore this could affect the timing. Some potential control problems are mutual exclusion, deadlock (renewable resource), starvation, and data coherence

Competition

Processes are unaware of each other existence. Various process' results are independent of the other, and timing of the process' may be affected. Potential control problems include mutual exclusion, deadlock (renewable resource), and starvation

Interrupt-Driven I/O

Processor issues an I/O command to a module and then goes on to do some other useful work. More efficient than programmed I/O; Requires the active intervention of the processor to the transfer data between memory and an I/O module, and any data transfer must traverse a path through the processor. Two major drawbacks: 1. I/O transfer rate limited by speed with which the processor can test and service a device 2. Processor tied up in managing an I/O transfer; a number of instructions must be executed for each I/O transfer.

What is meant by 'resources'? (4)

Processor time, memory, files, I/O devices

Information Redundancy

Provides fault tolerance by replicating or coding data in such a way that bit errors can be both detected and corrected

Temporal Redundancy

Repeating a function or operation when an error is detected. Effective with temporary faults, but not useful for those that are permanent.

Least-Recently-Used Algorithm (LRU)

Replace the block that is least likely to be needed again in the near future (idealist idea). The effective strategy to do this is to replace the block that has been in cache the longest with no reference to it.

CPU Utilization Calculation

See example in Figure 2.4

Two State Process Model

Set into two states: Running and Not Running. Used to depict execution of processes. When a new process is created by the OS, a Process Control Block for the process is created and the process enters the diagram in a Not Running state. Process model can be displayed in 2 different ways: state diagram and queueing diagram; the Queueing Diagram integrates a queue so that it accounts for the processes going in a certain order whereas the State Diagram is a little unclear due to the ambiguous model.

Mutex

Similar to binary semaphore. A key difference between the two is that the process that locks the mutex (sets the value to zero) must be the one to unlock it (sets the value to 1).

Condition Variables

Special data type in monitors, which are operated on by two functions: (1) cwait(c): suspend execution of the calling process on condition c. The monitor is now available for the use by another process. (2) csignal(c): Resume execution of some process blocked after cwait on the same condition. If there are several such processes, choose one of the; if there is no such process, do nothing

Amdahl's Law

Speedup= (Time to execute a program on a single processor)/(Time to execute a program on N parallel processors)= 1/((1-f)+ 1/N) System's speed is determined by its component

Symmetric Multiprocessors (SMP)

Stand alone computer system with: -2+ similar processor of comparable capability -Share the same main memory and I/O facilities interconnected by a bus or other internal connection scheme such that memory access time is approximately the same for each processor -All processors share access to I/O devices -All processors can perform the same functions (aka symmetric) -Controlled by integrated operating system that provides interaction between processors and their programs at the job, task, file, and data element level.

Five State Process Model

States are Running (process currently being executed), Ready (prepared to execute once given the opportunity), Blocked/Waiting (process cannot happen until a different event or action is completed first), New (process just created), Exit (process released to the pool of executable processes)

Dispatcher

Switches the processor from one process to another

Process Isolation

Technique to support fault tolerance. Processes isolated from each other in main memory, file access, and flow of execution.

Virtual Machine

Technique to support fault tolerance. Used as a backup or to provide redundancy.

Concurrency controls

Technique to support fault tolerance. Used to ensure correct operation and to recover from their fault conditions, such as deadlock

Checkpoints and rollbacks

Technique to support fault tolerance. Used to recover from transient as well as permanent hardware failures and certain types of software failures. A checkpoint is a copy of an applications state saved in some storage that is immune to the failures under consideration. A rollback restarts the execution from a previously saved checkpoint.

Banker's Algorithm

The 'bank' has a limited reserve of money to lend and a list of customers, each with a line of credit. A 'customer' may choose to borrow against the line of credit a portion at a time, and there is no guarantee that the customer will make any repayment until after having taken out the maximum amount of loan. The banker can refuse a loan to a customer if there is a risk that the bank will have insufficient funds to make further loans that will permit the customers to repay eventually.

Availability

The fraction of time the system is available to service users' requests

Mean Time to Failure (MTTF)

The integral from 0 to infinity of reliability [R(t)]

Distributed Processing

The management of multiple processes executing on multiple, distributed computer systems. The recent proliferation of clusters is a prime example of this type of system.

Multiprocessing

The management of multiple processes within a multiprocessor

Multiprogramming

The management of multiple processes within a uniprocessor system

Reliability R(t)

The probability of the correct operation up to time t given that the susste, was operating correctly at time 0

Mutual Exclusion

The reqirement that when one process is in a critical section that accesses shared resources, no other process may be in a critical section that access any of those shared resources

Spatial (physical) Redundancy

The use of multiple components that either perform the same function simultaneously or configured so that one component is available as a backup in case of the failure of another component. (i.e., multiple parallel circuitry with majority result produced as output)

Uptime

Time during which the system is available

Downtime

Time during which the system is unavailable

Purpose of Interrupts

To improve processor utilization. For example explanation go to textbook page 14-15.

Multiinstance Application

Virtual technology may be utilized to provide each application with its own separate and secure environment

Process Spawning

When OS creates a process at the explicit request of the other process

Multiprogramming, or Multitasking

When one job needs to wait for I/O, the processor can switch to another job which is likely not waiting for I/O

Instruction Format (bits)

____|_____________ |OP | ADDR |

Thread Pool

a collection of worker threads that efficiently execute asynchronous callbacks on behalf of the application; primarily used to reduce the number of application threads and provide management of the worker threads

User-mode Scheduling (UMS)

a lightweight mechanism, that applications can use to schedule their own threads; allows switching between UMS threads in user mode without involving the system scheduler and regain control of the processor if a UMS thread blocks in the kernel

Process Control Information

additional information needed by the OS to control and coordinate various active processes

Transition Thread State

after waiting if it is ready to run but the resources are not available

Terminated Thread State

can be terminated by itself, another thread, or when its parent process terminates

One-to-One Thread Process

each thread execution is a unique process to the address space and resources

Namespace

enables a process or multiple processes to have a different view of the system than other processes that have other associated namespaces

Process Table

manage processes

Virtual address

page and an offset

Real address

physical address

Blocked/Suspend State

secondary memory, awaiting event

Ready/Suspend State

secondary memory, ready to execute once it is put into main memory

Standby Thread State

selected to run next on a particular processor

Reasons for Project Suspension

swapping (OS needs to release sufficient main memory), Other OS reasons, Interactive user request (debugging purposes or connection purposes with a resource), timing, parent process request (parent process needs to suspend a child process)

Block Size (referring to cache)

unit of data exchanged between cache and main memory

Integer Format (bits)

|_|_______________| |S| INT |