Chöông 2.B Thread Khaùi nieäm toång quan Caùc moâ hình multithread Pthread (POSIX thread) Multithreading trong Solaris

Xem xeùt laïi khaùi nieäm quaù trình Nhìn laïi vaø phaân tích khaùi nieäm quaù trình truyeàn thoáng: quaù trình goàm 1. Khoâng gian ñòa chæ chöùa code, data, heap (Unix: text, data, heap section) 2. Moät luoàng thöïc thi duy nhaát (single thread of execution) program counter caùc register stack (Unix: stack section) 3. Caùc taøi nguyeân khaùc (caùc open file, caùc quaù trình con,…)

Môû roäng khaùi nieäm quaù trình Môû roäng khaùi nieäm quaù trình truyeàn thoáng baèng caùch hieän thöïc nhieàu luoàng thöïc thi trong cuøng moät moâi tröôøng cuûa quaù trình. Quaù trình goàm 1. Khoâng gian ñòa chæ 2’. Moät hay nhieàu luoàng thöïc thi, moãi luoàng thöïc thi (thread) coù rieâng program counter caùc register stack 3. Caùc taøi nguyeân khaùc (caùc open file, caùc quaù trình con,…)

Quaù trình ña luoàng (Multi-threaded process) Khi quaù trình khôûi ñaàu chæ coù main (hay initial) thread thöïc thi Main thread seõ taïo caùc thread khaùc. Caùc thread trong cuøng moät process chia seû code, data vaø taøi nguyeân khaùc (caùc file ñang môû,...) cuûa process. Quaù trình ña luoàng (multithreaded process) laø quaù trình coù nhieàu luoàng.

Trình soaïn thaûo vaên baûn vôùi ba thread Söû duïng thread formatting backup mouse Trình soaïn thaûo vaên baûn vôùi ba thread

Process & thread information Per process items Address space Open files Child processes Signals & handlers Accounting info Global variables Per thread items Program counter Registers Stack & stack pointer State Per thread items Program counter Registers Stack & stack pointer State Per thread items Program counter Registers Stack & stack pointer State Quaù trình coù ba thread

Chia seû CPU giöõa caùc thread (1/2) time CPU ba quaù trình single-threaded

Chia seû CPU giöõa caùc thread (2/2) time CPU hai quaù trình multithreaded

Ví duï chöông trình söû duïng Pthread #include <stdio.h> void* thread1(){ int i; for (i = 0; i < 10; i++){ printf(“Thread 1\n”); sleep(1); } void* thread2(){ printf(“Thread 2\n”); sleep(1); int main(){ pthread_t th1, th2; pthread_create(&th1, NULL, thread1, NULL); pthread_create(&th2, NULL, thread2, NULL); sleep(20); return 0; Stack Heap SP1 thread1 stack SP2 thread2 stack Static data Text PC1 PC2 Sô ñoà boä nhôù Chöông trình naøy khi chaïy coù bao nhieâu thread?

Öu ñieåm cuûa thread Tính ñaùp öùng cao cho caùc öùng duïng töông taùc Chia seû taøi nguyeân giöõa caùc thread: vd memory Tieát kieäm chi phí heä thoáng Chi phí taïo/quaûn lyù thread nhoû hôn so vôùi quaù trình Chi phí chuyeån ngöõ caûnh giöõa caùc thread nhoû hôn so vôùi quaù trình Taän duïng ñöôïc ña xöû lyù (multiprocessor) Moãi thread chaïy treân moät processor rieâng, do ñoù taêng möùc ñoä song song cuûa chöông trình.

User thread (1/4) Moät thö vieän thread (thread library, run-time system) ñöôïc hieän thöïc trong user space ñeå hoå trôï caùc taùc vuï leân thread Thö vieän thread cung caáp caùc haøm khôûi taïo, ñònh thôøi vaø quaûn lyù thread nhö thread_create thread_exit thread_wait thread_yield Thö vieän thread duøng Thread Control Block (TCB) ñeå löu thoâng tin veà user thread (program counter, caùc register, stack) 4.4 What resources are used when a thread is created? How do they differ from those used when a process is created? Answer: Because a thread is smaller than a process, thread creation typically uses fewer resources than process creation. Creating a process requires allocating a process control block (PCB), a rather large data structure. The PCB includes a memory map, list of open files, and environment variables. Allocating and managing the memory map is typically The most time-consuming activity. Creating either a user or kernel thread involves allocating a small data structure to hold a register set, stack, and priority. Is the thread ID unique to the system, or only unique to the process? unique to the process After pthread_create(), which thread is running? creator? new thread? another existing thread? do not assume anything about this! same applies to process fork()

User thread (2/4) Caáu truùc döõ lieäu vaø memory layout ñeå hieän thöïc user thread TCBs D. Feitelson

User thread (3/4) Kernel khoâng bieát söï coù maët cuûa user thread Kernel chæ bieát PCB cuûa quaù trình Ví duï thö vieän user thread POSIX Pthread

User thread (4/4) Vaán ñeà: heä ñieàu haønh chæ caáp phaùt duy nhaát moät PCB cho moãi process ( main/initial thread) Blocking problem: Khi moät thread trôû neân blocked thì moïi thread khaùc cuûa process seõ khoâng tieán trieån ñöôïc user thread thread library thread library thread library PCB PCB PCB kernel

Kernel thread (1/3) Khi kyõ thuaät multithreading ñöôïc heä ñieàu haønh tröïc tieáp hoã trôï Kernel quaûn lyù caû process vaø caùc thread – kernel thread Vieäc ñònh thôøi CPU ñöôïc kernel thöïc hieän treân thread

