ARui's Blog

陽明交大資工所碩一上（2023 Fall）修課心得

2024-03-05T18:55:00.000Z

作業系統

英文課名：Operating System
永久課號：CSIC30015
教師：吳俊峯

課程內容

因為沒上過交大這邊教的大學部OS，所以不知道跟大學的差別有多少。但是體感上跟清大差不少。清大周志遠教授的OS 感覺比較想是每個 component都碰一下，但是這堂比較偏向每個都會教到比較深層的。但可能時間的關係，所以也沒有辦法教很多很深。老師好像是作記憶體的（他下學期還有開一門〈記憶體與儲存系統〉），所以那段講的特別細節和清楚。

上課方式

英文授課。線上實體並行，會有影片存檔。課間的學生提問都會被錄下來。基本上我除了第一堂和期中期末以外都沒去過了XDD

考試作業

20% Midterm Exam
- 有人在 nctuplus 上面丟考古了，Dcard也有一個篇在討論這個。基本上跟去年考古一樣，多了一個 section的是非題。滿分依舊破百。
30% Final Exam
- 沒檢討，考卷沒發回來。會考到期中範圍，記得複習。
20% Paper Presentation
- 這年因為人數的關係兩個人一組。一組約 12~15分鐘報一篇。要從老師指定的 conferences 中選（USENIX OSDI, USENIX ATC,USENIX FAST, SOSP, ASPLOS, HPCA, ACM SC, ISCA, MICRO, EuroSys）。或是Rank A 且十頁以上的。
- 第二週報加兩分，第三周報加一分。用英文報加兩分。
30% Homework
- 作業一
  - 要改 Linux 的 uname，需要一台虛擬機。然後實作一個簡單的 systemcalls。
- 作業二
  - 用 pthread 去作不同 policy 的 scheduling。
- 作業三
  - 寫一個 kernel module 去印出系統資料。
10% Class Participation (1 question 2pts)

其他

不點名。線上也可以發問。

最後想說的話

老師的英文很好，用近乎兩倍速也可以聽懂。解釋能力也很好，闡述都很清楚。學生問問題如果遇到他不會他也會在下次補充。可能因為有加分的關係，所以很多人在問問題。最後還有小調三分，佛！

班平均 86.85，還有不少人破百 @@

校務系統開發與管理（一）

英文課名：Institutional System Development and Management
永久課號：CSIC30060
教師：鄭昌杰（雖然上面寫很多人，但是基本上是鄭老師在帶。）

課程內容

學生上台報告和報進度。有時候會安排演講，可以跟 Sophi（我們的PM）許願。

上課方式

每週會排一到兩個人上台報告。之後就是報大家這周各自的進度，老師會給你一些參考意見，但真的只是參考，他也不會強迫你作什麼。如果有遇到「人際」問題也可以在這時候提出來，人很好的Sophi 會幫你解決。基本上老師也想趕快閃人（大家都想），所以都會在 2:30分左右結束課程。

考試作業

無。評分由老師評估你這學期的開發進度。基本上不要亂搞應該都會 A+

其他

可以請假，但是不要太誇張。

最後想說的話

戊組人們少數聚在一起的時間（？）。老師和 Sophi人都很好，有問題都可以提出來。

論文研討

英文課名：Seminars
永久課號：CSIC30115
教師：每週都有不同的講者

課程內容

聽演講。

上課方式

每週會要請講者去演講。通常是一個小時會結束。有時候會出現跟 CS毫無關係的演講主題，像是兩性關係（超ㄏ）。多數都是企業來宣傳。

考試作業

手寫 100字心得。沒寫算沒到。助教會每週更新目前大家的出席次數。聽說會真的數字數，有人在Dcard 抱怨他被抓到。

其他

可以三次不出席。

最後想說的話

真心希望他們可以邀請更有料的講者 ==。有記得好的應該是一次是微軟的和另一個國外大學來講。

無線多媒體網路

英文課名：Wireless Multimedia Networks
永久課號：CSIC30073
教師：趙禧綠

課程內容

Quality of Service (QoS)
Inserve
DiffServ
MPLS
Internet Traffic Engineering
IGMP & Multicasting
MIMO Beamforming
Dynamic Reuse of Unlicensed Spectrum
TSN

上課方式

投影片加上板書作畫。一開始沒有錄影，期中後經學生要求有錄影上傳。上課老師會想要學生的反應，但是我們這屆沒什麼反應，所以坐第一排的同學就可以一直跟老師對話XD。老師時不時會分享他實驗室的東西和他之前的經驗，可以感受到他對於這個領域的熱情。

考試作業

Midterm: 30%
- 考題有問答和選擇。可以跟老師要去年考古，但是不會給解答。可以跟老師argue 範圍 XDD
Final: 35%
- 類似期中考。但是老師忘記給考古了 QQ
Project: 35%
- 可以一到二人，但是兩個人的要做的比一個人的難。題目自訂，老師是說拿課堂內教過的，但好像很多人拿其他課或實驗室在做的東西來延伸？期末考前有一次Proposal報告，老師會給意見和評價難度。期末後的報告是線上報告，這年是另外約時間。

其他

不點名，但是強烈建議到課。自己啃講義或是原文書很痛苦……

最後想說的話

老師會把 5G 念成「五雞」，把 Wi-Fi 念成「歪ㄈㄞ」。

老師的解釋都很清楚，但是小生駑鈍，很多之前學過的東西都忘記了。下課可以去找老師一直問到懂為止。有時候太多人問一樣的問題老師會叫已經問過的同學講給剛來的同學。可能因為小班的關係，老師都很free，想要什麼都可以問問看。

最後成績看不到細項，但是拿 A+ 就沒有去跟老師問成績了 XD

網路安全

英文課名：Network Security
永久課號：CSIC30093
教師：謝續平

課程內容

基本上就是照著《William Stallings, Network Security Essentials –Applications and Standards, Pearson》的各個章節。

上課方式

投影片加上口述補充。

考試作業

老師說會在根據當年的成績調整分配。

Midterm Exam: 30% ± 10%
- 考前六章，交大資工考古題系統上面有考古。有一定的題數會和前幾年的重複。建議可以多刷幾年。
Final Exam: 30% ± 10%
- 大致跟期中考一樣。
Project + Homeworks + quizzes: 40% +- 20%
- Project 是從助教給的 CVE中挑一個出來重現，建議早點開始挑個簡單的來寫。報告要分三次交，每次會有不同的進度。基本上分數很好拿，全班平均超高。

其他

不點名，沒線上，沒錄影。會有 pop quiz。這學期遇到兩次。

最後想說的話

甜爛。建議去上課，拿原文書啃很花時間，但是可以學到比較多東西。

軟體定義網路及網路功能虛擬化

英文課名：Software Defined Networks and Network FunctionVirtualization
永久課號：CSIC30127
教師：曾建超（超哥）

課程內容

沒…沒在上課 Orz

上課方式

投影片加上口述補充。

考試作業

大概每兩週一個 Lab，deadline 的下一周要去實體 Demo。週而復始直到寫完Final Project :)
Labs
1. Environment Setup and Basic Operation (5%)
2. OpenFlow Protocol Observation and Flow Rule Installation (10%)
3. SDN-enabled Learning Bridge (15%)
4. Unicast DHCP Application (15%)
5. Proxy ARP (15%)
6. Network Function Virtualization (15%)
Final Project: (25%)
- Virtual Routers
- 基本上就是把前面的東西串起來

其他

不點名，有線上，有錄影。因為沒考試，所以只要可以把功課寫出來，不上課也不會真的出大事（？

最後想說的話

希望超哥不會看到我沒上課 QQ

從中華郵政匯款到 Firstrade 的美元帳戶

2024-02-24T15:27:00.000Z

TL;DR

從郵局匯款到Fristrade，綁定約定到入帳最快可能可以四天完成。兩天是綁定的時間，兩天是匯款的時間。郵局這邊的手續費因為活動期間，用行動郵局App 轉帳只要 168。之後最便宜應該也要 300+ 100。中轉行收 15 USD。

時間線

2024/02/15 17:00 申請綁定約定帳戶
2024/02/17 12:01 通知綁定完成
2024/02/19 14:19 匯款至 Firstrade
2024/02/21 09:26 看到 Fristrade 收到款項
2024/02/21 晚上 申請匯款補助
2024/02/21 下午 收到匯款補助

費用

項目	金額
申請綁定約定帳戶	NT$0
郵局匯款（活動期間）	NT$158
中轉行	US$15
Firstrade 補助	-US$21
合計花費	≈ -NT$31.70

細節

申請綁定約定帳戶

需要的東西有：身分證、郵局存摺、印章和 Firstrade的帳戶資訊。這個過程大概需要 5 分鐘。

到郵局後，會給你一張紙填寫，基本上就照著 Firstrade給的資料填就好了。可以參考下面這張照片。（抱歉這種小朋友字體。）

不建議直接照抄（因為我字很醜），要抄還是照著 Firstrade的資料抄。或是參考網路上的教學，例如這篇。

郵局匯款

大概等 2 天之後，就會收到郵局的簡訊通知。簡訊內容大概是這樣：

中華郵政客戶您好：您申請網路（行動）郵局外匯匯出匯款服務已生效，請登入網路郵局或下載行動郵局APP，即可使用相關功能。

我是用 行動郵局 App來轉帳的。一開始還以為是在一般的轉帳的地方，結果他是要去 App下面的「更多」→「外匯匯款」→「匯出匯款」才有。匯出的教學網路上一定也很多，要注意的就是要寫對附言。寫錯就麻煩了（我也沒遇過就是了XD）。

因為我是在活動期間，所以手續費只要 168。下面是匯款紀錄。

[OS] Chapter 12 — Mass Storage System

2022-01-31T10:12:24.000Z

Notion好讀版

Disk Structure

由磁盤組成，最小儲存單位是 sector，買來就切死的，所以用軟體的 block（多個 sector）來控制。Sector 會有number，所以可以對特定資料作讀取。

