OS Lecture #1 - HackMD

# :writing_hand: ==LECTURE OPERATING SYSTEM== --- ## :pushpin: Chapter :one: : Introduction to OS (Operating System) ### I. Operating System Overview * Some general Operating Systems (OS) <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/414975466_322524554086603_6480500186760805937_n.png?_nc_cat=110&ccb=1-7&_nc_sid=5f2048&_nc_ohc=VpbInCGGUqYAb6PoU3t&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QFlcN56FcRyG04WG3Xui8WuPyxtCX5T_WINVfIa9K8nLA&oe=664A2D0B> </center> * **Hệ điều hành dành cho máy tính** :::spoiler :small_blue_diamond: Được thiết kế để sử dụng trên thiết bị như: desktop, laptop, ... :small_blue_diamond: Là hệ điều hành sử dụng GUI. :small_blue_diamond: GUI cho phép bạn sử dụng chuột để nhấp vào mọi thứ trên màn hình hiển thị (bao gồm các biểu tượng , nút, menu,…) và được diễn tả bằng cách kết hợp hình ảnh cùng với văn bản. :small_blue_diamond: GUI của mỗi hệ điều hành có giao diện khác nhau, tuy nhiên các hệ điều hành hiện này hầu hết được thiết kế khá dễ sử dụng và không khác nhau nhiều về nguyên tắc. ::: * [Windows](https://en.wikipedia.org/wiki/Microsoft_Windows) :::spoiler * Được phát hành lần đầu tiên vào năm 1980 bởi Microsoft, trải qua rất nhiều phiên bản cho đến nay và gần đây nhất là Windows 11 (sắp ra mắt Windows 12 vào mùa thu) được cài sẵn trên hầu hết tất cả hệ thống máy tính. * Giúp nó trở thành hệ điều hành phổ biến nhất trên thế giới ở thời điểm hiện tại. * Ưu và nhược điểm * ==**Ưu điểm:**== phổ biến, dễ sử dụng, tính ổn định cao và có đầy đủ các tính năng phục vụ cho công việc cũng như giải trí. * ==**Nhược điểm:**== không phải miễn phí, cần mua bản quyền để sử dụng. ::: * [Linux](https://en.wikipedia.org/wiki/Linux) :::spoiler * Là một hệ điều hành mở, có nghĩa là bạn có thể sửa đổi, làm bất cứ gì trên hệ điều hành này. * Linux là hệ điều hành miễn phí và không cần mua bản quyền để sử dụng. * Ưu và nhược điểm * ==**Ưu điểm:**== miễn phí, bạn có thể thay đổi thậm chí là phân phối nó. * ==**Nhược điểm:**== rất ít người sử dụng, tính bảo mật không cao, giao diện có phần cổ điển. ::: * [Ubuntu](https://en.wikipedia.org/wiki/Ubuntu) :::spoiler * Là một hệ điều hành máy tính dựa trên Debian GNU / Linux, một bản phân phối linux thông dụng. * Mục đích của Ubuntu: cung cấp một hệ điều hành ổn định, cập nhật cho người dùng thường, và tập trung vào sự tiện dụng và dễ dang cài đặt. * Ubuntu đã được đánh xếp hạng là bản phân phối Linux thông dụng nhất cho desktop, chiếm khoảng 30% số bản Linux được cài đặt trên desktop năm 2007 * Bản phát hành đầu tiên của Ubuntu vào 20 tháng 10 năm 2004, bắt đầu bằng việc tạo ra một nhánh tạm thời của dự án Debian Linux. * Ưu và nhược điểm: * ==**Ưu điểm:**== là phần mềm mã nguồn mở tự do, có nghĩa là người dùng được tự do chạy, sao chép, phân phối, nghiên cứu, thay đổi và cải tiến phần mềm theo điều khoản giấy phép GNU GPL. Bằng việc để cho Ubuntu tự do và mở mã nguồn, Canonical có thể tận dụng tài năng của những nhà phát triển ở bên ngoài trong các thành phần cấu tạo của Ubuntu mà không cần phải tự mình phát triển. * ==**Nhược điểm:**== giao diện có phần cổ điển, ít người sử dụng vì không hỗ trợ nhiều tác vụ, tính bảo mật không cao. ::: * [Mac OS](https://en.wikipedia.org/wiki/MacOS) :::spoiler * Trước đây, macOS còn có tên là OS X, được tạo ra bởi Apple và được cài sẵn trên tất cả các thiết bị máy tính của Apple. * Ưu và nhược điểm: * ==**Ưu điểm:**== giao diện đẹp, được cài sẵn ở những chiếc máy tính được Apple bán ra và không tốn phí. * ==**Nhược điểm:**== vì số người sử dụng macOS ít nên còn có nhiều phần mềm chưa được phát hành cho hệ điều hành này. ::: * **Hệ điều hành dành cho các thiết bị di động** :::spoiler :small_blue_diamond: Được thiết kết trên các thiết bị di động: Smartphone, Tablet, Ipad, ... :small_blue_diamond: Được thiết kế với nhu cầu giải trí, liên lạc, ... nên không có các tính năng đầy đủ như hệ điều hành dành cho máy tính. ::: * [iOS](https://en.wikipedia.org/wiki/IOS) :::spoiler * iOS là hệ điều hành được sử dụng duy nhất trên các thiết bị di động của Apple. * Được ra mắt vào năm 2007, iOS đã tạo ra một cuộc cách mạng về công nghệ phần mềm. * Được đánh giá khá cao về tính năng cũng như về độ ổn định của nó. * Ưu và nhược điểm: * ==**Ưu điểm:**== tính bảo mật cao, khả năng tối ưu phần mềm tốt, hiệu năng ổn định mà không cần đòi hỏi nhiều về cấu hình so với Android. * ==**Nhược điểm:**== hệ điều hành chỉ độc quyền cho các dòng điện thoại của Apple và không thể sử dụng trên các điện thoại khác, kho ứng dụng ít hơn so với Android. ::: * [Android](https://en.wikipedia.org/wiki/Android_(operating_system)) :::spoiler * Hệ điều hành Android được phát triển bởi công ty Android Inc và được Google mua lại vào năm 2005. * Android là hệ điều hành trên thiết bị di động có số người sử dụng đông đảo nhất trên thế giới (chiếm 87,7% thị phần vào năm 2017). * Ưu và nhược điểm: * ==**Ưu điểm:**== hệ điều hành mở, vì hầu hết cách thiết bị di động đều sử dụng nên Android sở hữu kho ứng dụng khổng lồ, khả năng tùy biến cao, dễ dàng cài đặt lại thiết bị nếu như quên mật khẩu. * ==**Nhược điểm:**== hiện tại độ bảo mật của Android là khá cao nhưng sẽ không cao bằng nếu như so sánh với hệ điều hành iOS. ::: * **So sánh hệ điều hành trên máy tính và thiết bị di động** :::spoiler :small_orange_diamond: Hệ điều hành trên hai nền tảng này có sự khác nhau, nếu như hệ điều hành trên máy được sinh ra để xử lý, đáp ứng các nhu cầu về công việc, thì ngược lại trên thiết bị di động sẽ tập trung chủ yếu về các tác vụ giải trí, liên lạc, truyền thông, ... nhưng hiện nay hầu hết các hệ điêu hành đang được cải tiến và hầu như đều có thể đáp ứng toàn bộ chức năng này. ::: 1. ==**Definition**== * **Operating System (OS)** is a ==**system program**== (`chương trình / phần mềm hệ thống` : Dưới góc nhìn của *end-users - `người dùng cuối`*, **system programs** là một ==khái niệm vô hình (abstract concepts)== bởi vì người dùng cuối sẽ không cần quan tâm **systems programs** sẽ hoạt động ra sao mà chỉ chú trọng đến **application programs**, tức là các ứng dụng người dùng ra sao. Tuy nhiên, **system programs** là một thứ vô cùng quan trọng và cần thiết để chúng ta có thể vận hành máy tính, là một phần mềm chạy bên dưới để giúp thao tác với các phần cứng **computer hardware** mà không cần biết các cấu trúc vật lý của phần cứng là gì ?) * provides ++an easy way++ to execute **application programs** (`chương trình / phần mềm ứng dụng`), i.e, user programs solving user problems $\to$ is used by end users (e.g: word processor: word microsoft, ... ; web browser: chrome, firefox, ...) * acts as ++an interface++ (`giao diện`) between **application programs** (`chương trình / phần mềm ứng dụng`) and **computer hardware** (`phần cứng máy tính`) (e.g: CPU, memory, I/O devices) $\to$ ảo hóa phần cứng và phần mềm máy tính. * Differences between ==`System Programming`== and ==`Application Programming`==: :::spoiler * **System Programming** is the process of creating software that interacts directly with the hardware and the operating system kernel, such as device drivers, compilers, loaders, linkers, debuggers, and shell scripts. System programmers need to have a deep understanding of the architecture, functionality, and limitations of the hardware and the operating system, as well as the low-level languages and protocols that they use. System programming is often complex, critical, and error-prone, as it involves managing memory, resources, security, and performance. * **Application Programming** is the process of creating software that runs on top of the operating system and provides functionality and user interface to the end-users, such as web browsers, games, word processors, and mobile apps. Application programmers need to have a good knowledge of the high-level languages and frameworks that they use, as well as the requirements and expectations of the users. Application programming is often more diverse, creative, and user-oriented, as it involves designing, testing, and deploying features, interfaces, and interactions. | System Programs | Application Programs | | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | | It is the collection of components and art or designing of a given program | There are the set of programs that view computer as a tool for solving a particular problem | | System programming is done using assembly language which reacts with hardware | Application programming is used to build application software which includes software. | | System software that executes the application software $\to$ aims to produce software which provides services to the computer hardware. | Application software is a software that are been used by the end user. | | System programming is used to write low level instructions | Application Programming is used to write high-level instructions | |**++Examples:++** Loader, Linker, Compiler, Assembler Microsoft, ... | **++Examples:++** Library Management Systems, Calculator, Web Browser, ... | ::: * **Computer System Overview** * Một hệ thống máy tính được chia thành 4 thành phần sau: phần cứng, hệ điều hành, chương trình ứng dụng/chương trình hệ thống, người sử dụng,... * Phần cứng (hardware): CPU, bộ nhớ, các thiết bị nhập / xuất. * Hệ điều hành (operating systems): điều khiển và phối hợp việc sử dụng phần cứng cho nhiều ứng dụng với nhiều người sử dụng khác nhau. * Chương trình ứng dụng và chương trình hệ thống (system and applications programs): là các chương trình giải quyết những vấn đề của người sử dụng như là chương trình dịch, hệ quản trị cơ sở dữ liệu, chương trình trò chơi, chương trình thương mại,... * Người sử dụng cuối (end-users): người sử dụng hoặc máy tính. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415238806_904182684227503_1848170765005449955_n.png?_nc_cat=105&ccb=1-7&_nc_sid=5f2048&_nc_ohc=TLh-O7BuDksAb6VZKT6&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QFk1CZCaFI5WnAC2xGiTBiezes66dkxrqgkbEZ8TthHGg&oe=664A0261> </center> 2. ==**Role of an Operating Systems (OS)**== (có hai **vai trò quan trọng nhất**: ==user view== và ==system view==) * **Virtual machine (user view)** - `giả lập máy tính mở rộng / máy ảo` **$\to$ vai trò ==++quan trọng++== thứ nhất** * provides a uniform abstraction of computer hardware $\to$ `ảo hóa phần cứng máy tính` * provides abstract concepts (e.g: file) for using computer easiers $\to$ `ảo hóa các thiết bị phần cứng đơn giản phía dưới` $\to$ `cung cấp các khái niệm trừu tường để lắp đi sự phức tạp để quản lý các phần cứng` $\to$ `đơn giản hóa cách thức cho người dùng cuối sử dụng` * What if users open myfile docx ? * Ví dụ chúng ta cần mở một file văn bản thì chúng ta sẽ không cần quan tâm quá trình nhập, xuất văn bản của phần mềm ứng dụng như nào (bởi vì những quá trình phức tạp này hệ điều hành sẽ xử lý và che phủ hết toàn bộ hệ thống xử lý (đóng gói chương trình)) <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415446046_2540791852775821_3826246067999998123_n.png?_nc_cat=101&ccb=1-7&_nc_sid=5f2048&_nc_ohc=ouFKwSSbe0kAb6A1EAo&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QFPXf2Ws4vhZGvw_ekG6RW5ocxskKnwbu4fmUoo6VktYA&oe=664A064D> </center> * **Resource manager / allocator (system view)** - `quản lý tài nguyên` **$\to$ vai trò ==++quan trọng++== thứ hai** * manages resources (có thể là tài nguyên vật lý (chính là các thiết bị cấu hình nên máy tính hay còn gọi là hardware: CPU, memory, printer, ...) hay tài nguyên phần mềm (như là các ứng dụng phần mềm) hay các khái niệm ảo file, ...) among various programs in a ++fair++, ++efficient++, and ++safe++ manner. * Allocation / Deallocation: cấp phát và thu hồi dữ liệu vùng nhớ (tài nguyên) của máy tính (giúp quản lý dữ liệu hiệu quả) * Sharing: chia sẻ tài nguyên máy tính (luân phiên để giảm thiểu rủi ro, tăng hiệu suất trích xuất dữ liệu) * Protection: bảo vệ tài nguyên (ngăn chặn các truy cập bất hợp pháp từ những chương trình hay người dùng khác) <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415286480_674171638225745_5592824274058163769_n.png?_nc_cat=102&ccb=1-7&_nc_sid=5f2048&_nc_ohc=mErBKFGYypwAb4KifdC&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QFnmDPrhN6OnwQutW7DE3olcgeZPraYeKuNOHMBBeLOdw&oe=664A334E> </center> * **Set of utilities, i.e. system calls (programmer view)** - `Hỗ trợ giao tiếp với máy tính thông qua các lời gọi hệ thống` $\to$ ==*++vai trò phụ bổ sung++*== (bởi vì không phải ai cũng là programmers nên nó không phổ biến tác vụ hay chức năng này) * Facilitates and simplifies application programming $\to$ `giúp đơn giản hóa quá trình lập trình` $\to$ `system calls` là tập hợp các hàm do hệ điều hành cung cấp để các chương trình hay programmers có thể gọi tới hàm này $\to$ khi chúng ta gọi các hàm này thì chúng ta có thể thao tác và lập trình trên các phần cứng của máy tính mà không cần biết cấu trúc các hardware này là gì. * Write a program to read files from disk ? * Viết file các hàm đọc file từ ổ đĩa: Nếu chúng ta không sử dụng hệ điều hành, bắt buộc chúng ta phải làm việc trực tiếp với cấu trúc vật lý của ổ đĩa đó (do chúng ta không biết hay không có được những khái niệm hay các hàm system calls do hệ điều hành cung cấp như các khái niệm về bộ phận quản lý tập tin (như tập tin là gì ? ; mở / đóng tập tin là gì ?) hay các hàm xử lý tập tin (CRUD functions)). Tuy nhiên, việc đó vô cùng phức tạp, khó khăn và mất thời gian gấp nhiều lần đối với lập trình viên (vì để có thể lấy được dữ liệu từ ổ đĩa ra thì chúng ta phải biết dữ liệu nằm ở sector hay track nào của ổ đĩa $\to$ phải viết code rất dài để thực hiện nhiệm vụ đó). Từ đó, để giải quyết vấn đề này, chúng ta có thể nhờ vào hệ điều hành để cung cấp các system calls (một hàm hệ thống hay các khái niệm đã được trừu tượng hóa để dễ dàng thao tác xử lý tác vụ trong một hệ thống $\to$ đơn giản hóa việc lập trình) $\to$ trừu tượng hóa thao tác và các khái niệm về tập tin $\to$ chúng ta chỉ cần gọi hàm tốt thì hệ điều hành tự xử lý tác vụ. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415485417_1401454690745498_5298868056909923848_n.png?_nc_cat=104&ccb=1-7&_nc_sid=5f2048&_nc_ohc=fSxootliR3YAb6odqww&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGliGqk__WOdnMzHUVe0scDdM0O1hp2gScqyEzVKrLOKw&oe=664A27C3> </center> ### II. Classification #### 1. Batch OS - `Hệ điều hành xử lý theo lô` * Introduction: * ++Định nghĩa++: **Batch OS** được ra đời ở ==buổi sơ khai== (đầu tiên) của máy tính (lúc máy tính to như tòa nhà cần có những người chuyên biệt để vận hành máy tính, lúc đó chúng ta chưa có khái niệm về chương trình $\to$ tại thời điểm này đã có khái niệm **jobs** - là một tập hợp các lệnh và dữ liệu (set of instructions and data) để máy tính xử lý, không được nhập từ hardware $\to$ những tập lệnh được lưu trong những **thẻ đục lỗ (`punched card`)** bằng mã nhị phân. Máy tính lúc đó còn thô sơ chỉ bao gồm **bộ vi xử lý (CPU)**, **bộ nhớ (memory)** lưu trữ chương trình cần được xử lý và **các I/O devices** là các thẻ readers (card readers) hay là các printers để in các dữ liệu ở dạng card). * ++Nguyên lý hoạt động++: Các lập trình viên / chuyên gia sẽ tạo các punched card (đục lỗ thẻ) $\to$ đẩy dữ liệu trong các punched cards này bằng cách đọc vào memory máy tính thông qua các card readers và được xuất ra thông qua các printers. Tại thời điểm đó, máy tính chỉ xử lý được 1 job / program tại một thời điểm (đẩy punched card qua card readers sau đó in qua printers $\to$ tuần tự tuyến tính) $\implies$ Khi chúng ta xử lý như vậy thì CPU không đạt hiệu suất tối đa (bởi vì trong thời gian chờ chương trình máy tính đọc dữ liệu trong punched card và xuất dữ liệu nhờ printers $\to$ không được phép thực thi được chương trình khác) $\implies$ Để phát triển hệ điều hành hơn, chúng ta có phiên bản cải tiến của hệ điều hành này là Batch OS (Hệ điều hành xử lý theo lô) tại thời điểm này: chúng ta sẽ gom các công việc tương tự thành một lô (batch - gồm tập hợp của nhiều thẻ đục lỗ - `punched card`, mỗi thẻ đục lỗ sẽ thực hiện mỗi job khác nhau) rồi nhập vào CPU của chương trình máy tính xử lý (vì lúc này chúng ta có khái niệm là các punched card này có thể được gôm vào các khay và những khay này có thể thông qua các thiết bị đặc biệt để xử lý ghi vào các băng từ và đẩy một băng từ (batch: set of similar jobs) vào hệ thống xử lý từng batch một $\to$ cải thiện hiệu suất xử lý thời gian nhập xuất dữ liệu vào CPU máy tính. Tuy nhiên, điều này vẫn không ổn vì nó vẫn xử lý lần lượt từng batch với nhau thì chúng ta vẫn sẽ tiêu tốn và mất một thời gian uổng phí để chờ máy tính có thể nhập xuất xong từng batch dữ liệu đó.) * Defination: * A job / program (i.e, set of instructions, data) * Stored on punched card, which are read by card readers * A batch (i.e, set of similar jobs) * Executed one by one without user interaction directly * Advantages: :x: None * Disadvantages: * CPU is idle while the current job is waiting for I/O to complete $\to$ `CPU vẫn còn nhiều thời gian rảnh rỗi khi chờ quá trình nhập xuất dữ liệu`. * Lack of user application $\to$ `giảm sự tương tác của người dùng`. * :spiral_note_pad: Note * Đục sai lỗi $\to$ sửa lỗi lại từ đầu * Ko thể chen thêm các lô khác trong quá trình xử lý $\to$ tiêu tốn time và hiệu suất xử lý do CPU không thể làm gì khi các lô khác chạy <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415261891_742655691144694_5600258402768920892_n.png?_nc_cat=106&ccb=1-7&_nc_sid=5f2048&_nc_ohc=QNr0TpdU3gAAb5sS3jT&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHgGXFcEXZGk4EzY5Y5b_nAUMBgsTsqbdxc2aqahcg_9Q&oe=664A3124> </center> * Example: Xem một ví dụ về cách thức làm việc với hệ thống xử lý theo lô: * Lập trình viên mang phiếu ghi chương trình đến máy 1401 * Máy sẽ đọc chương trình từ phiếu và ghi chương trình vào băng từ * Lập trình viên đem băng từ tới máy 7094 để thực thi tính toán và kết quả được ghi vào băng từ. * lập trình viên đem băng từ chứa kết quả đến máy 1402 để in. <center> <img src = https://scontent.fsgn2-8.fna.fbcdn.net/v/t1.15752-9/429604319_904029091515652_207223873850211668_n.png?_nc_cat=102&ccb=1-7&_nc_sid=5f2048&_nc_ohc=oSRIuGKqGbQAb5log9H&_nc_ht=scontent.fsgn2-8.fna&oh=03_Q7cD1QG1doqDeQIDGryUFlAaBH-eessbkzt5CoqwsR7IDSxiDw&oe=664A0D7A> </center> #### 2. Multiprogramming OS - `Hệ điều hành đa chương` * Definition: * Multiple programs are kept in memory simultaneously (giữ nhiều chương trình trong hệ thống). * While the current program is waiting for an I/O operation, the CPU switches to another (giao nhiệm vụ đó cho một chương trình khác). * Advantages * Maximize CPU utilization (tối ưu hóa hiệu suất của CPU). * Disadvantages: * CPU scheduling ? $\to$ phải thiết kế thuật toán sao cho CPU biết xử lý chương trình nào trước nhằm tối ưu hóa thời gian xử lý chương trình. * Memory protection ? $\to$ đảm bảo các chương trình khác nhau không được truy cập lẫn nhau một cách bất hợp pháp vào vùng nhớ cho chương trình khác. * Example: trong một bộ nhớ hiện có ba chương trình thực hiện ba công việc: * Nếu công việc 1 yêu cầu nhập / xuất thì công việc 1 tạm ngừng * Công việc 2 (hoặc công việc 3) sẽ được thực hiện. * Khi thao tác nhập / xuất của công việc 1 xong thì công việc 1 sẽ được thực hiện tiếp, công việc 2 sẽ tạm ngừng. <center> <img src = https://scontent.fsgn2-9.fna.fbcdn.net/v/t1.15752-9/429768698_1109162927097362_1706936224827553949_n.png?_nc_cat=103&ccb=1-7&_nc_sid=5f2048&_nc_ohc=hC6Nb7U6NS4Ab6AATfJ&_nc_ht=scontent.fsgn2-9.fna&oh=03_Q7cD1QG_66pOZIrzUuwzco2wHFbe8QuKInechRzE7gQsa05M4g&oe=664A1849> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415286472_1145149840180980_8514331925607064242_n.png?_nc_cat=108&ccb=1-7&_nc_sid=5f2048&_nc_ohc=ygaMwt7txk8Ab4tlw_X&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QE-atPkeyN70ccbT66ced7O_JDBGnYOeqTSQDVgctuL5Q&oe=664A3738> </center> * Batch System vs. Multiprogramming System * Batch System: Thực thi tuần tự các chương trình $\to$ CPU có nhiều thời gian rảnh rỗi trong quá trình nạp và xuất operations $\to$ hiệu suất CPU không hiệu quả. * Multiprogramming System: nhiều chương trình nằm trong bộ nhớ tại một thời điểm $\to$ khi P~1~ thực thi quá trình nạp xuất thì CPU sẽ không còn thời gian rãnh rỗi nữa mà CPU sẽ thực thi quá trình xử lý của P~2~ $\to$ sau khi CPU thực thi xong P~2~ thì lúc đó đồng thời I/O operation của P~1~ cũng hoàn thành thì CPU lại thực thi tiếp P~1~ và I/O operation của P~2~ lại được thực hiện và cứ tiếp tục như vậy đến hết day chuyền $\to$ tăng hiệu suất làm việc của CPU. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415498814_928865088951127_104465867919570414_n.png?_nc_cat=106&ccb=1-7&_nc_sid=5f2048&_nc_ohc=KEc2JeGwvLcAb4y6cQs&_nc_oc=AdgZ2q-bhfXKVaFolSUSRAyJqIZF8OSq36w_gvOqhwfNxx_Pun1zByhk0BFqHDxglYlB55pE5i4N5XwcRzMOc6Wn&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QE-YR6ccVOHj1lvknFKcgvWBSgm4G9so_Y7-ULsDJi8pA&oe=664A3152> </center> #### 3. Timesharing OS (Multitasking OS) - `Hệ điều hành chia sẻ thời gian / đa nhiệm` :::info Hệ thống xử lý đa nhiệm là hệ thống mở rộng của hệ thống xử lý đa chương. Đối với hệ điều hành, trong hệ thống xử lý đa nhiệm, việc chuyển đổi công việc không có chờ công việc đang được thực thi có yêu cầu nhập / xuất, mà khi công việc đang thực thi hết thời gian quy định sử dụng CPU thì việc chuyển đổi công việc cũng sẽ xảy ra. Mỗi công việc đang thực hiện luân phiên qua cơ chế chuyển đổi CPU, thời gian mỗi lần chuyển đổi diễn ra rất nhanh nên người sử dụng có cảm giác là các công việc đang được thực thi cùng một lúc. ::: * Definition: Hầu hết các hệ điều hành chạy trên máy tính cá nhân thuộc hệ điều hành timesharing OS. * An extension of the multiprogramming system. * Switches CPU among various programs (luân phiên $\to$ việc chuyển đổi các chương trình thực thi phải nhanh nằm trong lát cắt thời gian (thời gian lượng tử)) * Each program utilizes CPU in a short quantum of time (time slice). * Requires direct interaction users / systems. * Advantages: * Quick response to users * Fast enough to give an illusion of **pseudo-parallelism** $\to$ tạo cho người dùng có cảm giác xử lý nhiều tác vụ với nhau cùng lúc $\to$ thật ra các chương trình không thể xử lý song song được vì chỉ có một CPU mà thôi $\to$ mục tiêu là phải đẩy nhanh phản hồi để users không thể thấy được sự luân phiên xử lý của CPU $\to$ cần phải có những thuật toán điều phối phức tạp. * Disadvantages: * More complex CPU scheduling (vì cần phải giải quyết thuật toán điều phối làm sao để có thể giả lập tác vụ song song cho người dùng). * Examples: hệ thống có một CPU và hiện tại có ba công việc A, B, C trong bộ nhớ. Ba công việc này sẽ được thực hiện luân phiên: công việc A thực hiện trong khoảng thời gian q (quantum) thì tạm ngừng, đến lượt công việc B thực hiện trong khoảng thời gian q, rồi đến lượt công việc C. Sau đó lại đến lượt A, .... lặp lại việc thực thi các công việc cho đến khi các công việc hoàn tất. <center> <img src = > <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/422937090_2079263169107383_310194362882209822_n.png?_nc_cat=110&ccb=1-7&_nc_sid=5f2048&_nc_ohc=XtEgYmQDagMAb4-BSMz&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QE3pJU8CBaakPJYGWx2WdvxYJyh7DYtb76yM2UFAXHX3g&oe=664A2E06> </center> #### 4. Parallel OS (Multiprocessing OS) - `Hệ điều hành song song / đa xử lý` * Definition: * Máy tính đa xử lý (multiprocessor computer) :::spoiler * là máy tính có hệ thống máy tính không chỉ có một CPU mà có thể có nhiều CPU hoặc một CPU nhiều kernel (vi nhân) (nhiều bộ vi xử lý tích hợp trong một CPU / máy tính cùng chia sẻ một tài nguyên và bộ nhớ, hệ thống đường truyền dữ liệu, đồng hồ, I/O systems (các thiết bị ngoại vi), bus để cùng truyền và nhập dữ liệu) $\to$ phát sinh nhu cầu về hệ điều hành $\to$ xuất hiện hệ điều hành Parallel OS (tác vụ được thực hiện một cách song song thực sự) ::: * Mostly runs on ==**multiprocessor computers**== with ==**shared memory**==. * Divides a program into multiple activities / jobs, which could be executed on different CPUs simultaneously to speed up the execution $\to$ thực hiện tác vụ song song một cách thực sự. * Examples: Nhìn trong hình được chia bên dưới, chương trình P~1~ được chia thành 2 tasks là A và B. Hai công việc A và B này sẽ được xử lý trên hai bộ vi xử lý (CPU) khác nhau một cách song song thực sự trong cùng một computer $\implies$ mục tiêu: khi xử lý song song các tác vụ trong máy tính, chúng ta có thể tận dụng được bộ vi xử lý $\to$ (1) tăng năng lực tính toán (vì có những tác vụ mà một cpu không thể tính toán được hết hoặc rất chậm), (2) tăng độ tin cậy trong việc xử lý tác vụ (vì một phần công việc nào đó trong một chương trình bị gặp trục trặc, rủi ro thì chúng ta vẫn còn những cpu khác để thực hiện tiếp các công việc còn lại) <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426742602_6742603735843707_3230530709395480361_n.png?_nc_cat=111&ccb=1-7&_nc_sid=5f2048&_nc_ohc=KwhpbBVHgZUAb6u-CKW&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGBF3tT-hPRq-6jpHouRrvPcGUN08dTOn180ZTYgqECZw&oe=664A1973> </center> * Advantages: * Computing power increase $\gets$ hệ thống sẽ thực hiện rất nhanh do thực hiện các công việc đồng thời trên các bộ xử lý khác nhau. * Reliability $\gets$ sự hỏng hóc của một bộ xử lý sẽ không ảnh hưởng đến toàn bộ hệ thống. * Việc liên lạc giữa các công việc dễ dàng bằng cách sử dụng bộ nhớ dùng chung. * Disadvantages: * Support of hardware and system architecture ? $\to$ hệ thống đắt tiền vì cần hỗ trợ nhiều CPU có kernel xử lý nhiều, và các thiết bị phần cứng phức tạp. * Parallel computing techniques ? $\to$ chúng ta cần phải tốn công để quan tâm và thực hiện các kỹ thuật xử lý tính toán song song phức tạp hơn rất nhiều so với việc xử lý tính toán đơn. * Classification: * Hệ thống đa xử lý đối xứng (Symmetric Multiprocessing (SMP)): mỗi bộ xử lý chạy với một bản sao của hệ điều hành va các bộ xử lý là ngang cấp. Các hệ điều hành hiện nay đều hỗ trợ SMP. * Hệ thống đa xử lý bất đố xử lý chính (master processor) kiểm soát, phân việc cho các bộ xử lý khác (slave processors) #### 5. Distributed OS - `Hệ điều hành phân tán` :::info Tương tự như hệ thống đa xử lý nhưng mỗi bộ xử lý có bộ nhớ riêng. Các bộ xử lý liên lạc với nhau thông qua các đường truyền dẫn qua mạng: mạng LAN, WLAN với hệ điều hành Windows, UNIX chính là các hệ thống xử lý phân tán. ::: * Definition: * Consists of ==**independent systems**== (e.g, computers, printers, smartphone, laptop, ...) linked via ==**network**== $\to$ nhằm phối hợp làm việc với nhau thông qua các thiết bị, chia sẻ tài nguyên, tăng tốc độ tính toán xử lý. * Need for a distributed OS * Resource sharing $\gets$ dùng chung tài nguyên: máy tin, tập tin, ... * Job collaboration easier $\gets$ truyền thông tin dễ dàng (download / upload file, gửi / nhận mail, ...) * Computing power increase $\gets$ phân chia công việc để tính toán trên nhiều vị trí khác nhau. * Safety $\gets$ nếu một vị trí bị hỏng, các vị trí khác vẫn tiếp tục làm việc. * Classification: có hai loại * Peer-to-peer: hệ thống mạng ngang hàng, các máy tính ngang cấp, không có máy nào đóng vai trò quản lý tài nguyên dùng chung. * Client - server: có một máy đóng vai trò quản lý các tài nguyên dùng chung gọi là máy server (máy chủ), các máy khác gọi là máy client (máy khách). Client muốn sử dụng tài nguyên dùng chung phải được server cấp quyền. Mô hình client - server <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/437934073_3840301706240694_4819150404967856819_n.png?_nc_cat=110&ccb=1-7&_nc_sid=5f2048&_nc_ohc=ZHMa9Yi4Jz4Ab4EWYSI&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHJZ-fXSsfdt6jHuppjd30hrjiYb7gcq3Ts1o0h9wr2yA&oe=664A16C8> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427967375_7928084533885699_834985477562785821_n.png?_nc_cat=107&ccb=1-7&_nc_sid=5f2048&_nc_ohc=QGsHE8SU6DUAb5UhtdA&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHc3tpSBsxB8qDUBMb_XDRCMPbM98VkgDJCc6tbK0IxHQ&oe=664A27B2> </center> #### 6. Real-time OS (RTOS) - `Hệ điều hành xử lý ở thời gian thực` * Definition: * Tasks must complete within ==**++time constraint++**== $\to$ `hệ thống phải hoàn thành tác vụ trong một khoảng thời gian deadline`. * Classification of RTOS: * Hard real-time system (`hệ thống thời gian thực cứng` $\to$ quan tâm nhiều hơn): time constraint **must** be respected $\to$ thuật toán xử lý real-time rất phức tạp, đắt đỏ, và hạn chế đối với end_users. * Time delay causes system failure (i.e, tasks **MUST** be done ++on time or fail++) * E.g: industrial control systems, traffic control system (điều khiển giao thông), air control systems (hệ thống điều khiển không lưu $\to$ vì nếu hệ thống không thể xử lý kịp theo thời gian thực thì sẽ gây ra tai nạn hàng không vô cùng thảm khóc) * Soft real-time system (`hệ thống thời gian thực mềm`) * Time delay accepted occasionally * E.g: multimedia system (ví dụ chúng ta download phim, thì do đường mạng chúng ta không tốt, phim sẽ bị ngắt quãng, mất tiếng, ... $\to$ hậu quả nhỏ mức độ người dùng nên hệ thống này không gây ra hậu quả thảm khốc) * Disadvantages: * Limited - Complex - Expensive <center> <img src = https://static.javatpoint.com/operating-system/images/hard-and-soft-real-time-operating-system.png> </center> #### 7. Embedded OS (Handled Systems) - `Hệ điều hành nhúng / cầm tay` * Defintion: * Installed on phones, PDAs, and other devices (not a company). * Designed for specific purpose. * May or may not have user interface. * Disadvantages: * Limited resources (low CPU, small memory, no disk, no AIP, ...) * Complex algorithm <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426819132_918692552905219_4177437851573572119_n.png?_nc_cat=100&ccb=1-7&_nc_sid=5f2048&_nc_ohc=LWJ3JPU4ZxoAb7Jm5qY&_nc_oc=AdhEd0OjvPXQS_a4_EKHvNb1AAqwqksMc5iIKyvW9qwwrVSvj3RlbepXILQ_sQpvMSAVxCD38oiXQ0yd4CvuYM4R&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QF5c8XIdsO981HZAS3IrZOwMsewLvbSYapwQ8-6D9ZbRA&oe=664A2E36> </center> :::info **REVIEW QUESTIONS** 1. What are three main functions (roles) of an OS ? Answer :::spoiler ::: 2. Describe the differences among multiprogramming, multitasking, and multiprocessing. Answer :::spoiler * The same things: * The different things: ::: 3. Describe the differences between multiprogramming OS and time-sharing OS. Answer :::spoiler * The same things: Nâng cao năng lực tính toán bằng cách chia tác vụ ra nhiều phần và xử lý lần lượt. * The different things: ::: 4. Describe the differences between parallel OS and distributed OS. Answer :::spoiler * The same things: * The different things: ::: 5. What is the purpose of system calls ? Give an example. Answer :::spoiler ::: ::: ### III. Main Components #### 1. Process (and Thread) Management - `Quản lý tiến trình và tiểu trình / luồng` $\to$ quan trọng nhất (1) * **Process and Thread operations** (e.g. ==**create**==, ==**destroy**==): là những đơn vị thực thi cơ bản nhất của máy tính * Process - `tiến trình`: a program (i.e, là đối tượng tĩnh bao gồm tập hợp những dòng code (e.g, word microsoft, excel microsoft, ...). Khi chương trình được nạp vào trong bộ nhớ để thực thi, sở hữu các tài nguyên thực của hệ thống để chạy lên, xử lý cho người dùng) in execution $\to$ là một phiên bản động, một phiên bản đang thực thi của một chương trình nào đó. * Thread - `tiểu trình / luồng`: a lightweight process, supported in most modern OS $\to$ là một phần kịch bản thực thi của tiến trình. * Một process (tiến trình) có thể được chia ra thành nhiều thread (tiểu trình con). Mỗi thread (tiểu trình con) sẽ thực hiện một phần công việc của tiến trình cha (main process) chứa tiểu trình đó $\to$ tiểu trình nhẹ hơn tiến trình vì nó chỉ là phần con của tiến trình. Hai tiến trình khác nhau phải sở hữu hai vùng nhớ khác nhau trong bộ nhớ nhưng hai tiểu trình cùng sở hữu trong một tiến trình sẽ có những phần vùng nhớ sử dụng riêng, có những phần vùng nhớ sử dụng chung của tiến trình cha. $\to$ lập trình tiểu trình đơn giản hơn tiến trình. * Các công việc của tiến trình sẽ có thể được chia công việc cho nhiều tiểu trình $\to$ các công việc này sẽ thực thi một cách song song. * Có hệ điều hành sẽ hỗ trợ cho tiểu trình và cũng có những hệ điều hành sẽ không hỗ trợ cho tiểu trình. Máy tính cá nhân đều có hỗ trợ cài đặt tiểu trình ở mức lập trình. * **Interprocess Communication (IPC)** - `cơ chế liên lạc`: là cơ chế giao tiếp giữa các tiến trình $\to$ chia sẻ, trao đổi và phối hợp xử lý dữ liệu, tác vụ giữa các tiến trình $\to$ về nguyên tắc an toàn, khi trong bộ nhớ có nhiều tiến trình, những tiến trình này nằm ở những vùng nhớ riêng biệt $\to$ tuân thủ nguyên tắc an toàn dữ liệu thì những tiến trình nằm ở vùng nhớ nào thì chỉ xử lý dữ liệu ở vùng nhớ đó, không được tùy tiện can thiệp vào các tiến trình khác $\to$ chúng ta cần phải thiết kế một cơ chế liên lạc giữa các tiến trình (IPC). * For exchanging data or collaborating to solve a task ... * Examples: Hệ thống đang xét có 2 tiến trình riêng biệt là P~1~ và P~2~, mỗi tiến trình đều sở hữu riêng cho mình một vùng nhớ riêng biệt. Nếu P~1~ muốn chia sẻ biến sum dùng chung cho P~2~, biết rằng biến sum nằm trong vùng nhớ của tiến trình P~1~ $\to$ tiến trình P~2~ không thể truy cập để xử lý biến dùng chung P~1~ $\to$ cần có cơ chế liên lạc giữa các tiến trình (IPC) để có thê chia sẻ, liên kết các biến hay dữ liệu dùng chung giữa các tiến trình. * **CPU Scheduling** - `điều phối CPU / lập lich CPU`: trong một hệ thống có một CPU để xử lý một chương trình có rất nhiều tiến trình (process) được lưu trong bộ nhớ (memory) để được thực thi. Đặc biệt, trong các hệ điều hành hiện đại dựa trên cơ chế Timesharing OS, nhiều tiến trình sẽ được nạp vào để được thực thi $\to$ CPU phải giải quyết vấn đề làm sao luân phiên các tiến trình này một cách có hiệu quả nhất nhưng vẫn tạo cho cảm giác người dùng có cảm giác các tác vụ được xử lý một cách song song. * How to allocate CPU among many processes fairly and efficiently ? * **Synchronization** - `đồng bộ hóa`: được áp dụng nhiều cho Thread hơn là Process. * What if various processes access a common resource at the same time ? $\implies$ Bài toán này sẽ xảy ra khi hai hay nhiều tiểu trình / tiến trình cùng chia sẻ một tài nguyên dùng chung $\to$ vấn đề xảy ra là tiến trình hay tiểu trình A cập nhật trên tài nguyên dùng chung thì tiến trình / tiểu trình B không được nhìn thấy cập nhật, hoặc xảy ra tranh chấp khi cả hai cùng cập nhật khác nhau $\to$ cần một cơ chế đồng bộ hóa các tiểu trình / tiến trình. $\implies$ Bài toán gặp nhiều cho đơn vị thực thi là tiểu trình hơn là tiến trình vì tiến trình có cơ chế liên lạc và vùng nhớ của tiến trình là vùng nhớ riêng biệt $\to$ việc cập nhật giữa các tiến trình ít bị tranh chấp hơn, trong khi việc thực thi các tiểu trình cùng thuộc trong một tiến trình ở một vùng nhớ (do ngoài vùng nhớ riêng biệt được các tiểu trình sở hữu thì các tiểu trình còn sở hữu một vùng nhớ dùng chung đồi với tiến trình cha) $\to$ nhu cầu sử dụng các biến dùng chung tăng lên $\to$ nhu cầu tranh chấp vùng nhớ ngày càng cao của các tiểu trình mà không có một cơ chế liên lạc nào cả $\to$ cần một cơ chế giải quyết tranh chấp (đồng bộ hóa). #### 2. Memory Management - `quản lý bộ nhớ (cấp phát và thu hồi vùng nhớ)` $\to$ quan trọng nhất (2) * Bonus details :::spoiler * Đối với máy tính, hai tài nguyên hệ thống quan trọng nhất là CPU (bộ vi xử lý $\to$ xử lý lệnh hệ thống) và Memory (bộ nhớ chính, tức là thường nói đến RAM $\to$ nơi CPU sẽ tương tác, truy cập trực tiếp lấy dữ liệu từ RAM để xử lý lệnh hệ thống). * Trong một hệ thống ở các hệ điều hành hiện đại (Timesharing OS) dựa trên hệ tư tưởng của hệ điều hành đa chương (multiprogamming OS) $\to$ tức là nhiều tiến trình sẽ được thực thi trong một bộ nhớ tại một thời điểm nhưng vấn đề đặt ra là trong một hệ thống chương trình thì chỉ có một thiế bị RAM $\to$ làm sao chia các phần của bộ nhớ để cấp phát đến các tiến trình đang đòi hỏi vùng nhớ ? $\to$ memory allocation (cấp phát vùng nhớ để các tiến trình có không gian để xử lý các tác vụ) $\ne$ memory deallocation (thu hồi vùng nhớ khi các tiến trình đã xử lý xong các tác vụ) ::: * In a multiprogramming system, many programs to be executed (i.e, process) are resident in memory simultaneously. * OS deals with: * **Memory allocation, deallocation, and process (against invalid access)** $\to$ bảo vệ vùng nhớ cho các tiến trình và cho chính bản thân hệ điều hành (vì hệ điều hành cũng chính là một chương trình hệ thống cần được nạp vào vùng nhớ để thực thi chương trình (tiến trình hệ thống) $\to$ tạo nền tảng cho các chương trình khác thực thi)) $\implies$ Vấn đề (1) đặt ra là làm sao hệ điều hành biết được chỗ nào còn trống để hệ điều hành cấp phát vùng nhớ ? $\to$ Hệ điều hành phải xử lý vấn đề này. $\implies$ Vấn đề (2) đặt ra là nếu tiến trình A được cấp phát vùng nhớ A~1~ bởi hệ điều hành thì mặc nhiên, tiến trình B sẽ không được cấp phát vùng nhớ A~1~ được. Và tiến trình B không thể tùy tiện can thiệp vào vùng nhớ A~1~ đã được cấp phát cho tiến trình A. * **Virtual memory management** - `quản lý bộ nhớ ảo`: Bộ nhớ thật (physical memory / main memory / RAM) là bộ nhớ / tài nguyên RAM thật sự trong máy tính $\to$ kích thước và giới hạn tài nguyên cố định $\to$ không thể đáp ứng đủ hết tất cả các nhu cầu cho người dùng hay nếu bộ nhớ có thể đáp ứng đủ nhu cầu của người dùng thì nếu tất cả các tiến trình được thực thi cùng một lúc thì bộ nhớ cũng không thể đủ không gian để chứa hết tất cả tiến trình (một số giới hạn tiến trình) $\to$ cần phải mở rộng kích thước bộ nhớ chính $\to$ nhằm tăng số lượng tiến trình có thể thực thi theo nhu cầu của người dùng. Chính vì vậy, hầu hết hệ điều hành sẽ hỗ trợ cơ chế bộ nhớ ảo $\to$ hệ điều hành sẽ tìm một phân vùng mở rộng nào đó (làm không gian lưu các tiến trình đang trong quá trình để CPU xử lý $\to$ khi cần xử lý tiến trình đang cần thực thi thì CPU sẽ tìm kiếm tiến trình trong phân vùng đó, các phần tiến trình quan trọng thì sẽ được đặt vào bộ nhớ chính) để bộ nhớ chính mở rộng $\to$ phân vùng mở rộng đó sẽ được đặt vào ổ đĩa (một phần đặc biệt của ổ đĩa làm phân vùng mở rộng của bộ nhớ chính) $\to$ chỉ có hệ thống mới được quyền truy cập phân vùng đó $\to$ khi cần truy xuất đến dữ liệu thì nó sẽ nhanh hơn so với việc truy xuất toàn bộ dữ liệu ổ đĩa $\to$ tốc độ truy xuất phân vùn đặc biệt trong ổ đĩa cũng không thể nào nhanh hơn việc truy xuất dữ liệu trong bộ nhớ chính của hệ thống. Mục tiêu là chứa những phần của tiến trình đang được thực thi nhưng đó là những phần CPU chưa cần xử lý đến (tiến trình sẽ không được toàn bộ vào RAM, chỉ những phần cốt lõi, những phần mà CPU đang xử lý quan trọng thì mới nạp vào RAM, những phần còn lại thì được đẩy vào phân vùng mở rộng nằm trong ổ đĩa) $\to$ chứa được nhiều tiến trình đang thực thi hơn. $\implies$ Nếu CPU xử lý đến phần lệnh hay dữ liệu nào của tiến trình P~1~ đang nằm trong phân vùng mở rộng của ổ đĩa (không để trong bộ nhớ chính RAM) $\to$ CPU không thể ra đó lấy được $\to$ lúc này, hệ thống sẽ phát sinh dấu hiệu / lỗi để hệ điều hành / phần cứng biết xử lý (phải lấy dữ liệu trong phân vùng mở rộng của ổ đĩa $\to$ nạp vào bộ nhớ chính vì CPU đang cần xử lý). $\implies$ Nếu bộ nhớ chính bị đầy không gian thì chúng ta sẽ không thể nạp dữ liệu vào trong bộ nhớ chính nữa $\to$ cần nhu cầu để thay phần tiến trình đang xử lý mà bị đầy dữ liệu đó đẩy ra vùng nhớ phụ để đẩy phần tiến trình quan trọng hơn đang cần CPU xử lý vào phần vùng chính (SWAP IN SWAP OUT) $\to$ nhằm mở rộng vùng nhớ đang xử lý tiến trình. * To have more space ... * Programs loaded into memory partially ... #### 3. File & Disk Management - `quản lý tập tin và ổ đĩa` * A file is an abstract concept (about sector of disk) provided by OS to store collection of data on disk. * OS deal with: * File organization. * File allocation / deallocation. * File storage on disk. #### 4. I/O Management - `quản lý hệ thống nhập / xuất` * OS acts as an intermediary between I/O request and physical devices (e.g, mouse, keyboard, screen, printer) * OS deal with * I/O hardware communication (e.g, device controller (bộ điều khiển thiết bị $\to$ quy định những thao tác cho phép những thiết bị bên ngoài giao tiếp đến thiết bị của nhà sản xuất đó), DMA, polling, interrupt I/O) (thường là liên quan đến những vi mạch mà nhà sản xuất gắn trực tiếp đến thiết bị ngoại vi đó) * I/O software, which allows accessing and managing I/O operations (e.g, device driver (trình điều khiển thiết bị $\to$ những đoạn code để giúp hệ điều hành giao tiếp, thao tác với các thiết bị ngoại vi), interrupt handler). #### 5. System Calls - `lời gọi hệ thống` * (System) Programming Interface (giao diện lập trình hệ thống: giao diện cung cấp hàm hệ thống bởi hệ điều hành) * Provided by OS to facilitate (đơn giản hóa) application programming * Win32 API for Windows * POSIX API for UNIX (C / C++), Linux (C / C++), and Mac OS * Java API for JVM * Mostly called programs via Application Programming Interface (API) (giao diện lập trình ứng dụng, bởi vì hàm hệ thống cấp thấp thường rất khó sử dụng $\to$ lập trình viên thường rất thích sử dụng API hơn $\to$ trực tiếp fork() đến các hàm xử lý bên dưới hệ thống $\to$ các hàm nãy sẽ thao tác trực tiếp đến computer hardware), i.e, utilities provided by programming language. * User mode vs. Kernel mode * User mode: là mode của người dùng, là nơi mà những chương trình ứng dụng được chạy tách biệt với mode của hệ điều hành chạy (kernel mode) $\implies$ nhằm đảm bảo an toàn cho hệ thống vì các chương trình ứng dụng không có quyền thao tác xử lý trực tiếp đến computer hardware bên dưới hệ thống. Đồng thời nhằm đơn giản hóa thao tác xử lý cho người dùng / lập trình viên. * Kernel mode: là mode của hệ điều hành, khi chúng ta đang thao tác ở trong kernel mode thì chúng ta có thể thao tác đến tất cả phần cứng bên dưới thông qua device controllers. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/415513087_713356544263784_7131998784507751414_n.png?_nc_cat=109&ccb=1-7&_nc_sid=5f2048&_nc_ohc=cUkbMBR6mMgAb7wp2JJ&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHbrPs6ssrwvHSS1WYandvuRip_FPCtHAbyRRSDdOjfag&oe=664A102E> </center> * System Calls Examples <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/434769178_424525763512049_2167408300539865411_n.png?_nc_cat=105&ccb=1-7&_nc_sid=5f2048&_nc_ohc=AyT_YzEVAaEAb6VgM2D&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QEHLzIzA2ZOmp9wr8D0AtBQtWUCcDhLTlLQ0gFa4OBmLw&oe=664A1C1E> </center> #### 6. SHELL or Command Interpreter - `hệ thống cơ chế dòng lệnh` * Text-based interface for interacting with the operating system. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427843996_1458451928352130_6206038904871611358_n.png?_nc_cat=100&ccb=1-7&_nc_sid=5f2048&_nc_ohc=UR-68rZD6ZUAb78evwS&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGHWw-O5aNtHYX-qWTfOLK4opptIifu6dpa5EmjPnNKgQ&oe=664A2E11> </center> #### 7. Protection and Security - `hệ thống bảo vệ và bảo mật` * Computer resources (e.g, files, software, hardware) must be protected against insecure access. * Users / programs must have the right to manipulate system objects (e.g, files) or system components (software, hardware). ### IV. Operating System Structure #### 1. Simple Structure - `kiến trúc đơn giản` * Definition: * OS components are not well separated (e.g, MS-DOS) $\to$ hệ điều hành thô sơ, đơn giản đầu tiên sử dụng kiểu kiến trúc này. * Application programs can access computer hardware directly. * Advantages: * Simple and easy to extend. * Disadvantages: * Vulnerable * What if an application program fails ? $\implies$ Hệ điều hành không có cơ chế bảo vệ. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426808583_2695984060556811_3938728721760309183_n.png?_nc_cat=108&ccb=1-7&_nc_sid=5f2048&_nc_ohc=wAEcCdMDCqYAb7rpruh&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QFmIMhd7B81jV5byT94MX7WBcbObf1AZgJT1y_U_thjGw&oe=664A0841> </center> #### 2. Monolithic Structure - `kiến trúc một khối` * Definition: * OS components are combined into one single module (e.g, traditional UNIX systems) * Each procedure (function) can call any other procedures. * Advantages: * Simple and fast. * Disadvantages: * Difficult to implement and maintain. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427887837_7231886050214267_6095871350957531150_n.png?_nc_cat=100&ccb=1-7&_nc_sid=5f2048&_nc_ohc=sq1PN4awurQAb43f8r7&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHwKLiSaauJ5Yt5BEX_iKTpxUBkCo6nvBaW--95b2Aa5g&oe=664A1DE9> </center> #### 3. Layered Structure - `kiến trúc phân tầng` * Definition: * OS components are structured into layers (e.g, MULTICS) * Each layer uses services (operations, functions) prepared by its lower adjacent layer. * layer N calls services defined in layer N - 1 (layer 0 is hardware components) * Advantages: * Easier to implement and maintain than monolithic structure. * Disadvantages: * How to group services into layers ? based on functionality ? $\to$ làm sao chia layers, services nào chia vào layers nào ? (nguyên tắc: layer cao hơn chỉ gọi dịch vụ của layer thấp hơn chứ không có trường hợp ngược lại) $\to$ nếu layer N gọi dịch vụ layer (N - 1) nhưng do trong quá trình thiết kế thì phát hiện ra layer (N - 1) lại cần gọi services của layer N $\to$ phải chia phân lớp sao cho phù hợp * When invoking a system call, a user program may need to pass through many layers ? $\to$ efficiency ? $\to$ khi người dùng muốn gọi services ở layer càng thấp thì quá trình thực thi càng cao (do chương trình phải qua nhiều tầng layers) $\to$ hiệu suất không cao về mặt thời gian và truy xuất dữ liệu. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427805537_660920382728462_6015005175182559586_n.png?_nc_cat=104&ccb=1-7&_nc_sid=5f2048&_nc_ohc=c6zjbLHFUwsAb4Q9dHc&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QEcYd5RDwNmKWU-Us6DNXkONVTtDbh5HatB02PV_brmkw&oe=6649FF41> </center> #### 4. Module Structure - `kiến trúc module` * Definition: * A system consists of core kernel and additional services implemented as modules linked dynamically (e.g, Solaris). * Advantages: * Easier to add new service than modify the kernel $\to$ easy to extend. * Security $\to$ ít services nằm trong core kernel $\to$ services can not interact with computer hardware $\to$ đảm bảo tính không hư hại cho phần cứng máy tính. * Disadvantages: * Not a clear design $\to$ không có layer rõ ràng, kernel không đủ nhỏ, cấu trúc rời rạc, ... <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427845767_1056276678934206_1053787945328430084_n.png?_nc_cat=101&ccb=1-7&_nc_sid=5f2048&_nc_ohc=9DdbvKRLW7oAb4FbfQf&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGCS5f_jOClPE680qc7t6CECinmnrM2WYm2mpLlE-DDeg&oe=664A1320> </center> #### 5. Microkernel Structure - `kiến trúc vi nhân` * Definition: * **++Kernel++** only stores **++essential components++** of OS (e.g, Mach). * Other components are implemented as **++user programs++** $\to$ runs on **++user mode++** (not kernel mode). * Advantages: * Easy to manage, extend and build new architecture. * Security and Reliability. * Disadvantages: * Performance problem occasionally $\to$ Kernel nhỏ $\to$ trình server quản lý, xử lý các dịch vụ người dùng cung cấp hạn chế (vì ở kernel chỉ xử lý được giới hạn dịch vụ người dùng) $\to$ trình xử phải qua nhiều chương trình ở user mode $\to$ user mode gửi nhiều messages cho server xử lý $\to$ truy xuất dữ liệu và thời gian không tối ưu vì mỗi lần muốn gọi dịch vụ nào thì đều phải gọi lệnh lần lượt qua core kernel rồi mới tới user program (có khi phải qua hàng chục user programs) $\to$ xử lý quá tải dịch vụ người dùng $\to$ treo máy, lag, hư kernel ở server, ... <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427971757_1074058537182033_3280868668078137755_n.png?_nc_cat=105&ccb=1-7&_nc_sid=5f2048&_nc_ohc=VnymSomMq-sAb49lO-B&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHl9eHMODkpD6MbjKisW8AstXho5vZOcULJcORi6Xdb1A&oe=664A33FC> </center> #### 6. Hybrid Structure - `kiến trúc lai` * Defition: * A combination of various structures to address performance, security and usability. * Common design in many modern OS (e.g, Linux, Mac OS X, Windows, Android) <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426819119_249053148248975_3980384649500168848_n.png?_nc_cat=111&ccb=1-7&_nc_sid=5f2048&_nc_ohc=n-vXcoWYYugAb4j_HXa&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHvrgwEJmJkSqlXftRokniEpG9MduuzZzo49Cy6Eb3mCQ&oe=664A2C22> </center> #### 7. And other ... <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426833031_1382104285759818_6483074389456205644_n.png?_nc_cat=107&ccb=1-7&_nc_sid=5f2048&_nc_ohc=x0Ey1SxPUCMAb5zCm4W&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGs0RhXPzBPNaq3ZWoylIRrrKpFRGNKzYX4WIy2S-o0sg&oe=664A246F> </center> <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427849755_6672840169487081_7192834224063360901_n.png?_nc_cat=106&ccb=1-7&_nc_sid=5f2048&_nc_ohc=mJanVAMBNWYAb4txITP&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QE7Q7KE7KoJdQ3V93UNWw1wxe2l-hZc2QP13uzP4-KQHA&oe=664A2E10> </center> :::info REVIEW QUESTION 1. What is booting ? Summarize booting procedure ? Answer :::spoiler ::: ::: --- ## :pushpin: Chapter :two: : Process & IPC ### I. Process concepts :::info Tiến trình là một chương trình đang xử lý, mỗi tiến trình có một không gian địa chỉ, một con trỏ lệnh, một tập thanh ghi và stack riêng. Tiến trình có thể cần đến một số tài nguyên như CPU, bộ nhớ chính, các tập tin và thiết bị nhập/xuất. Hệ điều hành sử dụng bộ điều phối (scheduler) để quyết định thời điểm cần dừng hoạt động của tiến trình đang xử lý và lựa chọn tiến trình tiếp theo cần thực hiện. Trong hệ thống có những tiến trình của hệ điều hành và tiến trình của người dùng. Mục đích cho nhiều tiến trình hoạt động đồng thời: * **++Tăng hiệu suất sử dụng CPU (tăng mức độ đa chương)++** Phần lớn các tiến trình khi thi hành đều trải qua nhiều chu kỳ xử lý (sử dụng CPU) và chu kỳ nhập xuất (sử dụng các thiết bị nhập xuất) xen kẽ như sau: | CPU | IO | CPU | IO | CPU | |:---:|:---:|:---:|:---:|:---:| Nếu chỉ có một tiến trình duy nhất trong hệ thống, thì các chu kỳ IO của tiến trình, CPU sẽ hoàn toàn nhàn rỗi. Ý tưởng tăng cường số lượng tiến trình trong hệ thống là để tận dụng CPU: nếu tiến trình 1 xử lý IO, thì hệ điều hành có thể sử dụng CPU để thực hiện tiến trình 2... * Tiến trình 1: | CPU | IO | CPU | IO | CPU | |:---:|:---:|:---:|:---:|:---:| * Tiến trình 2: | -------- | CPU | IO | CPU | IO | |:--------:|:---:|:---:|:---:|:---:| * **++Tăng mức độ đa nhiệm++** Cho mỗi tiến trình thực thi luân phiên trong một thời gian rất ngắn, tạo cảm giác là hệ thống có nhiều tiến trình thực thi đồng thời. <center> <img src = https://scontent.fsgn2-9.fna.fbcdn.net/v/t1.15752-9/431610069_378049488353010_3320312305210618354_n.png?_nc_cat=103&ccb=1-7&_nc_sid=5f2048&_nc_ohc=SIR7v_Z8nr0Ab5Fmj8Z&_nc_ht=scontent.fsgn2-9.fna&oh=03_Q7cD1QH_UhxcRMi2HRNPbo-KKWAUqqcvsrPhCjwgJbPBjWlGBg&oe=664A1BF1> </center> * **++Tăng tốc độ xử lý++** Một số bài toán có thể xử lý song song nếu được xây dựng thành nhiều đơn thể hoạt động đồng thời thì sẽ tiết kiệm được thời gian xử lý. Ví dụ xét bài toán tính giá trị biểu thức kq = a\*b + c\*d . Nếu tiến hành tính đồng thời (a\*b) và (c\*d) thì thời gian xử lý sẽ ngắn hơn là thực hiện tuần tự. ::: * Process vs. Program (Tiến trình và chương trình) * Program - `chương trình`: khái niệm này xuất hiện vào thời kỳ có hệ điều hành đa chương (multiprogramming system) $\to$ là một tập hợp những dòng lệnh được viết bằng ngôn ngữ lập trình cấp cao (gọi là source code) $\to$ những dòng code này ở dạng tĩnh (không phải dạng động vì nó chỉ là dạng động khi và chỉ khi những dòng lệnh này được nạp vào bộ nhớ một cách tự động, có trạng thái hoạt động, thực thi và diễn ra) $\to$ chương trình là một thực thể tĩnh (static entity). Quy trình của chương trình: đầu tiên thì chương trình ở dạng source code (viết bằng editor $\to$ tuân thủ cấu trúc syntax của ngôn ngữ lập trình đó) $\to$ source code sẽ được biên dịch bằng các trình biên dịch tương ứng $\to$ object code là code sau khi đã đúng hết về mặt cú pháp của ngôn ngữ đó mà trình biên dịch có thể hiểu được $\to$ object code sẽ được thông qua Linker (thông thường sẽ được tích hợp trong compiler) để liên kết đến các thư viện để thực thi $\to$ excutable code (`mã thực thi`) là một file mã nhị phân có thể được load vào bộ nhớ để thực thi. * Process - `tiến trình`: xảy ra khi file nhị phân (excutable code) được nạp vào trong bộ nhớ, được sở hữu tài nguyên, cấp phát tài nguyên chuyển sang thể động $\to$ process là một thể động (dynamic entity) $\to$ process là một chương trình đang trong quá trình thực thi (còn thêm những tài nguyên đính kèm (file nhị phân, ...) để nó thực thi). * Ví dụ thực tế: một người nội trợ đang muốn làm món ăn cho gia đình mà họ không biết công thức thì họ cần phải xem quyển sách dạy nấu ăn, rồi họ mới mua trứng, đường, sữa, muối, ... để làm ra món ăn $\to$ người nội trợ được xem là một CPU đang thực thi chương trình $\to$ quyển sách dạy nấu ăn chính là chương trình (vì nó ghi công thức ở dạng tĩnh, tức là những hướng dẫn, ghi chú chỉ được ghi trong sách chứ không thể hành động thực hiện món ăn) $\to$ trứng, đường, sữa, muối, ... chính là những nguyên liệu (resource) hay tài nguyên để CPU thực thi chương trình. $\to$ hành động hay quá trình để người nội trợ làm ra món ăn đó (như khuấy trứng, chiên cá, luộc rau, xào nấu, ...) thì được xem là tiến trình cùng với tài nguyên có sẵn để thực thi chương trình $\to$ dạng động. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427877618_785102923662779_8993169899332865473_n.png?_nc_cat=111&ccb=1-7&_nc_sid=5f2048&_nc_ohc=MBIYdK2T-bIAb5s1Tjm&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QEQGNCQJUqtbxova_E8YycHsVt1BRuKs9aTaG8TgrfV5A&oe=664A2E70> </center> * Phân loại tiến trình: có hai loại * Tiến trình tuần tự: là các tiến trình mà điểm khởi tạo của nó là điểm kết thúc của tiến trình trước đó. * Tiến trình song song: là các tiến trình mà điểm khởi tạo của tiến trình này nằm ở thân của các tiến trình khác, tức là có thể khởi tạo một tiến trình mới khi các tiến trình trước đó chưa kết thúc. * **Tiến trình song song độc lập:** các tiến trình hoạt động song song nhưng không có quan hệ thông tin với nhau, trong trường hợp này hệ điều hành phải thiết lập cơ chế bảo vệ dữ liệu của các tiến trình, và cấp phát tài nguyên cho các tiến trình một cách hợp lý. * **Tiến trình song song có quan hệ thông tin:** trong quá trình hoạt động các tiến trình trao đổi thông tin với nhau. Hai tiến trình A và B được gọi là có quan hệ thông tin với nhau nếu tiến trình này có gửi thông báo cho tiến trình kia. Tiến trình gửi thông báo có thể không cần biết tiến trình nhận có tồn tại hay không? ở đâu? và đang ở giai đoạn nào? * **Tiến trình song song phân cấp:** trong qua trình hoạt động một tiến trình có thể khởi tạo các tiến trình khác hoạt động song song với nó, tiến trình khởi tạo được gọi là tiến trình cha, tiến trình được tạo gọi là tiến trình con. Trong mô hình này hệ điều hành phải giải quyết vấn đề cấp phát tài nguyên cho các tiến trình con. Tiến trình con nhận tài nguyên ở đâu? từ tiến trình cha hay từ hệ thống. * **Tiến trình song song đồng mức:** là các tiến trình hoạt động song song sử dụng chung tài nguyên theo nguyên tắc lần lượt, mỗi tiến trình sau một khoảng thời gian chiếm giữ tài nguyên phải tự động trả lại tài nguyên cho tiến trình kia. ### II. Process features #### 1. Process state - `trạng thái của tiến trình` :::info Việc chuyển trạng thái của tiến trình là do bộ điều phối (scheduler) thực hiện và tại một thời điểm, tiến trình có thể nhận một trong các trạng thái sau đây : 1. **New:** tiến trình mới được tạo đang ở trong bộ nhớ tạm trên đĩa cứng. 2. **Ready:** tiến trình trong bộ nhớ và chờ được cấp phát CPU. 3. **Running:** tiến trình trong bộ nhớ đang thực thi. 4. **Blocked (wait):** tiến trình trong bộ nhớ chờ được cấp phát tài nguyên, hoặc chờ thao tác nhập/xuất hoàn tất hoặc chờ một sự kiện nào đó. 5. **Exit (End):** tiến trình trong bộ nhớ hoàn tất xử lý. ::: * (1) Sau khi file nhị phân (executable code - mã nhị phân) được load vào bộ nhớ (tức là HĐH sẽ cấp phát tài nguyên, vùng nhớ để biến excutable code đó thành một tiến trình mới, đồng thời HĐH cũng sẽ có một cấu trình dữ liệu để quản lý khối tiến trình được tạo thành) thì nó sẽ được xem như là một tiến trình mới ở trạng thái NEW (lưu ý rằng: ngay tại thời điểm đó có thể có rất nhiều executable code được load cùng lúc vào memory $\to$ có rất nhiều tiến trình đang ở trạng thái NEW trong bộ nhớ) $\implies$ (1) NEW * (2) Khi các tiến trình NEW đang ở trạng thái READY (sẵn sàng để được thực thi) thì các tiến trình này sẽ được đẩy vào một Ready List / Queue của hệ thống (hàng đợi / danh sách các tiến trình sẵn sàng để CPU được thực thi) (lý do để đẩy các tiến trình vào hàng đợi: trong hệ thống Timesharing OS $\to$ bộ nhớ có nhiều tiến trình khác nhau $\to$ CPU sẽ luân phiên thực thi các tiến trình với nhau và CPU không có quyền quyết định tiến trình nào sẽ được thực thi trước mà do HĐH quyết định CPU sẽ thực thi tiến trình nào, luân phiên làm sao, cho dù tiến trình đó có đủ điều kiện về tài nguyên, vùng nhớ, ... để được thực thi $\to$ bắt buộc lúc này tiến trình đó phải vào hàng đợi để chờ CPU thực thi $\to$ lúc này tiến trình sẽ đang ở trong trạng thái Stack Ready (sẵn sàng để được thực thi nhưng chưa được bàn giao cho CPU để thực thi)) $\implies$ (1) NEW $\to$ (2) Ready (Ready List / Queue) * (3) Lúc này, nếu tiến trình trong trạng thái Stack Ready nằm trong Ready List / Queue đã được bàn giao cho CPU (CPU available) để thực thi tiến trình $\to$ tiến trình sẽ chuyển sang trạng thái mới là Running (đang được thực thi) $\implies$ (1) NEW $\to$ (2) Ready (Ready List / Queue) $\to$ (3) Running (CPU available) * (4) Sau bước (3) thì tiến trình sẽ có các hướng đi sau: * (4.1) Nếu tiến trình đang thực thi dang dở bởi CPU nhưng vẫn đủ điều kiện về tài nguyên, sự kiện, vùng nhớ, ... * Trong hệ thống TimeSharing OS, tiến trình đang trong trạng thái Running sẽ có thể không được CPU thực thi nữa dù tiến trình đó chưa hoàn thành xong (vì CPU sẽ luân phiên thực thi các tiến trình theo nhu cầu của HĐH sắp đặt) thì HĐH sẽ thu hồi lại CPU $\to$ lúc này, các tiến trình đang được thực thi dang dở bởi CPU sẽ được đẩy ngược lại vào hàng đợi Ready List / Queue $\to$ tiến trình sẽ trở lại trạng thái Stack Ready. (hay nói cách khác, tiến trình tạm dừng vì hết thời gian sử dụng CPU, scheduler sẽ chọn một tiến trình khác để xử lý, khi đó tiến trình được chuyển từ trạng thái Running sang Ready) $\implies$ (1) NEW $\to$ (2) Ready (Ready List / Queue) $\to$ (3) Running (CPU available) $\to$ (4.1) Ready (Ready List / Queue $\to$ Wait for CPU) * (4.2) Nếu tiến trình đang thực thi dang dở bởi CPU nhưng chưa đủ điều kiện về tài nguyên, sự kiện, vùng nhớ, ... * (4.2.1) Trạng thái Blocked: là trạng thái tiến trình không thể vào trạng thái Ready mà bị vào trạng thái Blocked do tiến trình phải chờ đợi một sự kiện gì đó (e.g, sự kiện nhập xuất I/O devices, ...) diễn ra hay các tài nguyên khác (e.g, thiếu vùng nhớ, ...) (không phải là CPU), tức là tiến trình đang bị thiếu tài nguyên, sự kiện, ... không thể nào trong trạng thái Stack Ready (sẵn sàng thực thi mà chưa được bàn giao CPU thực thi) sẽ bị chặn trong một hàng đợi chờ đợi về sự kiện hay tài nguyên nào đó ((I / O) Waiting List / Queue). $\implies$ (1) NEW $\to$ (2) Ready (Ready List / Queue) $\to$ (3) Running (CPU available) $\to$ (4.2.1) Blocked ((I/O) Waiting List / Queue $\to$ Wait for events or other resources (not CPU)) * (4.2.2) Nếu lúc này tiến trình đáp ứng đủ về tài nguyên có sẵn hay sự kiện đã tới $\to$ tiến trình sẽ được đẩy vào Ready List / Queue $\to$ tiến trình sẽ ở trong trạng thái Stack Ready (sẵn sàng thực thi và chờ CPU thực thi). $\implies$ (1) NEW $\to$ (2) Ready (Ready List / Queue) $\to$ (3) Running (CPU available) $\to$ (4.2.1) Blocked ((I/O) Waiting List / Queue $\to$ Wait for events or other resources (not CPU)) $\to$ (4.2.2) Ready (Ready List / Queue) * (5) Nếu tiến trình thực thi xong hết 4 bước trên, tiến trình sẽ được xem như là thực thi xong hết toàn bộ và giải phóng tài nguyên, vùng nhớ, ... $\to$ tiến trình sẽ ở trạng thái EXIT. $\implies$ (1) NEW $\to$ (2) Ready (Ready List / Queue) $\to$ (3) Running (CPU available) ($\to$ (4) : có thể có hoặc không) $\to$ (5) Exit <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/428013205_7106018862815846_2095334595395982592_n.png?_nc_cat=111&ccb=1-7&_nc_sid=5f2048&_nc_ohc=bwVSqby6yBkAb5t6-0b&_nc_oc=AdgkHm8g1mcL7Vlxv2sxEWNnVR4dm6o_JLoT1GlWF7ZGxxd8jI7DfXtKsf29AcXiaPgZtNv_IAbvhthcLCQku0HT&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGjpWu47IBVacjk2gjfXktUhZrcRQ9L_A7Y5VHo70LMJQ&oe=664A260C> </center> :::info * Question: Liệu tiến trình có thể từ một trạng thái Blocked trực tiếp qua trạng thái Running mà không cần phải qua lại trạng thái Ready được không ? * Answer: :::spoiler $\implies$ Không thể. Vì cho dù tiến trình đó có đủ điều kiện về sự kiện, tài nguyên, vùng nhớ, ... sau khi giải quyết vấn đề trạng thái Blocked thì tiến trình đó vẫn phải chịu sự điều phối của HĐH quyết định rằng tiến trình đó sẽ được CPU thực thi lúc nào ? (vì lúc này có khi CPU (mỗi máy chỉ có một CPU) đang thực thi cho tiến trình khác và tiến trình đó không thể nào can thiệp để giành lại CPU cho mình để thực thi) hay nói cách khác tiến trình đó vẫn phải vào hạng đợi và trong trạng thái Stack Ready (sẵn sàng thực thi nhưng chưa đủ điều kiện thực thi) để chờ CPU thực thi. ::: ::: #### 2. Process address space - `không gian địa chỉ của tiến trình` * Khi một chương trình được nạp vào bộ nhớ biến thành một tiến trình (phiên bản động của chương trình trong bộ nhớ đó), không gian của tiến trình hệ thống (tiến trình của HĐH tạo nền tảng cho các tiến trình chương trình khác) sẽ được nạp vào không gian bộ nhớ đầu tiên (OS), sau đó là các tiến trình của chương trình khác (P~1~, P~2~, ...). * Không gian vùng nhớ xử lý (Process address space) của các tiến trình được nạp vào bộ nhớ sẽ có cấu tạo sau đây: * Stack: stores function parameters, return values and local variables allocated automatically as a process loaded into memory $\to$ biến cấp phát tĩnh bởi HĐH. * [...] : đây là phân vùng trống hay phân vùng không liền nhau giữa vùng Stack và vùng Heap do hai vùng này sẽ tăng giảm kích thước trong quá trình thực thi $\to$ tránh khả năng đụng độ giữa hai vùng. * Heap: variables allocated **dynamically** during process run time (e.g, objects, pointers) $\to$ biến cấp phát động (không biết trước kích thước vùng nhớ) được cấp phát trong quá trình process running. * Data: global (and / or static) variables. * Text: program code (i.e, set of instructions) in binary form. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/428009112_1083684062872909_8095892206065746357_n.png?_nc_cat=111&ccb=1-7&_nc_sid=5f2048&_nc_ohc=DrMOhJcavPgAb7eZz2S&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHjd4GRpHaOCSnLHWCVVHaXFo7F36M658c89NQAptTw4w&oe=664A3513> </center> * Examples: <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427894486_1440840626840832_1735856289032623782_n.png?_nc_cat=104&ccb=1-7&_nc_sid=5f2048&_nc_ohc=0tzJm-ga5QUAb6FolmS&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHHjumNTIRpxswYsC-SBFAt4OmOB7FIW7ByeRZ8VoBCEg&oe=664A1A9C> </center> #### 3. Process Control Block (PCB) - `khối quản lý tiến trình` * Specific data structure * Contains process information. * Located in OS address space and accessible only in kernel mode. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426836676_730602485495224_6551676309416711255_n.png?_nc_cat=103&ccb=1-7&_nc_sid=5f2048&_nc_ohc=tBWusiHp3mIAb6RKmXG&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QH49HhFzw105ekiEu5UFJLhC1OWsk1h49K7fbJDD20e5g&oe=664A2D3C> </center> * Trong một hệ thống đa chương Timesharing OS, có quá nhiều tiến trình nằm trong vùng nhớ, làm sao hệ điều hành có thể quản lý tất cả tiến trình này? $\implies$ Mỗi tiến trình sau khi được tạo thành thì nó sẽ được cấp một khối quản lý tiến trình được lưu trong Process Table (bảng quản lý tiến trình) trong process address space phân vùng OS, chỉ có các dịch vụ hệ thống chạy ở mode kernel mới truy cập và quản lý vào bảng tiến trình này. $\implies$ Trong Process Table, tìm thấy được ứng với mỗi tiến trình thì sẽ có một PCB (Process Control Block) tương ứng dành cho tiến trình đó để quản lý khối tiến trình đó (e.g, tiến trình P~3~ sẽ có một khối quản lý tiến trình PCB3). $\implies$ Trong Process Table, mỗi khối quản lý tiến trình (Process Control Block) sẽ có thông tin cần thiết thực thi và tái thực thi cho tiến trình đó. Có thể đối với mỗi hệ thống khác nhau, mỗi khối quản lý tiến trình sẽ có cấu trúc khác nhau. Cho dù tên hay cấu trúc của khối quản lý tiến trình khác nhau đối với những hệ thống khác nhau như thế nào, chúng đều phải có những trường thông tin cơ bản sau: * **Process Identifier (PID) - `mã định danh tiến trình`**: A unique number (at a time t) to identifier a process $\to$ mỗi tiến trình được định danh bởi một con số nguyên $> 0$ do hệ thống cung cấp cho tiến trình đó tại một thời điểm (phải cung cấp tại một thời điểm vì giả sử chúng ta tắt máy, tắt hệ thống xử lý rồi khởi động lại $\to$ tiến trình đó bị huy $\to$ khi khởi động lại thì một tiến trình khác có thể có id trùng lại so với id lúc trước của tiến trình đó) để phân biệt tiến trình đó với những tiến trình khác trong hệ thống. * **Process State - `trạng thái hiện trại của tiến trình`**: Current state of the process (running, ready, blocked). * **Program Counter - `bộ đếm chương trình`**: Indicate the address of the next instruction to be executed $\to$ liên quan đến lệnh được thực thi hay sắp được thực thi (trỏ đến địa chỉ của lệnh kế tiếp để thực thi) $\to$ nhằm tái thực thi tiến trình (xác định địa chỉ tiếp theo để tiến trình đó có thể tái thực thi tiếp). * **CPU Registers - `thanh ghi CPU`**: Information for reloading the process correctly $\to$ thanh ghi lưu lại trạng thái của tiến trình trước khi kết thúc. * **CPU Scheduling Information - `độ điều phối CPU`**: Process priority, pointers to scheduling queues, ... * **Memory Management Information - `quản lý bộ nhớ`**: Information for locating the process in memory. * **Accounting Information - `thông tin thống kê`**: Information for statistics and system performance. * **I / O Status Information - `thông tin trạng thái I / O`**: Information about I / O devices, files, ... allocated to the process. #### 4. Context Switch - `chuyển đổi ngữ cảnh giữa hai tiến trình khác nhau` :::info Ngữ cảnh tiến trình được lưu trong PCB (Process Control Block) của từng tiến trình: mô tả các tài nguyên tiên trình đang sử dụng, dùng để phục vụ cho hoạt động hiện tại, hoặc để làm cơ sở phục hồi hoạt động cho tiến trình. Ngữ cảnh tiến trình bao gồm các thông tin sau: - Trạng thái CPU: bao gồm nội dung các thanh ghi, quan trọng nhất là con trỏ lệnh IP lưu trữ địa chỉ lệnh kế tiếp mà tiến trình sẽ thực hiện. Các thông tin này cần được lưu trữ khi xảy ra một ngắt, nhằm có thể cho phép phục hồi hoạt động của tiến trình đúng như trước khi bị ngắt. - Số hiệu bộ xử lý: xác định số hiệu CPU mà tiến trình đang sử dụng. - Bộ nhớ chính: danh sách các khối nhớ được cấp cho tiến trình. - Tài nguyên sử dụng: danh sách các tài nguyên hệ thống mà tiến trình đang sử dụng. - Tài nguyên tạo lập: danh sách các tài nguyên được tiến trình tạo lập. ::: * Trong hệ thống TimeSharing OS, CPU không thể được giao cho một process để thực thi process đó xuyên suốt $\to$ CPU phải luân phiên thực thi giữa các tiến trình khác nhau trong hệ thống $\to$ HĐH phải điều phối lấy lại CPU đang thực thi tiến trình đó cho tiến trình khác đang cần được ưu tiên thực thi $\to$ cần phải có bước chuyển đổi ngữ cảnh giữa tiến trình đang thực thi và tiến trình sắp được thực thi (điều kiện phải xảy ra trong một hệ thống TimeSharing OS vì CPU bắt buộc thực thi các tiến trình luân phiên). * Nguyên tắc chuyển đổi ngữ cảnh giữa process P~0~ và process P~1~: * Khi có interrupt hay system call nhằm lấy lại CPU thực thi process P~0~ $\to$ save state into PCB~0~ (lưu trạng thái ngữ cảnh của tiến trình P~0~ vào khối quản lý tiến trình PCB~0~) $\to$ reload state from PCB~1~ (nạp trạng thái ngữ cảnh của tiến trình P~1~ từ khối quản lý tiến trình PCB~1~ để CPU biết thực thi từ đâu) và tiếp tục quá trình này cho đến khi các tiến trình thực thi xong. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427963704_2625860474248395_2856042233787249323_n.png?_nc_cat=107&ccb=1-7&_nc_sid=5f2048&_nc_ohc=ZdfvO7oMKJwAb5ZB6M1&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QF173_WLvLCEBvn1mMfjLlky7TQynm4Worn5uGKzYpKRQ&oe=664A0025> </center> ### III. Process operations #### 1. Process creation - `tạo lập tiến trình` * Khi nào tiến trình sẽ được tạo lập hay để cần được thực thi ? $\to$ có 3 trường hợp của tiến trình * (1) Tiến trình hệ thống phải được thực thi $\to$ để tạo nền tảng cho các việc thực thi các tiến trình người dùng khác (tạo môi trường tiến trình). * (2) Khi chúng ta click nào biểu tượng (icon) của programs đó $\to$ users thực thi các tiến trình. * (3) Khi lập trình gọi tới các system calls hay infork đến system call của hệ thống $\to$ tạo nên tiến trình khác. * A parent process - `một tiến trình cha` create children processes - `nhiều tiến trình con`, which, in turn, may create their own children processes - `nhiều tiến trình con khác`. * System calls: fork (UNIX), CreateProcess (Windows). * A child process may: * be a **duplicate** of **its parent** (i.e, have some memory space with its parent). * load **another program** to execute. * System call: exec (UNIX) * When a new process is created: * It will be allocated **a process identifier (pid)** and **other resources**. * A **PCB - `process control block`** containing the information of new process will be created and placed in Process Table. * Examples: tạo tiến trình bằng hàm fork() trong UNIX. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427894480_805422211415490_468112053139821100_n.png?_nc_cat=103&ccb=1-7&_nc_sid=5f2048&_nc_ohc=jNViGU86KwAAb6r4KCD&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QE8fLrc2jnQeUlZ8IhteSggyVM-IF7XKQuEq2zOcD0THQ&oe=664A1A2C> </center> ```cpp!= #include <unistd.h> #include <stdio.h> main() { // pid = 20 --> pid of parent process int pid_t = fork(); // create child process --> pid_t = 21 // neu khong muon parent process and child process chay chung voi nhau --> dung if ... else ... if (pid_t == 0) { // child execution printf("%d is a child of parent %d", getpid(), getppid()); // getpid() -> print 21 20 || getpid() --> hàm lấy id của tiến trình gọi hàm này, getppid() --> hàm lấy id của tiến trình cha đang thực thi tiến trình đó. } else if (pid_t > 0) { // parent execution printf("Parent %d created a child %d", getpid(), pid_t); // getpid() -> print 20 21 || getpid() --> lấy id của tiến trình hiện tại là tiến trình cha 20, pid_t là id của tiến trình con. } else {error} // (pid_t < 0 --> error vì số lượng tiến trình đang tạo ra lớn hơn số lượng cho phép của hệ thống cho phép ...) } ``` * Process Tree - `cây tiến trình` * Trong quá trình xử lý, một tiến trình có thể tạo lập nhiều tiến trình mới bằng cách sử dụng một lời gọi hệ thống tương ứng. Tiến trình gọi lời gọi hệ thống để tạo tiến trình mới sẽ được gọi là tiến trình cha, tiến trình được tạo gọi là tiến trình con. Mỗi tiến trình con đến lượt nó lại có thể tạo các tiến trình mới... quá trình này tiếp tục sẽ tạo ra một cây tiến trình (trong Windows không có khái niệm cây tiến trình, mọi tiến trình là ngang cấp). Khi một tiến trình tạo lập một tiến trình con, tiến trình con có thể sẽ được hệ điều hành trực tiếp cấp phát tài nguyên hoặc được tiến trình cha cho thừa hưởng một số tài nguyên ban đầu. Khi tiến trình cha tạo tiến trình con, tiến trình cha có thể xử lý theo một trong hai khả năng sau: tiến trình cha tiếp tục xử lý đồng hành với tiến trình con, hoặc tiến trình cha chờ đến khi một tiến trình con nào đó, hoặc tất cả các tiến trình con kết thúc xử lý. Ví dụ: tiến trình A tạo hai tiến trình con B và C, B tạo ba tiến trình con D, E, F. <center><img src = https://scontent.fsgn2-11.fna.fbcdn.net/v/t1.15752-9/431552993_2154206264941264_3947985270328511166_n.png?_nc_cat=105&ccb=1-7&_nc_sid=5f2048&_nc_ohc=P-_4EhT3zgAAb4HLLoJ&_nc_oc=Adgy2GVF8ybMqAlmPVlwWoC2p6omYrfyrr3SeyApZGallOFptsctUjpd80j8CyTv6i0&_nc_ht=scontent.fsgn2-11.fna&oh=03_Q7cD1QEe96eM_LnqYlQddUVtDbvRcGHz6Woh9kLQn0V6BeM-aA&oe=664A40DD></center> ```cpp!= for (int i = 0; i < 3; i++){ fork(); } ``` $\implies$ không phân biệt tiến trình cha và tiến trình con, tiến trình cha tạo ra tiến trình nào thì tiến trình con cũng sẽ lặp lại y chang tiến trình đó. * Initial Process Tree: <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426833002_356851710500781_5564141169506011358_n.png?_nc_cat=100&ccb=1-7&_nc_sid=5f2048&_nc_ohc=1nwtebw16kIAb4wNyrd&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGnbVpxtZM6yiiHY_gxdLCTUigfRrOVB8rIqbPK5I09DQ&oe=664A1FDD> </center> * i = 0: <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/426886731_1348242865888784_4698282443661384251_n.png?_nc_cat=103&ccb=1-7&_nc_sid=5f2048&_nc_ohc=Kzu2iRTFLB8Ab4VnHVW&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHx5pl9GgpxYOSMXPm-Tgf966kWaQhKPPuDU9gVKP_OLw&oe=664A06BE> </center> * i = 1: <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/428142937_301645695899075_2408056056582711007_n.png?_nc_cat=103&ccb=1-7&_nc_sid=5f2048&_nc_ohc=-zX_PykHW74Ab5daWue&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHA_VkoRs1GkfnXsQT18y2ht3PhUGfEfE9gDdfj8H5ilQ&oe=664A2AED> </center> * i = 2: <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427899998_1110394316821809_6586077995832078158_n.png?_nc_cat=104&ccb=1-7&_nc_sid=5f2048&_nc_ohc=efvaXI6xnksAb7BtDF8&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QF9SmIQEE7_2A-C1oPgFkQwdc3sdzLFNj_8TVRZ08DeOQ&oe=664A08E0> </center> :::info Công thức: **Tổng số tiến trình = 2^n^** (n: là số lần lặp qua tiến trình) ::: * Các hệ điều hành khác nhau có thể chọn lựa các cài đặt khác nhau để thực hiện thao tác tạo lập một tiến trình * Các công việc cần thực hiện khi tạo lập một tiến trình: * Định danh cho tiến trình mới phát sinh * Đưa tiến trình vào danh sách quản lý của hệ thống * Xác định độ ưu tiên cho tiến trình * Cấp phát các tài nguyên ban đầu cho tiến trình * Tạo PCB lưu trữ thông tin tiến trình * Các thời điểm tiến trình được tạo ra: * Thời điểm khởi tạo hệ thống (system initialization) * Thời điêm thực thi lời gọi tiến trình * Thời điểm người sử dụng yêu cầu tạo tiến trình mới * Thời điểm khởi đầu một công việc theo lô (batch job). #### 2. Process termination - `kết thúc tiến trình` * A process may terminate when finishing its execution ($\to$ CPU thực thi xong thì nó kết thúc $\to$ kết thúc một cách chủ động) or be terminated by its parent or OS processes ($\to$ bị kết thúc bởi một tiến trình khác $\to$ kết thúc một cách bị động). * System Calls: exit (UNIX), ExitProcess (Windows) * Zombie processes (i.e, khi một tiến trình kết thúc, cho dù nó gọi hàm exit hay bị kết thúc bởi một tiến trình khác hay hệ thống $\to$ có hai thứ cần giải phóng: (1) vùng nhớ và các tài nguyên gắn với tiến trình, (2) PCB (Process Control Block) tương ứng với tiến trình đó nằm trong bảng Process Table trong vùng nhớ OS. Nếu cả hai đều được giải phóng, thì tiến trình kết thúc bình thường, đi ra khỏi hệ thống. Nếu child process kết thúc, toàn bộ tài nguyên, vùng nhớ đã được giải phóng nhưng khối quản lý tiến trình (PCB - process control block) của tiến trình đó chưa được giải phóng $\to$ tiến trình đó sẽ ở trạng thái zombie process): là trạng thái các tiến trình con đã giải phóng toàn bộ tài nguyên, vùng nhớ nhưng khối quản lý tiến trình chưa được giải phóng. $\implies$ Nguyên nhân: Vì khối quản lý tiến trình cần phải biết được trạng thái kết thúc của tiến trình đó thì nó mới giải phóng được, trong PCB có một thông tin chứa trạng thái kết thúc tiến trình (là trạng thái quyết định tiến trình đó kết thúc có lỗi hay không) $\to$ HĐH không bắt hay biết được tín hiệu kết thúc của tiến trình đó mà chỉ có tiến trình cha mới bắt được tín hiệu kết thúc đó $\to$ hầu hết các tiến trình khi kết thúc nó sẽ pass vào zombie state (tức là tài nguyên đã giải phóng nhưng PCB vẫn còn) $\to$ tới khi nào tiến trình cha bắt được tín hiệu kết thúc của nó $\to$ nhờ tín hiệu kết thúc này HĐH mới giải phóng được khối quản lý tiến trình (PCB) trong Process Table của tiến trình đó $\to$ tiến trình mới hoàn toàn kết thúc thực sự. Vấn đề là làm sao để tiến trình cha bắt được tín hiện kết thúc của tiến trình con ? $\to$ ta sẽ hai system calls (wait (UNIX), WaitForSingleObject(Windows)) của hệ thống khi tạo tiến trình cha để tiến trình cha bắt tín hiệu kết thúc của tiến trình con $\to$ tiến trình cha phải chờ tiến trình con kết thúc, trả về tín hiệu kết thúc. * A child terminates, but its PCB has not released yet (zombie process). $\to$ The parent must `wait` for its children to complete (solutions). * System Calls: wait (UNIX), WaitForSingleObject(Windows) * Orphan processes: là tiến trình mà tiến trình cha của tiến trình này đã kết thúc rồi mà tiến trình con vẫn tồn tại. Một số hệ thống không cho phép chuyện này xảy ra vì nếu xảy ra, không thể bắt được trạng thái kết thúc (tiến trình cha kết thúc thì phải kết thúc cả những tiến trình con). Nếu tiến trình cha kết thúc mà tiến trình con chưa kết thúc, thì lúc này tiến trình con sẽ được gán cho một tiến trình cha có bậc lớn hơn. Nếu tiến trình cha có bậc cao nhất (root process) kết thúc mà vẫn còn tiến trình con cần gán vào tiến trình cha $\to$ cascading termination (kết thúc tất cả các tiến trình mà tiến trình root đang quản lý). * Parent terminate, but children still exist $\to$ orphan processes $\to$ assigned to `root process` * Cascading termination #### 3. System Calls for Process Management <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427924280_940580017717750_5463575853604351206_n.png?_nc_cat=111&ccb=1-7&_nc_sid=5f2048&_nc_ohc=0l5rqd2qzOoAb6i2kgO&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QH_ESVp98fBNZUO6pcmAWbxYbOApMvsiNQaZgnCdvADaw&oe=664A0F2F> </center> ### IV. Inter - process Communication (IPC) - `cơ chế liên lạc / giao tiếp giữa các tiến trình` #### 1. Overview * IPC (Inter - processor Communication) provides the way in which processes communicate to each other (do các tiến trình phải có vùng nhớ riêng biệt và không có quyền can thiệp vào vùng nhớ lẫn nhau). * Exchangable / Sharing data: trao đổi / chia sẻ dữ liệu. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/428008814_432687899092787_5032873662531026247_n.png?_nc_cat=106&ccb=1-7&_nc_sid=5f2048&_nc_ohc=7YUj59EaluEAb4YgiIv&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QFvpI4pLDq5WBAGwfYJVvi5d828ENt8pw9On8uwCPxf7Q&oe=664A20F0> </center> * Cooperate to accomplish a task: hợp tác để thực thi một nhiệm vụ. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427873030_405230108729953_8976988699307594594_n.png?_nc_cat=110&ccb=1-7&_nc_sid=5f2048&_nc_ohc=FSSR3ga6wg4Ab7CCDSG&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHGIcl8hUO_drx_KnHff7ZlUtyWH-__Zn-1tFcjp9v_hw&oe=664A3581> </center> #### 2. Pipe - `đường ống` $\to$ Pipe là một file đặc biệt do hệ thống quản lý: nếu hai tiến trình muốn trao đổi, giao tiếp, chia sẻ dữ liệu thì một tiến trình sẽ làm nhiệm vụ ghi dữ liệu cần giao tiếp, chia sẻ và trao đổi vào file đặc biệt đó dưới dạng streams of bytes (writer), tiến trình còn lại sẽ đọc các dữ liệu mà tiến trình ban đan đầu đã ghi (reader) $\to$ đọc theo đúng thứ tự FIFO (First - In, First - Out). * Unidirectional communication $\to$ `giao tiếp một chiều` * Sending data in a one - way direction * Consists of two processes: writer (tiến trình gửi dữ liệu) and reader (tiến trình nhận dữ liệu) * Two kinds of pipes * Ordinary pipes (i.e, anonymous pipes - `không có đặt tên cho pipes`) $\to$ được tạo trong vùng nhớ chung của các tiến trình: two communicating processes **must** have a **parent - child relationship** (chỉ trao đổi, giao tiếp, chia sẻ, hợp tác giữa tiến trình cha và tiến trình con). * Named pipes - `pipes chung phải được đặt tên`: two communicating processes do not need to have a parent - child relationship (trao đổi, giao tiếp, chia sẻ, hợp tác giữa hai tiến trình bất kỳ). <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/421738822_1554156262026192_1475167369662569429_n.png?_nc_cat=104&ccb=1-7&_nc_sid=5f2048&_nc_ohc=g13ZOZvM7G0Ab6PKHjA&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGipYdjNUPtuRmT5ElclgVBP1UfBOIxQEobXgnT72SreA&oe=664A2B4D> </center> #### 3. Shared Memory - `vùng nhớ chia sẻ` * Processes make communication via a shared memory $\to$ thường dùng cho các tiến trình phức tạp. * Shared memory resides in address space of the process that created it. * Generally, **memory sharing** requires a **synchronization mechanism**. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/423221165_1092588308444099_4716652788256888146_n.png?_nc_cat=106&ccb=1-7&_nc_sid=5f2048&_nc_ohc=KjXlpwBqre0Ab6FlGYS&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QE7Kome7kaKwlatlahlbDUtKaZ71i4-ewjz7X5xMkCadQ&oe=664A08E7> </center> * Examples: Tiến trình A muốn chia sẻ, trao đổi các dữ liệu dùng chung (biến, tham số, ...) $\to$ tiến trình A sẽ tạo ra shared memory nằm trong tiến trình A để lưu các dữ liệu muốn chia sẻ, trao đổi, ... $\to$ lúc này, process B muốn dùng các dữ liệu đã được tiến trình A chia sẻ thì attach(), tức là lấy cái vùng shared memory trong vùng nhớ tiến trình A vào vùng nhớ tiến trình B để có thể sử dụng vùng dữ liệu này. $\implies$ dễ xảy ra vấn đề tranh chấp khi các tiến trình dùng các dữ liệu chung $\to$ cần có cơ chế đồng bộ hóa. * Nhận xét: - là phương pháp nhanh nhất để trao đổi dữ liệu giữa các tiến trình. - cần được bảo vệ bằng những cơ chế đồng bộ hóa. - Không thể ad hiệu quả trg các hệ p.tán #### 4. Socket * Definition: Socket dùng trong môi trường distributed system, dùng để chia thông tin của các tiến trình trên các máy tính khác nhau thông qua Internet. * Communication endpoints between processes on distant machines * Based on **client - server model**. * A socket is identified by an **IP address** and a **port number** $\to$ là một chương trình nằm trên một máy tính. * IP address: computer identifier over network $\to$ phân biệt các máy tính trên network $\to$ mỗi máy tính được cấp duy nhất một IP address trên network đó $\to$ xác định được máy tính nào trên network. * Port number: program identifier on a computer $\to$ dùng để định danh một socket có trên một máy tính tại một thời điểm (vì một máy tính có thể có nhiều socket $\to$ tại một thời điểm, port number chỉ gán cho một socket duy nhất có trên máy tính) $\to$ xác định được socket nào trên máy tính. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/427949440_714548154192209_7180399116367268799_n.png?_nc_cat=109&ccb=1-7&_nc_sid=5f2048&_nc_ohc=xU-UISaHZGsAb4lMmsf&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGjoCwvZ3bEnD8SoP5cHArXcqw62ILz3VBkWuG5V0SOzQ&oe=664A3182> </center> * **Connectionless (UDP) socket**: cơ chế giao tiếp phi kết nối (2 máy tính trao đổi không cần thiết lập kết nối trước đó) * No connection required. * Data transmitted as datagrams. * Loss data possible. * Fast. * Less reliable than TCP socket. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/423036682_277615125349851_8812324557834648213_n.png?_nc_cat=109&ccb=1-7&_nc_sid=5f2048&_nc_ohc=VJ76ZTew09gAb6yuJcH&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QHfiQTwVpet7cmGDsOwLTLF00yj6GjNBln4Y-2pp9AtRw&oe=664A25B0> </center> * **Connection - oriented (TCP) socket**: cơ chế giao tiếp kết nối (2 máy tính khi kết nối cần phải gửi request từ client vào server $\to$ có kết nối trước đó) * A logical connection required during data transfer. * Data transmitted as streams of bytes. * Re - transmission. * Slower than UDP socket. * Reliable. <center> <img src = https://scontent.xx.fbcdn.net/v/t1.15752-9/428005038_1397448547829628_959177884118442695_n.png?_nc_cat=110&ccb=1-7&_nc_sid=5f2048&_nc_ohc=_GTcXBlCKRgAb4wLpdo&_nc_ad=z-m&_nc_cid=0&_nc_ht=scontent.xx&oh=03_Q7cD1QGn_fkLIgZnirp8e3vi09DVEyYESICBtsJktOcUM_QEEQ&oe=664A109C> </center> #### 5. And other ... * Single handling * RCP (Remote Control Protocol) * Message Passing :::info **REVIEW QUESTION** 1. Explain the difference between a program and a process. * Answer :::spoiler ::: 2. Describe the context - switch procedure. * Answer :::spoiler ::: 3. When will a process move into the zombie state ? How to solve this problem ? * Answer :::spoiler ::: 4. When will a process move into the orphan state ? How to solve this problem ? * Answer :::spoiler ::: 5. What is the role of a PCB ? The following statement is true or false: `"A PCB of a process resides in memory zone reserved for this process"`. * Answer :::spoiler ::: ::: ---