Computer Science: I/O Processing and Storage

Study Notes

Synchronous I/O: CPU waits for I/O operation to complete before processing other tasks.
Asynchronous I/O: CPU continues processing other tasks while waiting for I/O operation to complete.

Main Memory (RAM): primary storage area, random access, volatile, and characterized by DRAM (Dynamic Random Access Memory).
Secondary Storage: extension of main memory, non-volatile, and provides larger capacity, including Hard Disk Drive (HDD) and Non-Volatile Memory (NVM).
Tertiary Storage: includes devices like optical disks and magnetic tapes, providing very large storage capacities but are significantly slower than secondary storage.

Bit: smallest unit of data, representing a 0 or 1 (binary digit).
Byte: a group of 8 bits.
Word: native unit of data in a specific computer architecture, consisting of one or more bytes.
Kilobyte (KB): 1024 bytes.
Megabyte (MB): 1024² bytes.
Gigabyte (GB): 1024³ bytes.
Terabyte (TB): 1024⁴ bytes.
Petabyte (PB): 1024⁵ bytes.

Volatile (Temporary) Storage: includes registers, cache, and main memory, with fastest access time, highest cost, and lowest capacity.
Symmetric Clustering: multiple nodes run applications and monitor each other, using a storage area network (SAN) to share hard disks among computers.

Key Components: processor socket, memory slots, buses.
Functionality: a fully functioning computer once its slots are populated with components like RAM, PCI bus, display adapter, and keyboard.

Operating System Services: facilitate program execution, user interaction, resource management, and error handling.
Key services include user interface (CLI/GUI), program execution, I/O operations, file system manipulation, communication, error detection, resource allocation, and security.
User and Operating System Interface: users interact with operating systems through various interfaces such as Command Line Interface (CLI), Graphical User Interface (GUI), and touchscreens.

Process Scheduler: responsible for selecting processes for CPU execution, aiming to maximize CPU utilization and ensure acceptable response times.
Ready Queue and Waiting Queue:
- Ready Queue: processes ready for CPU execution.
- Waiting Queue: processes waiting for events (e.g., I/O operations) before they can proceed.
Schedulers:
- Long-term Scheduler: selects processes from the job queue (disk) to be loaded into memory, optimizing system throughput.
- Short-term Scheduler (CPU Scheduler): rapidly selects processes from the ready queue to maximize CPU utilization.
- Medium-term Scheduler: swaps processes between main memory and disk to optimize system performance under heavy load.
CPU Scheduling: involves selecting processes from the ready queue for execution on the CPU, using scheduling algorithms (e.g., round-robin, priority scheduling) to manage process execution efficiently.
Context Switch: occurs when the CPU switches from executing one process to another, involving saving the state of the current process and loading the state of the new process.

Multitasking: capability of a system to execute multiple processes concurrently.
Process Creation: processes are created through system calls such as 'fork' in Unix or API calls in Windows, with parent processes spawning child processes.

Processes are prioritized based on importance (foreground, visible, service, background, and empty), with Android reclaiming resources starting from the least important.

Chrome employs a multi-process architecture where each tab runs in its own sandboxed process, enhancing security by isolating potentially risky web content.

Round Robin: each process gets a time quantum to execute before being preempted.
First Come First Serve (FCFS): processes are executed in the order they arrive.
Priority Scheduling: processes with higher priority are executed first.
Preemptive vs. Non-preemptive: whether a process can be interrupted (preempted) or must complete its full burst before another process can run.

Divides the ready queue into separate queues, each with its own scheduling algorithm tailored to the class of processes it serves (e.g., interactive or batch).
Fixed Priority Preemptive Scheduling: queues have a fixed priority, and higher priority queues preempt lower priority queues.
Time Slicing: each queue gets a specified portion of CPU time, which can be adjusted based on the needs of different classes of processes.

Starvation: risk of lower priority processes never getting CPU time if higher priority processes are always present.
Algorithm Selection: choosing the right scheduling algorithm based on the characteristics of the processes (foreground vs. background) is crucial for efficient system performance.