Sectors per Track

Constant linear velocity ****(CLV)
- Density of bits per track 是固定的
- 這樣內圈的資料量就會小於外圈的
- 但是這樣讀取資料的速度會不固定
  → 讀內圈要轉比較快
- applications: CD-ROM and DVD-ROM
Constant angular velocity ****(CAV)
- keep same rotation speed
- 內圈 density 比較高
- 這樣轉速就不用改
- applications: hard disks

Disk IO

EIDE, ATA, SATA (Serial ATA), USB, SCSI, etc
效能會有差
I/O bus is controlled by controller

Disk Scheduling

Disk-access time has 3 major components
- seektime：去移動讀寫頭的位置花的時間（通常最慢）
  → 主要優化目標
- rotational latency：轉動磁盤的時間（快到可以被 ignore）
- read time：content transfertime（取決於一次讀寫的資料量，也可能這邊最慢）
Disk bandwidth — # of bytes transferred/(complete of last req –start of first req)

FCFS(First-Come-First-Served)

問題的描述方式會是一串數字，代表著他是第幾圈的資料。

SSTF(Shortest-Seek-Time-First)

看哪一個離目前的磁頭最近的就去那個（Greedy）
有 starvation，因為 request會不停地發生，所以很遠的可能一直被插隊
不是Optimal，因為只能找現在離我最近的，可能等一下進來的會更近，但是他就跳走了，他應該要停一下等那個未來的傢伙。

SCAN Scheduling

通常的解
我就移動我的，有剛好可以做的我就做
disk head move from one end to the other end
轉到底會換方向
⇒ 檢查時間不 uniform
A.k.a elevator algorithm

C-SCAN Scheduling

只轉一個方向，走到底就把磁頭拉回去另一端
⇒ 比較 Uniform
（Round robin）
基本上都用這個，不會用 SCAN

C-LOOK Scheduling

一樣只轉一個方向，但是不會走到底
如果往右邊走，就會去看右邊的下一個是誰
其實跟 SSTF 很像，因為他在也會被剛進來的帶著走（但是不會starvation）

Summary

SSTF
- common and has a natural appeal, but not optimal
SCAN
- perform better for disks with heavy load
- No starvation problem
C-SCAN
- More uniform wait time
Performance is also influenced by the file-allocation method
- Contiguous: less head movement
  → 可能會因為有同時很多 process 在讀，所以還是不 contiguous的
- Indexed & linked: greater head movement

Review Slides (I)

3 major components in disk-access time
- Seek
- Rotation
- Read
Goal of disk-scheduling algorithm
Disk-scheduling algorithms
- FCFS
- SSTF
- SCAN
- C-SCAN
- C-LOOK

Disk & Swap-SpaceManagement

Disk Formatting

一般的格式化是 high level 的格式化，low level 的 disk 的formatting（這是出廠前就做好的）是 dividing a disk (magnetic recordingmaterial) into sectors that disk controller can read and write 。

each sector = header + data area + trailer
- Header — metadata，i.e. where the sector is, the ID of thesector
- trailer — error correction code, based on all bytes in dataarea
High-level: partition and 用 data block 的方式去存取

Booting

Bootstrap program
- Initialize CPU, registers, device controllers, memory, and thenstarts OS
- First bootstrap code stored in ROM
- Complete bootstrap in the boot block the boot disk (aka systemdisk)
Booting from a Disk in Windows 2000
1. Run bootstrap code in ROM
2. Read boot code in MBR(Master boot record)
3. Find boot partition from partition table
4. Read boot sector/block and continue booting

Bad block

A.k.a 壞軌

Disk controller 是第一個去處理的
IDE — 看 ECC 知道他壞掉就不會讀給上面的，而是 notify他們說「欸，壞去啊！」
SCSI — 除了不會讓你用以外，還會把壞掉的地方的儲存空間 recreate出來，有下面兩種方式
1. Sector sparing (forwarding) —像是有空白的撲克牌，有牌不見就拿空的補充。但是這樣連續的 sector #會存在不連續的地方，所以壞太多效能就會變差。
  → Run time 在用的
2. Sector slipping — 從壞掉的地方開始全部往後移一格。超花時間。
  → Reboot 在做的

Swap space

Seethis
之前是說由 Virtual Memory 或是 Memory Manager 。把他切成固定的page，然後直接 map。
他也可以用 File system 來管。把每一個 page 設成 4kb 的file。當要存取的時候就用 file name 當作 page ID。
通常是直接用 Memory Manager 來操作，不通過 filesystem，比較快。
所以用 raw partition 一定比較快，但是這樣就會浪費 raw partition的空間。且如果 VM 用得很兇，那 swap space會不夠，那就效能大量下降。
所以通常都一起用。
Swap Space Allocation
- 1st version: disk 和 memory 都一份一樣的
- 2nd version:
  - Solaris 1:
    - Run time 產生的才存，像是 code 就不用存，反正需要再去 disk拿就好
    - 如果 declare 了但是還沒用，那就不用存在 swap space
  - Solaris 2:
    - 先不要再 swap space 存 copy，只有在 swap out 才 create

RAID Structure

現在儲存空間越來越便宜。

RAID = Redundant Arrays ofInexpensive Disks

→ 想要用很多便宜的硬碟，產生一個 powerful 的 storage device

→ provide reliability viaredundancy (多 backup)

→ improve performance viaparallelism (平行化，一起讀寫)

RAID is arranged into different levels
- Striping → 資料分散
- Mirror (Replication) → 資料 copy
- Error-correcting code (ECC) & Parity bit

RAID 0

Striping → 把檔案切割用 Round Robin 的方式擺到印碟上去
Improve performance viaparallelism → 大資料可以同時讀取

RAID 1

Mirror → 複製
Provide reliability via redundancy→ 通常最多作三個 replica
- 讀取速度會變成 N 倍
- 寫入速度不變

RAID 2: Hamming code

Hammingcode → 可以推出是誰遺失然後重建出來
E.g.: Hamming code(7,4)
- 4 data bits (on 4 disks) + 3 parity bits (on 3 disks)
- 只浪費的 75%（RAID 1 是 100%）

RAID 3 & 4: Parity Bit

硬碟壞掉，他本來就會自己說，所以應該是不用偵測的，我們只需要recovery
→ a single parity bit is enough to correct error from a single diskfailure
→ 所以我們只需要浪費 1/N
RAID3: Bit-level striping; RAID 4: Block-level striping
→ RAID 4 recover 的速度會略快（除非壞掉的只有一個bit），因為讀取都是一個 block 在操作的，所以他就不用橫跨好幾的 disk了
讀取速度是 N - 1 倍，寫入速度不變（因為要去寫存Parity bit 的那顆）

RAID 5: Distributed Parity

Load balancing → 把 parity bit 分散在各個 disk
最常見的
Read 可以是 N 倍了
Write
- Method 1
  1. 讀 N-2 筆 data
  2. 重算 pb
  3. 寫進去那兩個
  ⇒ N / (N - 2 + 2) = 1
- Method 2
  1. 讀原本的值
  2. 算出修改的影響
  3. 寫入
  ⇒ N / 4 times faster

RAID 6: P+Q Dual ParityRedundancy

你有不只一個 PB ⇒ 可以多個硬碟壞掉

Hybrid RAID

RAID 0+1: Stripe then replicate → 保護能力比較弱
RAID 1+0: Replicate then stripe
先寫先做

Review Slides (II)

Swap space using FS? Raw partition?
How to reduce swap space usage?
RAID disks? Purpose?
RAID-0~6?
RAID 0+1, RAID 1+0

Textbook Questions

此筆記為清華大學周志遠教授作業系統之課堂筆記，所有內容及圖片皆取材於課堂內容。
如內容有誤，歡迎來信 mail@arui.dev。

[OS] Chapter 13 — I/O System

2022-01-31T10:12:24.000Z

Notion好讀版

Overview

電腦不是在做 I/O 就是在做計算
I/O devices: tape, HD, mouse, joystick, networkcard, screen, flash disks, etc
I/O subsystem: the methods to controlall I/O devices
Two conflicting trends
- 我們希望他是 interface，這樣才可以 standardization 的控制
- 但是他又很多樣性
Device drivers: a uniform device-accessinterface to the I/O subsystem
⇒ Similar to system calls between apps and OS
Device categories
- Storage devices: disks, tapes
- Transmission devices: network cards, modems
- Human-interface devices: keyboard, screen, mouse
- Specialized devices: joystick, touchpad

I/O Hardware

Port: A connection pointbetween I/O devices and the host. 每個 port 都有自己的 ID，那就是 device對於電腦的 identifier。
→ E.g.: USB ports
Controller: A collection of electronics that canoperate a port, a bus, or a device
⇒ A controller could have its own processor, memory, etc. (E.g.: SCSIcontroller)
Bus: A set of wires and a well-definedprotocol that specifies messages sent over thewires（連接的方式，除了物理相接，還有 protocol 的部分）
→ E.g.: PCI bus

I/O Methods

透過 port address 做 什麼事
Port address 用一個簡單的 table 就好了，反正也沒有很大
Each I/O port consists of four registers (1~4 Bytes)
- Data-in register — In buffer
- Data-out register — Out buffer
- Status register — 狀態的值
- Control register — command

I/O Methods Categorization

Depending on how to address a device
- Port-mapped I/O
  - 直接用 I/O instruction (e.g. IN, OUT)
- Memory-mapped I/O
  - Access by standard data-transfer instruction (e.g.MOV)
  🙂 More efficient for large memory I/O (e.g. graphiccard)
  ☹️ Vulnerable to accidental modification, error
Depending on how to interact with a device:
- Poll (busy-waiting): processor periodicallycheck status register of a device.不停地確認好了沒，啥時可以作下一個
  → 如果量不多，用這個
- Interrupt: device notify processor of itscompletion. I/O 好了他會直接 call interrupt 跟你的程式講。
⇒ 通常會 Memory-mapped I/O ＋ Interrupt或是另外兩個相加，不然會互相抵銷好處。
Depending on who to control the transfer:
- Programmed I/O: transfer controlled by CPU
  → 需要一直用 CPU