Kernel thread (2/3) Khi multithreading ñöôïc hoã trôï bôûi kernel Khôûi taïo vaø quaûn lyù caùc thread chaäm hôn so vôùi user thread do system call overhead chuyeån user mode  kernel mode Taän duïng ñöôïc lôïi theá cuûa kieán truùc multiprocessor Duø moät thread bò blocked, caùc thread khaùc cuûa quaù trình vaãn coù theå tieán trieån Moät soá heä thoáng multithreading Windows 9x/NT/200x Solaris Linux 4.2 What are two differences between user-level threads and kernel-level threads? Under what circumstances is one type better than the other? Answer: (1) User-level threads are unknown by the kernel,whereas the kernel is aware of kernel threads. (2) On systems using either M:1 or M:N mapping, user threads are scheduled by the thread library and the kernel schedules kernel threads. (3) Kernel threads need not be associated with a processwhereas every user thread belongs to a process. Kernel threads are generally more expensive tomaintain than user threads as they must be represented with a kernel data structure.

Kernel thread (3/3) Caáu truùc döõ lieäu vaø memory layout ñeå hieän thöïc kernel thread TCBs D. Feitelson

Hieän thöïc user thread Nhaéc laïi kernel thread – thread ñöôïc heä ñieàu haønh quaûn lyù User(-level) multithreading coù theå hieän thöïc theo moät trong caùc moâ hình sau Moâ hình many-to-one Moâ hình one-to-one Moâ hình many-to-many

Moâ hình many-to-one Nhieàu user(-level) thread “chia seû” moät kernel thread ñeå thöïc thi Vieäc quaûn lyù thread ñöôïc thöïc hieän thoâng qua caùc haøm cuûa moät thread library ñöôïc goïi ôû user level. Blocking problem: Khi moät thread trôû neân blocked thì moïi thread khaùc cuûa process khoâng tieán trieån ñöôïc. Coù theå ñöôïc hieän thöïc ñoái vôùi haàu heát caùc heä ñieàu haønh. kernel thread

Moâ hình one-to-one Moãi user thread thöïc thi thoâng qua moät kernel thread rieâng cuûa noù Moãi khi moät user thread ñöôïc taïo ra thì cuõng caàn taïo moät kernel thread töông öùng Heä ñieàu haønh phaûi cung caáp ñöôïc nhieàu kernel thread cho moät quaù trình Ví duï: Windows NT/2000 kernel thread

Moâ hình many-to-many Nhieàu user-level thread ñöôïc phaân chia thöïc thi (multiplexed) treân moät soá kernel thread. Keát hôïp öu ñieåm cuûa user-level thread vaø cuûa kernel-level thread Ví duï Solaris 2 Windows NT/2000 vôùi package ThreadFiber kernel thread

Pthread Chuaån POSIX (IEEE 1003.1c) ñaëc taû API cho caùc thuû tuïc taïo thread vaø ñoàng boä thread Phoå bieán trong caùc heä thoáng UNIX/Linux Laø moät thö vieän hoã trôï user-level thread Tham khaûo theâm ví duï veà laäp trình thö vieän Pthread vôùi ngoân ngöõ C trong heä thoáng Unix-like, trang 140, “Operating System Concepts”, Silberschatz et al, 6th Ed, 2003. Bieân dòch vaø thöïc thi chöông trình multithreaded C trong Linux $ gcc source_file.c -lpthread –o output_file $ ./output_file

Thread trong Solaris (1/3) User-level threads Pthread vaø UI-thread Lightweight process (LWP) Moãi process chöùa ít nhaát moät LWP Thö vieän thread coù nhieäm vuï phaân ñònh user thread vaøo caùc LWP User thread ñöôïc gaén vôùi LWP thì môùi ñöôïc thöïc thi. Thö vieän thread chòu traùch nhieäm ñieàu chænh soá löôïng LWP Kernel(-level) thread Moãi LWP töông öùng vôùi moät kernel thread Ngoaøi ra, heä thoáng coøn coù moät soá kernel thread daønh cho moät soá coâng vieäc ôû kernel (caùc thread naøy khoâng coù LWP töông öùng) Ñoái töôïng ñöôïc ñònh thôøi trong heä thoáng laø caùc kernel thread 4.5 Assume an operating system maps user-level threads to the kernel using the many-to-many model and the mapping is done through LWPs. Furthermore, the system allows developers to create real-time threads. Is it necessary to bind a real-time thread to an LWP? Explain. Answer: Yes. Timing is crucial to real-time applications. If a thread is marked as real-time but is not bound to an LWP, the thread may have to wait to be attached to an LWP before running. Consider if a real-time thread is running (is attached to an LWP) and then proceeds to block (i.e. must perform I/O, has been preempted by a higher-priority real-time thread, is waiting for a mutual exclusion lock, etc.) While the real-time thread is blocked, the LWP itwas attached to has been assigned to another thread. When the real-time thread has been scheduled to run again, it must first wait to be attached to an LWP. By binding an LWP to a realtime thread you are ensuring the threadwill be able to runwithminimal delay once it is scheduled.

Thread trong Solaris (2/3) many-to-many

Thread trong Solaris (3/3) … LWP1 LWP2 LWP3 Quá trình trong Solaris

Read more POSIX thread programming, Blaise Barney, Lawrence Livermore National Laboratory https://computing.llnl.gov/tutorials/pthreads/