Process Management in OS Flashcards
Process
A program in execution: A process is essentially a program in the midst of execution. Processes are the active content within a computer system, starting from when the program is opened (or executed) until it is closed.
Batch System
Processes are referred to as “jobs.” This terminology is reminiscent of older computing systems where tasks were submitted in batches.
Time-shared systems
Processes are often referred to as “user programs” or “tasks.” This reflects the multi-user, multitasking nature of such systems where multiple processes may be executed concurrently.
Items of a process
- Program counter: Holds the address of the next instruction to be executed, thus guiding the sequential flow of control.
- Stack: Used for storing temporary data like function parameters, return addresses, and local variables.
- Data section: Contains the global and static variables used by the program.
Process State
- New: The process is being created.
- Running: The process is currently executing instructions.
- Waiting: The process is paused, waiting for an event to occur.
- Ready: The process is ready to run and waiting for processor allocation.
- Terminated: The process has completed execution and is exiting.
Process Control Block
- Process State: The current status of the process (e.g., New, Running, Waiting, Ready, Terminated).
- Program Counter: Holds the address of the next instruction for the process to execute.
- CPU Registers: Contains the process’s current register values when it is not running.
- CPU Scheduling Information: Includes priority information and other data necessary for scheduling the process.
- Memory-Management Information: Details about the process’s allocated memory, including base and limit registers.
- Accounting Information: Information tracking the use of processor time and other resources by the process.
- I/O Status Information: Lists the I/O devices allocated to the process and a list of open files.
Process Scheduling Queues
- Job Queue: The set of all processes in the system.
- Ready Queue: The set of all processes residing in main memory that are ready and waiting to execute.
- Device Queues: Sets of processes waiting for an I/O device.
Short-term scheduler
- Selects which process to execute next and allocates CPU.
- Invoked very frequently to maintain efficient processor use.
Long-term scheduler
- Selects processes to bring into the ready queue.
- Controls the degree of multiprogramming.
- Balances the mix of CPU-bound and I/O-bound processes.
Process Creation
- Parent Process Creates Children: Parent processes can create child processes, forming a tree of processes.
- Resource Sharing: Determines how resources are shared between parent and child processes.
- Execution: Parent and children can either execute concurrently or the parent can wait for the children to terminate.
- Address Space:
The child process starts as a duplicate of the parent (same program and data). The child can load a new program into its address space. - UNIX System Calls: fork to create a new process, exec to load a new program into the process’s address space.
Process termination - exit
- The process completes its execution and asks the OS to delete it.
- The parent process can receive output data from the child through the wait system call.
- The operating system deallocates the resources of the process.
Process Termination - abort
- The child has exceeded its allocated resources.
- The task assigned to the child is no longer required.
- The parent is exiting, and the OS does not allow the child to continue independently.
Advantages of Process Cooperation
- Information sharing
- Computation speed-up
- Modularity
- Convenience
Direct Communicaton
- Links are established automatically.
- A link is associated with exactly one pair of processes.
- Between each pair, there exists exactly one link.
- Links are usually bi-directional, though they can be unidirectional.
Indirect Communication
- A link is established only if processes share a common mailbox.
- A link can be associated with many processes.
- Each pair of processes can share several links.
- Links can be unidirectional or bi-directional.
Blocking (Synchronous) Message Passing
The sending/receiving processes wait until the other side is ready.
Non-blocking (Asynchronous) Message Passing
The sending/receiving processes do not wait for each other.
Buffering - Zero Capacity
No messages are buffered; direct handoff.
Buffering - Bounded Capcacity
A fixed number of messages can be buffered.
Buffering - Unbounded Capacity
An unlimited number of messages can be buffered.
Sockets
Endpoints for communication, identified by an IP address and a port number (e.g., 161.25.19.8:1625).
Remote Procedure Calls (RPCs)
Enable procedure calls between distributed processes, with structured messages and stubs acting as client-side and server-side proxies.
Remote Method Invocation (RMI)
A Java mechanism similar to RPCs but specifically for Java objects and methods.
Ordinary Pipes
- Producer/Consumer
- Unidirectional: Prod -> Consumer
- Parent -> Child Process
- Half-Duplex
- Same machine
Named Pipes
- Bidirectional
- No relationship
- Continue
Full Duplex
Data can travel in both directions at the same time
Half Duplex
Data can travel only one way at a time
Benefits of Threads
- Responsiveness: Enhances system responsiveness by allowing tasks to run concurrently
or in parallel. - Resource Sharing: Enables efficient sharing of resources among multiple tasks or processes.
- Economy: Improves system economy through task multiplexing and reducing overhead.
- Utilization of MP Architectures: Boosts performance by leveraging multi-processor (MP) architectures for parallel task execution.
Many-to-One Model
Multiple user-level threads map to one kernel thread.
- Solaris Green Threads: An implementation of threads that maps multiple user- level threads to a single kernel thread.
- GNU Portable Threads: A user-level thread library where multiple threads are managed by a single process without kernel-level context switching.
One-to-One Model
Each user-level thread maps to a kernel thread.
- Windows NT/XP/2000: Each user-level thread corresponds to a single kernel thread, allowing better concurrency on multiprocessor systems.
- Linux: Implements a one-to-one threading model where each user thread is associated with a distinct kernel thread.
- Solaris 9 and later: Shifted to a one-to-one model to improve performance and scalability on multiprocessor systems.
Many-to-Many Model
- Solaris prior to version 9: Allowed mapping many user-level threads to many kernel threads, providing flexibility in how threads were managed.
- Windows NT/2000 with the ThreadFiber package: Provided the ability to use a many-to-many threading model through additional libraries, offering a hybrid approach between user and kernel threads.
Two-level Model
- IRIX
- HU-UX
- Tru-64 UNIX Solaris-8 and earlier
Threading issues
- System Calls: Interactions with fork() and exec() can affect threads differently. Thread - Cancellation: Terminating a thread before it has completed.
- Signal Handling: Managing UNIX signals within multithreaded applications. Thread
- Pools: Using a pool of pre-created threads to handle tasks.
- Thread-Specific Data: Allowing individual threads to have their own copies of data.
- Scheduler Activations: Communication between the kernel and thread library to manage kernel threads.
Thread-Pools
- Concept: Create a number of threads in a pool to wait for and perform work.
- Advantages: Slight performance improvement and the ability to limit the number of concurrent threads in an application.
Signal Handling
- To the thread that caused the signal.
- To every thread in the process.
- To specific threads in the process.
- To a designated thread handling all signals for the process.
Thread Cancellation
- Asynchronous Cancellation: Terminates the target thread immediately.
- Deferred Cancellation: The thread periodically checks if it should terminate, allowing for a safer cleanup.
Thread-Specific Data
Allows each thread to maintain its own set of data, beneficial when the thread creation process is outside the programmer’s control.