- Direct memory access (DMA) I/O: controlled byDMA controller (a special purpose controller)
  → 只負責 I/O
  - Design for large data transfer

Interrupt

Interrupt Vector Table
Interrupt Prioritization
- Maskable interrupt — 有一些不重要的 interrupt 會被 mask掉
- Non-maskable interrupt (NMI): highest-priority, never masked
  → Often used for power-down, memory error
Interrupt-Driven I/O
CPU and device Interrupt handshake
1. Device asserts interrupt request (IRQ) → I/O要註冊他的 interrupt，這樣 OS 才知道要去處理誰
2. CPU checks the interrupt request line at thebeginning of each instruction cycle
3. Save the status and address of interrupted process
4. CPU acknowledges the interrupt and search the interruptvector table for interrupt handler routines
5. CPU fetches the next instruction from the handlerroutine
6. Restore interrupted process after executing interrupt handlerroutine

DMA (Direct Memory Access)

File System → （我要讀多少資料，要讀到 X）→ device driver →（說「我要讀多少資料，要讀到 X」，並 register 一個 interrupt說「做完之後跟我說欸」） → disk controller → （初始化DMA，因為他只能傳很少的資料，所以 DMA 就開始不停地送搬移的指令到 diskcontroller，然後存到 X）→ DMA → （Through interrupt 到 CPU 說我搬完了）→CPU → 看到搬完了，開心：）

注意那個 X 通常是 physical 的 address，不然就要去看 pagetable，那就需要 CPU 去跑 OS 來看。

→ 這樣 Virtual Memory 就有點失效，因為那塊就被 fix 住了。

Review Slides ( I )

Definition of I/O port? Bus? Controller?
I/O device and CPU communication?
- Port-mapped vs. Memory-mapped
- Poll vs. Interrupt
- Programmed I/O vs. DMA
Steps to handle an interrupt I/O and DMA request?

Kernel I/O Subsystem

I/O Scheduling
Buffering — Bridge 速差
Caching — Always just a copy; Key toperformance
Spooling — 像 buffer，但是是 all ornothing
Error handling — when I/O error happens
I/O protection — Privilegedinstructions
Device-status Table
Life Cycle of An I/O Request

Performance

Intercomputer Communications

Application Interface

Textbook Questions

此筆記為清華大學周志遠教授作業系統之課堂筆記，所有內容及圖片皆取材於課堂內容。
如內容有誤，歡迎來信 mail@arui.dev。

[OS] Chapter 11 — File System Implementation

2022-01-31T10:11:24.000Z

Notion好讀版

File-System Structure

一個 disk 提供的最小單位是 sectors（usually 512 bytes）
但是 mapping 的時候不喜歡用 sector，太小了
所以都用 Blocks，通常是四到十幾個 sectors
一個 OS 可以 support > 1 個 FS type
需要兩個 interface
- 對上：user programs
- 對下：physical storage (disk)

Layered File System

最上層是 API
最下層（最終要寫到 disk 上面去的）要透過 driver 寫過去，那 driver要的是單位是 sector
Logical file system — 根據 file path 找到 fileID，也要去判斷權限（i.e. 判斷 API 是不是合法可執行的東西）
File-organization module — 每一個 FS 最不一樣的地方。要找到在logical 中的位址對應到的 physical 的地方。（甚至需要 map到不同的電腦）
Basic File system — 最基本的 I/O 的動作（跟檔案管理無關啦）

之所以一個 fread 可以對不同的 file system作操作就是中間有 FS manager (VFS — Virtual File System)

File System Implementation

On-Disk Structure

→ 因為 reboot 後，資料還是要在，所以和之前的不一樣

Boot control block ****(per partition) — 關於booting 的 code 或資訊
- 裝 OS 他就會幫你 create 起來
- 一個 partition 只會有一個（也最多一個） boot controlblock，通常會放在最上面
- 如果不是開機槽，那就不會有這個 block
- Unix File System → boot block; NTFS → partition boot sector
Partition control block ****(per partition) — 關於這個 partition的資訊
- details: # of blocks, block size, free-block-list, free FCBpointers, etc
- UFS → superblock; NTFS → Master File Table
- 如果沒有 boot control block，那他應該會在最前面
File control block (per file) — file 的 metadata
- 注意不存 data，data 會有一個指標指過去
- UFS — inode; NTFS: stored in MFT (relationaldatabase)
Directory structure (per file system): organize files

$ stat

In-Memory Structure

→ 一樣的，只是哪些東西要被 load 到 memory 裡面

in-memory partition table — 有人被 mount，他就會存關於這個 partition的資訊。Unmount 就會被移除。
in-memory directory structure — 最近 accessed 到的 directory
system-wide open-file table — 被 open 的 file 的 file controlblock
per-process open-file table — process 對於一個 file 需要 keep的資訊，且 file close 的時候，他就會被清掉，不會寫回去。

File-Open

如果沒讀過這個 directory，他就會去 disk （secondarystorage）的地方把他拉出來
Directory 的最後接的是 file control block

File-Read

上面 open 好了，所以兩個 open-file table 都 ready 了

去 per-process 確認有沒有權限（logical file system）
如果有，去 system-wide 找 file control block 裡面存的 data block 的pointer

File-Create

OS allocates a new FCB
Update directory structure
1. OS read in the corresponding directory structure into memory
2. Updates the dir structure with the new file nameand the FCB
3. (After file being closed), OS writes back the directory structureback to disk → Close 才會寫回去，因為 disk 太慢了
The file appears in user’s dir command

Virtual File System

Four main object types defined by Linux VFS Disk Allocation Methods
- inode (FCB) → an individual file
- file object → an open file (per process)
- superblock object → an entire file system
- entry object → an individual directory entry

DirectoryImplementation

大型系統的 directory 太大了，且掉了很慘

Linear lists
- use link list and traverse
- easy to program but poor performance
Hash table
- 把 file path 當成 key，FCB 是 value
- constant time for searching
- linked list for collisions on a hash entry
- hash table usually has fixed # of entries

Review Slides (I)

Transfer unit between memory and disk?
App → LFS → FOM → BFS → I/O Control → Devices
on-disk structure
- Boot control block, Partition control block
- File control block, Directory structure
In-memory
- Partition table, Directory structure
- System-wide open-file table
- Per-process open-file table
Steps to open file, read/write file and create file?
Purpose of VFS?

Allocation Methods

把 file 對應到 block。

Contiguous Allocation

一個 block 一定只屬於一個 file
Sequential access 和 random access 都很有效率（根據 I/O的次數作判斷）→ random 是因為可以用算的飛過去
☹️ Problems
- External fragmentation → compaction（硬碟清理）
- File cannot grow（會被後面卡住）→ 搬移資料（big cost）

Extent-Based File System(Ext)

用 link list 的方法把 extent 串起來
所以除了存 start 和 length，還要多存 pointer to next extent
☹️ Problems
- Random access become more costly
- “Internal fragmentation” → extent 給他的 blocks 沒用完

Linked Allocation

把下一個 block 的 pointer 存在 data block 裡面，dir 只會有第一個pointer
Only good for sequential-access files, randomaccess need to traverse through the link list
Each access to a link list is a disk I/O (because link pointer isstored inside the data block)
每一個 data block 都會浪費 4 byte 去存 pointer
Reliability → 斷了就 GG

FAT (File AllocationTable) file system

把整個 pointers 存起來，所以就變成一個純 link list，存取還是需要traverse，但是不用 I/O，只會有很快的 memory access
超快，但是需要空間
Link 斷了也 GG

Indexed Allocation

跟剛剛很像，但是他是用 index，不用 traverse
很快，random 也超快
注意那個 index 也是存在 disk 上了，他也是一個 block
所以 inode 會存那個 index 在的 block
☹️
- Index block 很浪費空間，小的 block 根本用不完
- Index block 如果不夠大？
  - Linked Indexed Scheme
    → search time 會變長
  - Multilevel Scheme (two-level)
    → 大 file 這個比較優
    → 小 file 就很浪費

Combined Scheme: Unix inode

根據 file size 決定用哪個

Free-Space Management

找到全部的 free block
Free-space list: records all free disk blocks
Scheme
- Bit vector
  - 用一串 1 和 0 去紀錄他是不是 free 的
  - 🙂 simplicity, efficient
  - ☹️ 因為是 fix size，會浪費 memory 空間
- Linked list (same as linked allocation)
- Grouping (same as linked index allocation)
- Counting (same as contiguous allocation)
  → keep the address of the first free block and # of contiguous freeblocks

Review Slides (II)

Allocation:
- Contiguous file allocation? Extent-based file system?
- Linked allocation?
- Indexed allocation?
  - Linked scheme
  - multilevel index allocation
  - Combine scheme
Free space:
- Bit vector, linked list, counting, grouping

Textbook Questions

此筆記為清華大學周志遠教授作業系統之課堂筆記，所有內容及圖片皆取材於課堂內容。
如內容有誤，歡迎來信 mail@arui.dev。

[OS] Chapter 10 — File System Interface

2022-01-31T10:10:24.000Z

Notion好讀版

File Concept

File 也是抽像的概念。

Physical storage unit in disk
File attributes (Metadata)
- Identifier: non-human-readable name
- Name
- Type
- Location
- Size
- Protection
- Last-access time, Last-updated time
File operations
- Create
- Write
- Read
- Repositioning within a file (i.e. file seek)
- Delete
- Truncating → 切掉尾巴
- Appending → 貼在尾巴
Open-File Tables
注意他存的是 metadata，不是 data
- Per-process table
  - Tracking all files opened by this process
  - 跟操作這個 file 有關的資訊（independent 的）
  - File pointer → process 操作這個檔案到的位置
  - 裡面還有一個 pointer 指到 file 的 System-wide table
    ⇒ 這樣就可以避免資料一致性的問題，所以才不要 duplicate 一份到Per-process table 裡面
