vault backup: 2025-04-21 21:20:06

Operating Systems/Processes and Threads.md

@@ -0,0 +1,201 @@
+---
+type: theoretical
+backlinks:
+  - "[[Overview#Multiprogramming]]"
+  - "[[Overview#Multitasking/Timesharing]]"
+---
+## Process
+A program in execution.
+
+Consists of:
+* The program code - **text section**
+* Current activity - **PC**, registers
+* **Stack** -> Function parameters, return addresses, local variables
+* Data section
+* **Heap** -> dynamically allocated (at run time) memory 
+
+
+The difference between a process and a program is that the program is the executable file stored on disk, while the process **is running** (shocker).
+
+
+### Creation
+Four events could cause processes to be created
+1. System init - Daemons
+2. Executing a process by "running a program"
+3. A user process request to create a new process
+4. Initiation of a batch[^1] job
+
+
+### `fork()`
+
+A Linux [system call](Overview.md#System%20calls).
+
+```mermaid
+graph LR;
+
+	A["`fork()`"] --> |parent| B["wait"]
+	A --> |child|C["`exec()`"]
+	C --> D["`exit()`"]
+	D --> B
+	B --> E["Resumes"]
+```
+
+
+### Hierarchy
+Linux creates a parent-child relationship between processes, Windows doesn't.
+
+Linux:
+
+```mermaid
+graph TD;
+	init["init
+	pid = 1"]
+
+	login["login
+	pid = 8415"]
+	
+	kthreadd["kthreadd
+	pid = 2"]
+
+	sshd["sshd
+	pid=3028"]
+
+
+	bash["bash
+	pid=8416"]
+
+
+	ps["ps
+	pid=9298"]
+
+	emacs["emacs
+	pid=9204"]
+
+    khelper["khelper
+    pid=6"]
+
+    pdflush["pdflush
+    pid=200"]
+
+init --> login
+init --> kthreadd
+init --> sshd
+
+login --> bash
+
+bash --> ps
+bash --> emacs
+
+kthreadd --> khelper
+kthreadd --> pdflush
+
+
+```
+
+
+### Termination
+1. Normal 
+	Process should return a code to its parent. Child processes should wait until they know that the parent received it, becoming **zombie processes**. If the parent dies before the child, the child is called an orphan. Absolutely fucking crazy naming. Every linux process should have a parent process [source: unicef](https://unicef.org).
+2. Error - just a special return code
+3. Fatal error, involuntary - division by zero, invalid opcode; process is immediately terminated by the system
+4. Killed
+
+
+### States
+As a state machine
+
+1. Running
+2. Ready
+3. Blocked (blocking == waiting)
+
+```mermaid
+graph TD;
+	A["Running"]
+	B["Ready"]
+	C["Blocked"]
+
+	A --> |1| C
+	A --> |2| B
+	B --> |3| A
+	C --> |4| B
+```
+#### Ready State
+- In this state the process is not waiting for a resoucrce
+- Can be executed
+- Put in a queue (ready queue)
+
+#### I/O queue
+- I/O device has its own
+- Multiple queues are created by OS
+## Timesharing: In-depth
+from [Multitasking/Timesharing](Overview.md#Multitasking/Timesharing)
+The output of running programs should not change when we stop and switch back to the same program later on.
+
+
+### Context switching
+Switching implies that we have to store the values of registers, flags, PC, etc. of the current process and load them into the next one. Then we continue.
+
+
+### The process control block - PCB
+The OS needs a place to store the status of each process. This is that data structure.
+
+
+### Process table
+A list of PCBs (one per process)
+
+![Figure: PS](Pasted%20image%2020250419141856.png)
+
+
+* Timer (`ISR`[^2]) generates multiple interrupts per second
+* Store the status of the process in PCB
+
+
+
+## Threads
+A thread is a basic unit of CPU utilization, consisting of a program counter, a stack, and a set of registers, ( and a thread ID. )
+
+A light-weight process.
+
+![](Pasted%20image%2020250419143713.png)
+
+### Processes vs threads
+
+
+| Processes                                 | Thread                                           |
+| ----------------------------------------- | ------------------------------------------------ |
+| Heavyweight                               | Lighter                                          |
+| Each process has its own memory           | Threads use memory of the process they belong to |
+| Inter-Process Communication (IPC) is slow | Way faster inter-thread communication            |
+| Context switching is more expensive       | Less expensive                                   |
+| Do not share memory                       | do share memory                                  |
+
+### Multithreading
+- Traditional processes have a single thread of control[^3]
+* If a process has multiple threads of control, it can perform more than one task
+
+### Ways to Implement Threads
+* Kernel-Level Threads (KLT)
+	* Managed by the OS kernel
+	* Each thread is a separate scheduling entity
+	* `pthread`, `thread`
+* User-Level Threads (ULT)
+	* Managed by user-space libraries, OS is unaware
+	* Faster context switching
+	* Green threads
+
+### User Threads and Kernel Threads
+- **User threads**
+	- Implemented by a thread library at the user level
+	- thread creation and scheduling are done in user space
+- **Kernel Threads**
+	- Managed by OS
+
+### Relationship modles
+* 
+
+[^1]: A batch job is a scheduled task or a set of commands that are executed without manual intervention - **cron**
+
+[^2]: interrupt service routine - like in LC3
+
+[^3]: sequence of programmed instructions that can be managed independently by a scheduler within a computer program
+