- System-wide table ****
  - 不管誰操作都要看到的資訊（share 的）
  - File size, disk location
Open File Attributes
- File pointer (per-process)
- File open count (system table)
- Disk location (system table)
- Access rights (per-process)
File types
- .exe, .com, .obj, .cc, .mov, etc
- Hint for OS to operate file in a reasonable way

Access Methods

是以使用者的角度來看：

Sequential access
- 連續的存取
- fread, fwrite
Direct (relative) access a.k.a random access
- Call API 需要給他位址
- 像是使用 table
- 使用者要自己維護位址（With great power comes greatresponsibility）

Index Access Methods
- DB
- 用 index 去存取資料
- Index: contains pointers to blocks of a file
- With a large file → index could become too large
- To find a record in a file:
  - search the index file → find the pointer
  - use the pointer to directly access the record

Review Slides (I)

File vs. Sector, Track
Open-file (in-memory) attributes
- Per-process, system-wide?
File-access methods?
- Sequential access
- Direct access
- Index access

Directory Structure

Directory Basics

Partition (Raw partition) — 儲存的空間切割後變成單獨的 partition作是使用和管理，但是這個區塊我們還沒作格式化的動作
Volume — 我們有把他作 formatted（File system 的格式化）的動作了（File system 的專有名詞）→ 強調這是由 filesystem 管理使用的空間
Directories — used by file system to store the information aboutthe files in the partition
File-System Organization
File name 本身也是 directory 的一部分
- 因為要找到 file，就要有 file name
- 所以 Directory 的最後一層是 file name
Directory Operations
- Search for a file
- Create a file
- Delete a file
- List a directory
- Rename a file
- Traverse the file system

Directory structure

Single-Level Directory

指的是沒有資料夾，完全只有檔案
Single 指的是 file name
File name 很容易打架，因為不能重複
因為是 flat 的，所以每次都要 scan through，效能差

Two-Level Directory

出現了資料夾
一個 user 一個資料夾，所以還是有上面的問題

Tree-Structured Directory

Multi-Level
有 absolute path 和 relative path

Acyclic-Graph Directory

可以建立捷徑到同一個 file
When does a file actually get deleted?
1. deleting the link but not the file
2. deleting the file but leaves the link → dangling pointer
😃 deleting the file when reference counters is 0

General-Graph Directory

可以隨便亂指，甚至可以有 cycle
有可能會明明 access 不到了，但是因為有 link在，所以也沒刪掉檔案
- Garbage collection
  → 從 root 開始 traverse，mark 每一個人，沒 mark 到的就刪掉
  ☹️ Poor performance
- Use cycle-detection algorithm when a link is created

Review Slides (II)

Directory structure: pros & cons
- One-level directory
- Two-level directory
- Tree-structured directory
- Acyclic-graph directory
- General-graph directory

Mounting

A file system must be mounted before it can be accessed
Mount point — 接到的位址（the root path that a FS will be mountedto），系統槽就是 mount 在 /
Mount timing: three possibility
1. boot time （系統槽）
2. automatically at run-time（USB）
3. manually at run-time
File System Mounting Example
- Partition B 的 mount point 是在 /usr
- Partition C 的 mount point 是在 /home
mount –t ext2 /dev/sda0 /mnt/hdd
- mount 一個 file type 是 ext2 的（所以知道這是啥FS，才能正確讀取），他現在是 /dev/sda0 （是被 I/O deviceattach 成一個檔案的，mount 之後才可以讀取）要 mount 到/mnt/hdd
How to extend the tree
- Tree 長這樣
- 前面的 m 代表那不是我管的，是 mount進來的，所以要去查下面的 mount table
- mount 就會修改這裡面的內容

基本上都是 multi-user，所以要 sharing，但是要處理permission
對於每一個 process，需要去管理他的
- Identity：誰 call 的（Login 就知道了）（也有 groping去幫助管理）
- Permission：知道是誰後要知道他可以動誰
Each user — UserID, GroupID
Each file has 3 sets of attributes — owner (one and only), group(can operate), others
Access-Control
Create an access-control list (ACL) for each user
- 每次 request 就去查他的權限
☹️ 會太大，每新增一個 user or file ACL will be huger
- 3 classes of users → 3 ACL (RWX) for each file
  - Owner — (e.g. 7 = RWX = 111)
  - group — (e.g. 6 = RWX = 110)
  - other (public) — (e.g. 4 = RWX = 100)

Protection

Access control protection
Data failure protection
- 用加密的方式保護他不會遺失

Review Slides (III)

File system mounting point, timing?
Access-control list? How does it function?

Textbook Problem Set

此筆記為清華大學周志遠教授作業系統之課堂筆記，所有內容及圖片皆取材於課堂內容。
如內容有誤，歡迎來信 mail@arui.dev。

[OS] Chapter 7 — Deadlocks

2022-01-31T10:07:24.000Z

Deadlock Characterization

Notion好讀版

Example
- 2 processes and 2 tape drivers
  - 一人各拿一個，然後等對方手上那個
- 2 processes, and semaphores A & B
  - P1 (hold B, wait A): wait(A), signal(B)
  - P2 (hold A, wait B): wait(B) , signal(A)

Necessary Condition →一定要全部的條件同時發生

Mutual exclusion — 資源是沒有共享性的（暫時）
Hold and Wait — 會 hold resource 然後 wait 別人
No preemptive — 不能強制別人放開 resource
Circular wait — 一定會有一個 circular 的 wait。
$P_0 \rightarrow P_1 \rightarrow P_1\rightarrow \dots\rightarrow P_n \rightarrow P_0$

System Model

要有某些資源 $R_1, R_2, \dots,R_m$
- E.g. CPU, memory pages, I/O devices
每個資源 $R_i$可能會有複數的共 $W_i$ 個instances
- E.g. a computer has 2 CPUs
每一個 process 取得 resource 的方式：
Request → use → release

Resource-Allocation Graph

3 processes, P1 ~ P3
4 resources, R1 ~ R4
- R1 and R3 each has one instance
- R2 has two instances
- R4 has three instances
Request edges:
- P1 → R1: P1 requests R1 （一直存在因為 resource 正在被用）
Assignment edges:
- R2 → P1: 那個 instance 正在被 P2 使用

⇒ P1 is hold on an instance of R2 and waiting for an instance ofR1

If the graph contains a cycle, a deadlock may exist
- 如果有 multiple instances，那就要檢查每一條路線都是 cycle才行
- Example 1
  1. P1 is waiting for P2
  2. P2 is waiting for P3 → P1 is waiting for P3
  3. P3 is waiting for P1 or P2, and they both waiting for P3
  ⇒ deadlock!
- Example 2
  1. P1 is waiting for P2 or P3
  2. P3 is waiting for P1 or P4
  3. Since P2 and P4 wait no one
  ⇒ no deadlock

Deadlock Detection

沒 cycle → 沒 deadlock
有 cycle
- one instance per resource type → 有 deadlock
- multiple instances per resource type → 可能有 deadlock

Handling Deadlocks

確保不會進去
- deadlock prevention — 確保至少一個必要條件不會發生
- deadlock avoidance — 在 runtime 去不斷的檢查
讓他進去再 recover
- deadlock detection
- deadlock recovery
完全不處理（ignore the problem）
- 讓 user 去中斷他

Review Slides ( I )

deadlock necessary conditions?
- mutual exclusion
- hold & wait
- no preemption
- circular wait
resource-allocation graph?
- cycle in RAG → deadlock?
deadlock handling types?
- deadlock prevention
- deadlock avoidance
- deadlock recovery
- ignore the problem

Deadlock Prevention& Deadlock Avoidance

Deadlock Prevention

每一種 resource 各拿掉一種條件。（每一個可以不一樣）
- Mutual exclusion (ME): do not require ME on sharableresources
  - E.g. set file to read only → no mutual exclusion (can many read insame time)
  - 但不是所有都可以這樣解
  - （Memory 是 support concurrent access 的，是 programer 的行為讓他有ME 的條件出來的）
- Hold & Wait
  - 規定他要 free 掉手上的 resource 才能去要其他resource。或是一就要把全部的 resource 要齊（只要要等就要把拿到的 free掉，可以等，但是手上不能有東西）。
  - All or nothing allocation
  - 去改變 mutex_wait 的實作
  ☹️ Resource 使用率降低，可能會有 starvation
- No preemption
  - 改成可以作 preemptive
  - E.g. preemptive 的 scheduler → 有 timer 去讓 OS always controlCPU
  ☹️ Overhead，要多一塊 memory 去暫存資料
  → Printer 的代價就太高了（要重印）
- Circular wait
  - 在 request resource 的時候，如果你要 request $R_k$，那就要 release $R_i, \forall i \geq k$。（小於 $k$ 的可以繼續 hold）
    手上不能握比較大的。
  - Example
    - F(tape drive) = 1, F(disk drive) = 5,F(printer) = 12
    - 如果 hold disk，可以要 printer
    - 如果 hold printer 和 tape，那 request drive 就要 releaseprinter，tape 可以留著
  - Proof
    - 證明有 deadlock 但是不可能成立
    - $P_0(R_0) \rightarrowR_1$($P_0$ hold $R_0$ and request $R_1$)
      $P_1(R_1) \rightarrow R_2, \dots, P_N(R_N)\rightarrow \red {R_0}$
    - 但是最後一個不可能成立，因為 $N>0$

Avoidance Algorithms

Single instance of a resource type
→ 用 resource-allocation graph (RAG) algorithm ****直接偵測circle
Multiple instances of a resource type
→ banker’s algorithm

Resource-AllocationGraph (RAG) Algorithm

Request edges:
- $P_i \rightarrow R_j$: $P_i$ waiting for $R_j$
Assignment edges:
- $R_j → P_i$: $R_j$ is allocated and held by $P_i$
- Resource 被 release 可能轉回 claim edge
Claim edge:
- $P_i \rightarrow R_j$: $P_i$ may request $R_j$ in the future (worstcase)
- 真的發生就會變成 request edges
Example
- 這不會出事
- 當 P2 request for R1 的時候，他會被擋掉。因為我們會假設 claim的情形會在未來 somehow 發生。
Cycle-detection algorithm ⇒ $O(n^2)$

Banker’s algorithm

去考慮 worse case。

Safe state → 可以找到一個 safe sequence讓程式照著跑，結束前都不會遇到 deadlock
Unsafe state → 有機率會 deadlock
Deadlock avoidance → 不要進到 unsafe

Safe Sequence

Assume 有 12 個 tape drives
Safe state:
- At t0:
  Max Needs Current Holding
  P0 10 5
  P1 4 2
  P2 9 2
  - Max need is hinted from processes
  - Max need is worst case
  → is a safe sequence
  1. 給 P1 3 個（有的都給他）
    Max Needs Current Holding Available
    P0 10 5
    P1 4 2 3
    P2 9 2
  2. 給 P0 5 個
    Max Needs Current Holding Available
    P0 10 5 5
    P1 4 0 0
    P2 9 2
  3. 給 P2 10 個
    Max Needs Current Holding Available
    P0 10 0
    P1 4 0
    P2 9 2 10
Unsafe state:
- At t1:
  假設這時候 OS 拿到的一個 request 說 P2 想要多一個 tape drive。
  Max Needs Current Holding Available
  P0 10 5
  P1 4 2 3 → 2
  P2 9 2 → 3
  - 跑一次上面的流程，然後我們就會發現，如果我們同意了（P2 的 currentholding 變成 3 了），我們就會發現他可能會 deadlock （i.e. 進到 unsafestate）。
  - 所以 OS 就會擋掉這個 request。
Banker algorithm:
1. 拿到 request，先假設同意了
2. 然後去跑 safe sequence
  選 sequence 的順序隨便都沒差。
3. 如果 safe sequence 存在，我們就 grant request，反之就不同意
  如果有數個，那就都可以，反正至少一個就好了
Banker’s Algorithm Example 1
我懶得貼.. P.27
Programming Example
A, B, C are semaphores initialized with the values of 2, 1, 1.
用 round-robin 跑。
- 原本
- Use avoidance
  - P4 的 wait(A) 如果成功了，加上 claim edge 就會 dead lock，所以 OS不會讓他拿
  - 接下來 P2 就會搶到 A，然後 eventually 他就會 signal A andC，剩下的就會成功結束了

	Max Needs	Current Holding
P0	10	5
P1	4	2
P2	9	2

	Max Needs	Current Holding	Available
P0	10	5
P1	4	2	3
P2	9	2

	Max Needs	Current Holding	Available
P0	10	5	5
P1	4	0	0
P2	9	2

	Max Needs	Current Holding	Available
P0	10	0
P1	4	0
P2	9	2	10

	Max Needs	Current Holding	Available
P0	10	5
P1	4	2	3 → 2
P2	9	2 → 3

Review Slides (II)

deadlock prevention methods?
- mutual exclusion
- hold & wait
- no preemption
- circular wait
deadlock avoidance methods?
- safe state definition?
- safe sequence?
- claim edge?

Deadlock Detection& Recovery from Deadlock

deadlock 了再解
（就算卡住了，也只是 user program，OS 一定不會卡住的啦，要信任OS）
所以就就當下的情況去跑上面那些 check
Single instance
Multiple-Instance → Banker’s algorithm
- 可以把 Max Needs 拿掉，沒用了
- 去檢查有沒有 safe sequence 存在，有就當作沒事。沒有就代表進入deadlock 了。
Deadlock Recovery
→ Process termination
- 但是要 kill 誰？（可能可以 kill priority 低的）（但是一直 killpriority 低的可能會 starvation ）
- Kill 掉之後還可以 roll back 嗎？

Textbook Problem Set

此筆記為清華大學周志遠教授作業系統之課堂筆記，所有內容及圖片皆取材於課堂內容。
如內容有誤，歡迎來信 mail@arui.dev。

[OS] Chapter 6 — Process Synchronization

2022-01-31T10:06:24.000Z

Notion好讀版

Background

因為有 share 的 data，會被多個 content 去用他，所以需要
就算只有一個 core，也會有 Concurrent 的問題（因為會有 contentswitch）
重點就是他們 execute 的 order

Consumer & Producer Problem

用 counter 去記還有幾個空位

Producer

while (1) {
nextItem = getItem( );
while (counter == BUFFER_SIZE);
buffer[in] = nextItem;
in = (in + 1) % BUFFER_SIZE;
counter++;
}

Consumer

while (1) {
while (counter == 0) ;
item = buffer[out];
out = (out + 1) % BUFFER_SIZE;
counter--;
}

但是 counter 會是這兩隻 thread共用的東東，所以會出現不一致的問題：

counter++

1
2
3

move ax, counter
add  ax, 1
move counter, ax

counter--

1
2
3

move bx, counter
sub  bx, 1
move counter, bx

但是…如果是這樣呢？（counter initially is 5）

producer: move ax, counter   // ax = 5
producer: add ax, 1          // ax = 6
context switch
consumer: move bx, counter   // bx = 5
consumer: sub bx, 1          // bx = 4
context switch
producer: move counter, ax   // counter = 6
context switch
consumer: move counter, bx   // counter = 4

不過如果不是 preemptive 就不會有這個問題了。

Race Condition

Single processor 的可以用 disable interrupt 或 non-preemptive CPU來解決。

Critical Section

~~一個 process 之間溝通的 protocol~~
Critical section: 會產生 race condition 的那段程式碼。
Mutually exclusive: 會有相同 critical section 的process。他們要在那段 critical section 被迫去 serialize。

Critical SectionRequirements

Mutual Exclusion: if process P is executing in its CS, no otherprocesses can be executing in their CS
Progress: 有 process 想要進去空的 criticalsection，就應該要讓他馬上進去。（有效性）
Bounded Waiting: 不能讓等的人一直等，要 bound 他的 waitingtime。（公平性）

2 和 3 是可捨取的

Review Slide

Race condition?
Critical-Section (CS) problem? 4 sections?
- entry, CS, exit, remainder
3 requirements for solutions to CS problems?
- mutual exclusion
- progress
- bounded waiting

Software Solution

Assume only 2 processes, $P_0$and $P_1$
用 turn 決定輪到誰
- 因為是用 single instruction 去 set，所以不會被中斷詠唱
- Requirements
  1. Mutual Exclusion: Yes
  2. Progress: Nope，不符合 Progress 的條件，因為 $P_0$ 可能已經繞一圈想上去了，但是因為$P_1$ 還沒進過 CS，所以他進不去
  3. Bounded Waiting: Yes，因為是 Round robin.

Peterson’s Solution forTwo Processes

跟剛剛那個很像，但是多了一個 flag，用來表示他是不是想要進去critical section（True 就是他準備好進去了）
對方可以看到別人的 flag，但是只有自己可以改自己的
所以進去的時候就是別人不想進去，或是你拿到 token 了（i.e.對方沒拿到 token）

Proof

Mutual exclusion: 用反證
1. 假設他們可以同時在裡面
2. 那下面的條件就要同時存在。
3. 因為他們都在裡面，所以 flag 都是 true
4. 但是 turn 不可能同時是 0 且 1
5. 所以不可能同時進去
Progress
1. 假設 $P_0$ 想要進去，且 $P_1$ 不想要進去，要證這時候 $P_0$ 應該要要可以進去 ⇒好像也不用證，反正就可以啊
2. 兩個都想進去的時候，那就看turn，一定有其中一個可以進去
Bounded Waiting
- 假設當 $P_1$ 想要進去，但是 $P_0$ 在裡面。
1. $P_0$ 一離開 CS 就把flag 設成 False 了，所以馬上就輪到 $P_1$ 了
2. $P_0$ 如果一離開 CS就又想進去（可能因為剩下的都是 CPU burst，所以就沒有被 content switch掉）
  ⇒ 但是因為會在最一開始把 token 給別人，所以會被讓給別人作

Producer/Consumer Problem

如果先進 Consumer 就會 deadlock（i.e. 程式沒有在前進，但是 CPU在燒）。
正確但是低效能。
正確且優質。

Bakery Algorithm (nprocesses)

像去麵包店

在每次進去 CS 前，要抽號碼牌
號碼牌最小的先進（因為 counter 是用 ++的，所以只能保證是 non-decrease order 的，e.g. 1, 2, 3,3, 4, 4, 4, 5）
如果號碼牌一樣，就根據 process ID，小的先

// Process i
do {
choosing[i] = true;  // 開始抽
num[i] = max(num[0], num[1], ..., num[n-1]) + 1; // get ticket
choosing[i] = false; // 抽完了
for (j = 0; j < n; j++) {
while (choosing[j]);  // 確定他抽完了才可以比
while ((num[j] != 0) &&     // num 是 0 就是不想進去
 ((num[j], j) < (num[i], i))); // 比較每一個 j 確定我是最小的
}
**critical section**
num[i] = 0;
**reminder section**
} while(1);

最小號碼一定先做 → first come first serve → bounded-waitingtime
如果沒有 choosing
1. 假設目前最大是 5
2. P4 抽的比較快，抽到 6，這時候 P1 還是 0
3. 然後 P4 會進去 CS（他這時候會以為 P1 沒有要進去，因為他是 0）
4. 接下來 P1 抽完了，抽到 6，他就去跟 P4 比，發現跟他一樣，但是他的 pid比較小，所以他就開開心心的進去了。然後就沒有然後了。(race conditionby355)
- 如果有 locking，P4 就會等到 P1 先抽完再跟他比

Synchronization Hardware

只要用到 Hardware 的就算是（包括之前的 disable interrupt）

Atomic instruction

一個 CPU 的 instruction，所以一定會一次做完。

不需要 library 的 support，內建就有了。

`TestAndSet()`

boolean TestAndSet (bool &lock) {
bool value = lock;
lock = TRUE;   // 不論結果，都會鎖起來
return value;  // return 的是原本的值
}

Mutual exclusion: Yes
⇒ 因為只有正在 CS 裡面的人把他設成 False 才可以放下一個進去
Progress: Yes
⇒ 只要沒人在裡面，想進去就可以馬上進去
Bounded-Wait: No
⇒ 因為先搶先贏，所以可能一直搶不到
⇒ P0 的 CS 結束了，但是 CPU burst 還沒完，所以他又搶到lock，然後進去之後 CPU burst 結束了，content switch。換P1，但是他被擋在外面，CPU burst 燒完之後都輪不到他 QQ，又回到 P0繼續。

`Swap()`

把值對調。

特性也跟剛剛一樣

Review Slide (2)

Use software solution to solve CS?
- Peterson’s and Bakery algorithms
Use HW support to solve CS?
- TestAndSet(), Swap()

Semaphores

Resource counting 的問題。
一個值 indicate 想要透過 semaphore 保護的資源的數量多寡。
- If #record = 1 → binary semaphore, mutex lock
- if #record > 1 → counting semaphore
用兩個 atomic operation：
1. wait：搶資源
  1
  2
  3
  wait(S) {
  while (S <= 0); // busy waiting
  }
  用的是 Spinlock → 等待還是會燒 CPU（因為一直在作指令）
2. signal：放資源
  1
  2
  3
  signal(S) {
  S++;
  }

POSIX Semaphore

他是 OS 的 API
Semaphore is part of POSIX standard BUT it is not belonged toPthread
- It can be used with or without thread
因為 lock 多是在 threads 之間，semaphore 多是在 process之間。

POSIX Semaphore routines:

sem_init(sem_t *sem, int pshared, unsigned int value)
sem_wait(sem_t *sem)
sem_post(sem_t *sem)
sem_getvalue(sem_t *sem, int *valptr) // check
sem_destroy(sem_t *sem)

Example:

#include 
sem_t sem;
sem_init(&sem);
sem_wait(&sem);
// critical section
sem_post(&sem);
sem_destroy(&sem);

Another example

do {
wait(mutex);   // pthread_mutex_lock(&mutex)
// critical section
signal(mutex); // pthread_mutex_unlock(&mutex)
// remainder section
} while(1);

Progress: Yes
Bounded waiting: 取決於 wait 的實作

Non-busy waitingImplementation

Semaphore is data struct with a queue （可以用各種 queuestrategy）

typedef struct {
int value;        // init to 0
struct process *L;
// “PCB” queue 
} semaphore;

wait() and signal()

需要用到 block() and wakeup() 兩個 systemcalls。（明顯的缺點，需要多用到 system call）

void signal(semaphore S) { 
S.value++;
if (S.value <= 0) {         // 注意有 `=`，因為我們先 `++` 了 
remove a process P from S.L; 
wakeup(P);
}
}

void wait(semaphore S) {
S.value--;  // subtract first
if (S.value < 0) {         // 注意沒有 `=`
add this process to S.L; // 要先放進去才能去睡覺
block();
}
}

更多行加上更多 share data（那些 queue），所以要確保他有 atomic的特性。可以用：
- Single-processor: disable interrupts
- Multi-processor:
  - HW support (e.g. Test-And-Set, Swap)
  - SW solution (Peterson’s solution, Bakery algorithm)
如果等待時間短，不如用 busy waiting，不然要一直 call systemcall。

Cooperation Synchronization

因為會有資料的 independency，所以也可以用這個來解。

Example:
- P1 executes S1; P2 executes S2 (S2 be executed only after S1 hascompleted)
- sync 一開始設成 0
A More Complicated Example (DAG)
- (Initially, all semaphores are 0)

Deadlocks & Starvation

Deadlocks: 2 processes are waiting indefinitely for each other torelease resources（程式之間彼此互卡）
Starvation:
- example: LIFO (Last In First Out) queue in semaphore processqueue
- 有人可以執行只是輪不到我

Review Slide (3)

What’s semaphore? 2 operations?
What’s busy-waiting (Spinlock) semaphore?
What’s non-busy-waiting (Non-Spinlock) semaphore?
How to ensure atomic wait & signal ops?
Deadlock? starvation?

Classical Problems ofSynchronization

解決方法很多，重點是去定義問題。

Bounded-Buffer (Producer-Consumer) Problem
Reader-Writers Problem
Dining-Philosopher Problem

Bounded-Buffer Problem

就上面那些問題。

A pool of n buffers, each capable of holding one item
Producer:
- grab an empty buffer
- place an item into the buffer
- waits if no empty buffer is available
Consumer:
- grab a buffer and retracts the item
- place the buffer back to the free pool
- waits if all buffers are empty

Readers-Writers Problem

reader processes → 只會讀
writer processes → 只會寫
如果都是 reader 那沒差，反正同時 read 也不會出事。但是 writer就只能一個人寫，連 reader 都不能同時 read。（Exclusive access）
Different variations involving priority
- First RW problem: no reader will be kept waitingunless a writer is updating a shared object（只要符合上面的基本定義就好了）
- Second RW problem: first 的條件加上 writer 不能starvation。
  → Writer 要比較高的 priority
  → once a writer is ready, no new reader may start reading

First Reader-WriterAlgorithm

// mutual exclusion for write
semaphore wrt = 1;

// mutual exclusion for readcount
semaphore mutex=1  // 保護 readcount
int readcount=0;   // 有多少人要 read

Writer() { 
while(true) {
wait(wrt);
**// Writer Code**
signal(wrt);
}
}

Reader() {
while(true) {
wait(mutex);

readcount++;
// Acquire write lock if reads haven’t
// 全部 reader 共用一個 write lock
if (readcount == 1) // 代表原本沒有人在 read
wait(wrt);        // 所以需要要過來

signal(mutex);

**// Reader Code**

wait(mutex);

readcount--;
// release write lock if no more reads
if (readcount == 0)  // 代表沒有人要 read 了
signal(wrt);       // 就可以放掉了

signal(mutex);
}
}

Writer 會有 starvation，因為 reader 共用一個lock，所以可以一直輪流佔著
⇒ Second RW problem solve it.

Dining-Philosophers Problem

每個人左邊跟右邊都有一根筷子（五個人五隻筷子）
- 吃飯需要兩隻筷子
- 一隻筷子只能一個人拿
- 吃完就要把筷子放下
Deadlock problem
- 每個人拿左邊的筷子直到吃完飯 → 卡死
Starvation problem
- 不能讓人一直拿，一直吃

Monitors

目的是要更抽象化（他是在 language level）
跟 OO 很像
像是由一個 class 定義的東西：有自己的 methods、variables、privatevariables。
（Private variables 只能由自己的 methods 操作）
和 OO 不同的是他會確保他的 process 只會有一個在active (running) 的狀態
Schematic View ****
- Shared data → private variable
- Operations → methods
- Initialization code → constructor
- Entry queue → 想要用 monitors 的傢伙

(Monitor) Condition Variables

他是一個獨立的同步化 tool，跟 monitor 沒關係
Event driven
To allow a process to wait within the monitor, acondition variable must be declared, as
condition x, y;
Can be used with wait() and signal()（但是跟上面的那些毫無關係，請不要搞混，定義完全不同）
- x.wait()
  有一個 event queue，所以這像是 enqueue。（上面的那個是counting）
- x.signal()
  像是 dequeue，把裡面的 process叫醒去工作。如果裡面沒有東西，就啥都不會發生。（如果是semaphore，值會繼續加上去）

Dining Philosophers Example

Thinking — 根本沒要吃
假設大家都是看得到彼此的狀態的（i.e. 有 Global information）

monitor dp {
enum {thinking, hungry, eating} state[5]; // current state
condition self[5]; // delay eating if can’t obtain chopsticks
void pickup (int i)    // pickup chopsticks
void putdown (int i)   // putdown chopsticks
void test (int i)      // try to eat
void init() {
for (int i = 0; i < 5; i++) 
state[i] = thinking;
}
}

 void pickup(int i) {
state[i] = hungry;
test(i);               // try to eat (to prevent deadlock)
if (state[i] != eating)  // 沒成功吃到
self[i].wait();        // wait to eat
}

void putdown(int i) {
  state[i] = thinking;

// check if neighbors are waiting to eat
// 叫他們起來吃飯
test((i+4) % 5);
test((i+1) % 5);
}

void test(int i) {
if ((state[(i + 4) % 5] != eating) 
&& (state[(i + 1) % 5] != eating) // 左邊和右邊有沒有在吃
&& (state[i] == hungry)) {        // 和我想不想吃
// No neighbors are eating and Pi is hungry
state[i] = eating;

// 把他自己叫起（如果是 pickup call 的，這是沒有用的
// 但是如果是 putdown call 的，那就會搖醒睡著的）
self[i].signal(); 
}
}

An illustration

Thread Programming

（考試比較不會考）

Pthread Lock/Mutex Routines

To use mutex:

Declared as of type pthread_mutex_t
Initialized with pthread_mutex_init()
Destroyed with pthread_mutex_destroy()
Use pthread_mutex_lock() andpthread_mutex_unlock()

#include “pthread.h”
pthread_mutex mutex;
pthread_mutex_init (&mutex, NULL);  // NULL -> optional configuration
pthread_mutex_lock(&mutex);
**// Critical Section**
pthread_mutex_unlock(&mutex);
pthread_mutex_destroy(&mutex);

Condition Variables (CV)

跟上面的一樣。

In Pthread, CV type is a pthread_cond_t
- Use pthread_cond_init() ****to initialize
- pthread_cond_wait (&theCV, &somelock)
- pthread_cond_signal (&theCV)
- pthread_cond_broadcast (&theCV) → 把 queue裡面全部的 thread 都叫醒（i.e. 對他們全部作 signal）
Example
- 一個 thread 在 x = 0 的時候做事
- 另一個負責 x--
- 一定要把 wait 和 signal 在 mutex 被 lock 的時候才能用（不然連code 都不會跑）
  1. 因為 call wait 和 signal 的時候，大多會和其他 conditional variable有相依性（In this case: x），所以 lock起來才是合理的。
  2. 要確保 cond 不會有 concurrent write 的問題。
  ⇒ 所以至少要包到他本身和他的觸發條件。
- What really happens...
  1. action: Lock mutex
  2. action call wait, put thread into sleepand release the lock. ⇒ 因為 wait 會直接release mutex （所以不是下面那行做的，是 wait就直接 release 掉了！）
    counter lock mutex
  3. counter go into CS and call signal.
    action is waked up, but thread is locked.（unlock 會先呼叫 lock確定可以跑，但顯然不行，因為 lock 還在 counter 那邊）
  4. counter call unlock.
    action Re-acquire lock and resume execution
  5. action release lock
  - 另一個我們之所以要用 lock 包住的原因。

ThreadPool Implementation

Task structure
- 存 function pointer 跟 argument
ThreadPool structure
- thread_count — 紀錄一共有多少 threads
- *thread — threadPool
- head — *queue 的 head
- tail — *queue 的 tail
- shutdown — threadPool 是不是要結束掉了（決定要不要break while loop）
Allocate thread and task queue
Implement

Synchronized Tools in JAVA

Synchronized Methods (Monitor)

public class SynchronizedCounter { 
private int c = 0;
public synchronized void increment() { c++; }
public synchronized void decrement() { c--; }
public synchronized int value() { return c; }
}

加上 synchronized 就可以保證只有一個才操作。所以可以看到有動到c 的都有加。如果沒有動到 share data的，可以不用加，增加平行度。

Synchronized Statement (Mutex Lock)

public void run()
{
synchronized(p1)
{
int i = 10; // statement without locking requirement
p1.display(s1);
}
}

Review Slides (4)

Bounded-buffer problem?
Reader-Writer problem?
Dining Philosopher problem?
What is monitor and why need monitor?

Atomic Transactions

（考試不太會提）

System Model
- Transaction: 一系列的 operation
- Atomic Transaction: 需要一次完成 transaction，all or nothing
- DB 很容易需要
File I/O Example
- Transaction 是一連串的 read and write
- 像是 version control 的工具，需要有 commit（成功）、abort（失敗）、rolled back（失敗後要 undo）
- 所以重點是要有 log
  - 因為有 log 才能回推重建
  - 也叫做 checkpoint
  - 存在 secondary storage
- 也會有 checkpoints
  - 還原點，上一個 commit 的點
  - 說不定會直接不 undo，然後 apply checkpoint

Review Slides (5)

What is atomic transaction?
Purpose of commit, abort, rolled-back?
How to use log and checkpoints?

Textbook Problem Set

此筆記為清華大學周志遠教授作業系統之課堂筆記，所有內容及圖片皆取材於課堂內容。
如內容有誤，歡迎來信 mail@arui.dev。

[OS] Chapter 5 — Process Scheduling

2022-01-31T10:05:24.000Z

Notion好讀版

Basic Concepts

因為 multiprogramming 所以才要 scheduling。

CPU-I/O burst cycle

→ 東西要嘛在 CPU 要嘛在 I/O

所以每一個 process 就切成在 CPU burst 和在 I/O burst
I/O-bound program → 大部分在做 I/O
⇒ 不等於 I/O burst 的 cycle 數比 CPU多（數量應該要是一樣的，因為一個做完接另一個），應該要是一個 burst要很久。
CPU-bound program → 大部分在做 CPU
CPU 大多是短的 burst 很多

CPU Scheduler

Ready state → Running state

下面都假設是 single core，只有單一隻程式

Preemptive vs.Non-preemptive

Preemptive → 一個 process 可以在 CPU burst 中間被打斷
Non-preemptive → 一個 process 不能在 CPU burst中間被打斷，一定要做完的
CPU scheduling 要做事的時間點：
1. A process switch from running to waiting → CPU空下來了，可以加東西囉
2. A process switch from running to ready（可能是 timer到了，所以被丟過去了）→ CPU 空下來了，可以加東西囉
3. A process switch from waiting to ready → 看看有沒有更重要，需要就把running 的拿掉換他
4. A process terminates → CPU空下來了，可以加東西囉
- 紫色是 Non-preemptive 的 scheduler 只能做的事
大部分都是 preemptive。（Windows, Mac OS）
Preemptive issue
- 會打斷東西，所以可能會 raise condition（如果不打斷就不會產生）
- 會影響到 OS 需不需要處理 synchronisation 的問題
- Unix solution: 進到 kernel space 就 disable 2 和 3（就會變成non-preemptive）

Dispatcher

把 scheduler 選出來的東西丟到 CPU 裡面的苦工。（Switchingcontext...）
要很有效率

Scheduling Algorithms

Scheduling Criteria → 定義效能的指標
- CPU utilization
  - 0% ~ 100% (per core)
  - 通常大概會在 40% ~ 90% 之間
- Throughput
  - 每單位時間可以完成多少工作（processes）
  - High throughput computer system → 目標就是要最大化 through 的computer system
  - 很常見，比 utilization 重要（對 user 來講比較有感覺）
- Turnaround time
  - 單一 process 的角度來量測
  - 進到 new 到 terminate 的時間（submission ~ completion）
  - 通常會看平均、最大值、最小值、distribution 等等
- Waiting time
  - 在 ready queue 的總時間（不包括 waiting time）
  - 是純粹因為 scheduling 的原因所以不能執行
- Response time
  - new 到第一次回應（第一次進到 running）

First-Come,First-Served (FCFS) scheduling

先來先排

會給 CPU burst time，根據他們進來的順序

Example
- P1(24), P2(3), P3(3)
- Waiting time: P1 = 0, P2 = 24, P3 = 27
- Average Waiting Time (AWT): (0 + 24 + 27) / 3 = 17
Convoy effect (Head of line blocking):可以很快執行的被要跑很久的擋住了

Shortest-Job-First (SJF)scheduling

Optimal solution → minimum average waiting time
最短 CPU burst time 的先做
Two schemes
1. Non-preemptive
2. Preemptive
Non-preemptive example
有時候 ready queue 會是空的，那 CPU 就 idle。
AWT 不要算到 CPU idle 的時間。
Preemptive example
4 → content switch! 一般的方式可能是把 P1 加回 Ready queue 裡面，然後再挑最短的出來" />
但是因為沒有 futureknowledge，所以實作不出來（所以會預測，但是失準就 GG）
- Approximate SJF: time series,用歷史和上次的結果去調整比例來算
  \[ \tau_{n+1}=\alpha t_n+(1-\alpha)\tau_n \]
  - $\tau$ is the history and$t$ is the new one
  - $\alpha$ usually set as $1/2$
  - Example
    We guess 10 for the first time.

Priority Scheduling

每個 process 就有一個 priority的值（要怎麼決定，啥時決定，都可以），然後就照那個決定
最 general 的，上面的兩個也可以說是 priority scheduling
Problem:
- Starvation: 可能有 process 會永遠沒有排程到
  - Solution: aging → 等越久，priority 越高

Round-Robin (RR) Scheduling

每一個 process 都只能執行一定的時間（a.k.a time quantum, usually10 ~ 100 ms），時間到就被踢出來重新排隊
容易實作，公平
Performance
- TQ too large → FIFO (FCFS)
  - 如果不在乎 fairness，那這樣也 OK
- TQ too small → (context switch) overhead increase
  - 如果 CPU 沒什麼人在用，那這樣也 OK
- 所以就看系統需求
Example
Response time 通常會是最小的，但是 turn around time通常會很大

Multilevel Queue Scheduling

上面都是 single queue
現在這個有很多 ready queue，一個 process 只會進到其中一個queue
每一個單一 queue都可以用上面那些解法，我們現在要解決的是怎麼從這麼多 queue 中挑哪一個queue 來 deqeue
- Fixed priority scheduling: 根據 queue 的 priority 開始挑
  - 一樣會有 starvation → 最上面一定要清完才能作下面的，最下面的 queue可能會排不到
- Time slice: 每一個 queue 會有各自被選中的機率，選中就從那邊dequeue
我們要決定哪一個 process 要加到哪個 queue，但是要在 run之前就做決定，且加進去就會一直待在裡面，所以可能會東西作一作就變成不應該在那個queue 的，這樣不好。所以有下面的：

Multilevel Feedback QueueScheduling

Queues 不會分是要作哪種 process，所以 process 可以在 queues中移動。（所以叫 feedback）
所以 Higher level 一定都會先被執行（可以作 aging to preventstarvation）
所以我們要做的事情就變成要決定誰會移到哪個queue（跟上面要做的事完全不同）
幾乎都是根據 I/O 的時間來排，i.e. I/O-bound的程式會放到上面的 queue。（因為通常 I/O-bound 的程式 CPU通常會跑比較快）
Example
- 移動條件：如果超過 TQ，就往後踢
所以我們需要決定
- 有幾個 queues
- 每個 queue 用哪種 single queue 的演算法
- 什麼時候 process 要移動

Evaluation Methods

Deterministic modeling — Given 已知且固定的input，去比較各個方式（超沒用，通常當例子用）
Queueing model — 用數學（Queuetheory）去算（不是很準，偏向理論）
Simulation — 模擬然後得到結果（這只有部分功能）
Implementation — 就實作出來（這已經完整了）

Review Slide (I)

Preemptive scheduling vs Non-preemptive scheduling?
Issues of preemptive scheduling
Turnaround time? Waiting time? Response time? Throughput?
Scheduling algorithms
- FCFS
- Preemptive SJF, Nonpreemptive SJF
- Priority scheduling
- RR
- Multilevel queue
- Multilevel feedback queue

Special Scheduling Issues

Multi-Processor Scheduling

硬體會跟 scheduler 講說他需要多少，就拿給他
Asymmetric multiprocessing
- 會有一個 centralise 的傢伙在處理誰要去哪
- 就沒有 synchronise 的問題
- 但是會浪費一個 core 在處理
Symmetric multiprocessing (SMP)
- 直接開搶，所以需要 lock 來處理 synchronise 的問題

Processor affinity

把 process 綁在一個 CPU 上（不同 CPU burst 可能會在不同 core上）（是為了要處理資料在換 core 的時候資料要重新 cache）

Type:
- soft affinity
  - 如果有空的，就還是會去用
- Hard affinity
  - 就算有空的，也不會用
如果系統的 loading 沒有很高，這是一定有好處沒壞處的，但是如果很多process 在搶 core，那這就沒啥用了。

NUMA and CPU Scheduling

NUMA (non-uniform memory access)
- 有些 CPU 離某些 memory 比較近，所以還要把 process 放到離 CPU比較近的 memory

Load-balancing

Push Migration — 把工作推出去，如果 loading輕，就用這個去丟工作
Pull Migration — 把工作拉進來，如果 loading重，就用這個去丟工作
Load balancing often counteracts the benefits of processor affinity(355)

Multi-Core ProcessorScheduling

Multi-core Processor — memory stall: 需要等 access memory的時間
Multi-threaded multi-core systems
- 把上面等 memory access 的時間拿來做事
- Two ways:
  1. fine-grained: 把所有 stage的東西都記下來，所以東西不會掉。但是就需要很多硬體資源去記。（快，成本高）
  2. coarse-grained: 會 flush 不用的東西
Scheduling for Multi-threaded multi-core systems
- Hardware 跟 software 說要幾個 process，然後 software 就給他
- 要怎麼去處理要來的 process（執行在哪個 core）就給 hardware 決定

Real-Time Scheduling

Real-time does not mean speed, but keeping deadlines

Soft real-time — 希望可以不要 miss deadline，但是 miss也不會炸開
Hard real-time — 絕對不能 miss deadline

Real-Time SchedulingAlgorithms

比前面多了 period 的參數 →每過多久就會重新出現，要在下一次出現前做完這次的。（E.g., (0, 4, 10) →0，10，20 都會出現一次）

FCFS — Non-RTS
Rate-Monotonic (RM) Scheduling
- Static (Fixed) → 跑得時候不會改變
- Shortest period first
- Example
Earliest-Deadline-First (EDF) algorithm
- Dynamic → 跑得時候，每一個的 priority 會變動（因為離 deadline的時間會變近）
- Early deadline first
- Miss deadline 會被 bound 住
- Example

Review Slide (II)

What is Processor affinity?
Real-time scheduler
- Rate-Monotonic
- Earliest deadline first

Scheduling Case Study

Solaris

Priority-based multilevel feedback queue scheduling
六個 class — 更像是六個queue，反正最上面的一定會先做。裡面小的會再自己排序

Example
- the higher the priority, thesmaller the time slice（因為我們希望 priority 高的，CPUburst time 是短的，所以很快搶到就要很快放掉）
  - Time quantum expired: 只要使用超過你的 timeslice，就根據下表調整你的 priority。（因為感覺你是更 CPU burst 的）
  - Return from sleep: 從 sleep (i.e. I/O wait) 回來就提升priority。（因為可以縮短等待時間）

Windows

跟剛剛的差不多

Linux

值越小，priority 越高
分成兩個 class 而已
Priority 高的，分到的 time quantum 越大
⇒ 因為這邊的 time quantum 是 budget 的概念，只要用完就會被丟到waiting queue
所以他是用比較 fairness 的作法

Algorithm
- 一開始大家都在 active array，然後時間到就被丟到 expiredarray。（這樣就算是 low priority 的也可以被做到）
- 最後 active array 被清空了就把兩個 array 的指標對調。
- 所以他是一輪一輪的做。

Textbook Questions

QA

What is CPU-burst?
- 程式正在做 CPU 的 instruction，除此之外的時間都是 I/O-burst
Preemptive vs. Non-preemptive?
- Preemptive：在 CPU burst 間 scheduler 可以 interrupt 做 scheduling的動作
- Non-preemptive：在 CPU burst 間 scheduler 不能 interrupt 做scheduling 的動作（但是 hardware 還是可以 interrupt 的）

此筆記為清華大學周志遠教授作業系統之課堂筆記，所有內容及圖片皆取材於課堂內容。
如內容有誤，歡迎來信 mail@arui.dev。

WebSocket

2021-05-12T09:50:24.000Z

Notion好讀版

網路溝通可以分成兩種主要的 API

Web Service APIs (e.g. SOAP, JSON-RPC, XML-RPC, REST)
Web Socket APIs

HTTP

HTTP/2:the difference between HTTP/1.1, benefits and how to use it

REST (REpresentationalState Transfer)

→ 幫 HTTP 套規則

GET → 取得資料
PUT → 修改資料
POST → 新增資料
DELETE → 刪除資料

HTTP polling(輪詢)

可以用兔子（Client）和店老闆（Server）來想像。

HTTP Short Polling

需要一直問。像是兔子一直站在店旁邊不停地問「有紅蘿蔔嗎？」，每問一次老闆就要回他一次「沒有。」或是「有。」老闆回完話後，兔子過一陣子之後就會再問一次「有紅蘿蔔嗎？」所以整個流程就會像：

00:00:00 兔子 -> 有紅蘿蔔嗎？
00:00:01 老闆 -> 沒有。
00:00:03 兔子 -> 有紅蘿蔔嗎？
00:00:04 老闆 -> 沒有。
00:00:06 兔子 -> 有紅蘿蔔嗎？
00:00:07 老闆 -> 有，拿去。
00:00:09 兔子 -> 有紅蘿蔔嗎？

這種方法雖然不會占用 Client 和 Server過多的資源，但是因為他每過一陣子才會再重新問一次，所以也不能拿到即時的資料。還有就是在來回傳輸的過程中還是會頻繁的浪費網路資源，還有可能什麼都沒拿到。

HTTP Long Polling

這個方法就是老闆生氣了，不想要理兔子了，所以他決定等到貨到了再跟兔子說有紅蘿蔔了。但是如過或太久沒有到，久到他都氣消了，他還是會跟兔子說「沒有」。所以對話會變成下面這樣：

00:00:00 兔子 -> 有紅蘿蔔嗎？
00:00:10 老闆 -> 沒有。
00:00:10 兔子 -> 有紅蘿蔔嗎？
00:00:13 老闆 -> 有，拿去。
00:00:13 兔子 -> 有紅蘿蔔嗎？

這個的缺點就是老闆和兔子同時都被耽擱了，老闆在等著要回復兔子，而兔子也等著老闆的回覆。也就是說，前端和後端的通訊同時都被卡住了。還有如果資料更新的很頻繁，這個方法就會相對的很沒有效率，因為每次老闆都會馬上回答有貨了，而不能累積很多再一次給兔子。但他的優點就在於這種方法是沒有延遲的，因為老闆一拿到貨就會馬上跟兔子說有紅蘿蔔。

HTTP Streaming

這次換兔子覺得麻煩了，所以他跟老闆說，我就在這邊等著，只要貨一有情況就要馬上跟我說喔，等我拿夠了，我會再跟你說。所以對會變成這樣：

00:00:00 兔子 -> 有紅蘿蔔嗎？
00:00:01 老闆 -> 等一下喔。
00:00:02 老闆 -> 貨快到了。
00:00:03 老闆 -> 有，拿去。
00:00:03 老闆 -> 正在等下一次送貨。
00:00:04 老闆 -> 貨快到了。
00:00:05 老闆 -> 有，拿去。
00:00:05 老闆 -> 正在等下一次送貨。
00:00:06 兔子 -> 夠了，謝啦。

這個方法最大的問題是由於他是建立在 HTTP協定上的一種傳輸機制，所以有可能會因為代理伺服器（proxy）或防火牆（firewall）將其中的資料存放在緩衝區中，造成資料回應上的延遲。

SSE (Server Sent Events /EventSource)

這個方法和上一個類似，只是兔子覺得老闆太多廢話了，所以他跟老闆說，不要什麼都跟我說，只要有貨再跟我說就好了。

00:00:00 兔子 -> 有紅蘿蔔嗎？
00:00:03 老闆 -> 有，拿去。
00:00:05 老闆 -> 有，拿去。
00:00:06 兔子 -> 夠了，謝啦。

這兩個都共有的問題 MDN 上有提到

當連線不是透過 HTTP/2 時，SSE會受到最大連線數限制所苦，尤其當開啟多個分頁。每個瀏覽器有自己的限制數而且被限制在很低的數量（6）。

但是透過 HTTP/2 就沒差了。但是還是有一些瀏覽器不支援 SSE。

WebSockets

過了這麼久，兔子和老闆都變成朋友了。所以他們無話不談，誰都可以自由的溝通。

00:00:00 兔子 -> 有紅蘿蔔嗎？
00:00:01 老闆 -> 等一下喔。
00:00:01 兔子 -> 好啊。
00:00:03 老闆 -> 有貨了，拿去。
00:00:03 老闆 -> 正在等下一次送貨。
00:00:04 兔子 -> 這是甚麼口味阿。
00:00:04 老闆 -> 我不知道欸，蘿蔔口味吧。
00:00:05 老闆 -> 貨快到了。
00:00:05 兔子 -> 太棒了，超好吃的欸。
00:00:06 兔子 -> 但是我吃夠了，謝啦。

但實際上，老闆跟兔子還是要先培養感情才能這樣輕鬆的溝通的，所以他們一開始還是會透過原本HTTP 的方式來連線。

這就分別是 Client 和 Server 會傳給對方的訊息。Client 會傳送要求Upgrade 到 websocket 的請求和 websocket 的 Key 等資料。

GET /chat HTTP/1.1
Host: example.com:8000
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

如果 Server 端沒有問題，他也會回傳可以 Upgrade的訊息。

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

然後因為 WebSocket 是在另一個通訊方式下溝通的，所以他並不會占用原本用HTTP 溝通的管道。

WebSockets in100 Seconds & Beyond with Socket.io