งานนำเสนอกำลังจะดาวน์โหลด โปรดรอ

งานนำเสนอกำลังจะดาวน์โหลด โปรดรอ

การประสานเวลา กระบวนการ การประสานเวลา กระบวนการ Process Synchronization นงลักษณ์ พรมทอง วิเชษฐ์ พลาย มาศ.

งานนำเสนอที่คล้ายกัน


งานนำเสนอเรื่อง: "การประสานเวลา กระบวนการ การประสานเวลา กระบวนการ Process Synchronization นงลักษณ์ พรมทอง วิเชษฐ์ พลาย มาศ."— ใบสำเนางานนำเสนอ:

1 การประสานเวลา กระบวนการ การประสานเวลา กระบวนการ Process Synchronization นงลักษณ์ พรมทอง วิเชษฐ์ พลาย มาศ

2 Objectives n เพื่อศึกษาแนวคิดพื้นฐานเกี่ยวกับการประสาน เวลาของซีพียู ปัญหาและวิธีการแก้ไขเกี่ยวกับ การประสานเวลา n เพื่อให้รู้เกี่ยวกับแนวคิดพื้นฐานและความเป็นมา เกี่ยวกับการประสานเวลากระบวนการ ส่วนวิกฤติ ฮาร์ดแวร์ประสานเวลา เซมาฟอร์ n เพื่อให้เข้าใจถึงปัญหาของการประสานเวลา และ วิธีการแก้ไขโดยใช้ตัวเฝ้าสังเกต และภาวะติด ตาย

3 Agenda Basic Concepts Scheduling Criteria Scheduling Algorithms Multiple-Processor Scheduling Real-Time Scheduling Algorithm Evaluation

4 Agenda: Process Synchronization Background The Critical-Section Problem Peterson’s Solution Synchronization Hardware Semaphores Classic Problems of Synchronization Monitors Synchronization Examples Atomic Transactions

5 Background n การออกแบบระบบปฏิบัติการ คือการเกี่ยวข้องกับกระจัด การกระบวนการและเธรด ในสภาพแวดล้อมต่อไปนี้ l มัลติโปรแกรมมิง (Multiprogramming) l มัลติโพรเซสซิง (Multiprocessing) l การประมวลผลแบบกระจาย (Distributed processing) หรือ คลัสเตอร์ (cluster) n จำเป็นต้องออกแบบเรื่อง l การจัดการภาวะพร้อมกัน (concurrency) l การประสานเวลา (synchronization)

6 Background (2) n ภาวะพร้อมกันมักเกิดขึ้นภายใต้สภาพแวดล้อมที่ แตกต่างกัน ดังนี้ l แอพพลิเคชันหลายชุด  สภาพแวดล้อมแบบมัลติโปรแกรมมิงยินยอมให้แอพพลิเคชัน หลายตัวสามารถกระทำการในเวลาเดียวกันได้ l โครงสร้างของแอพพลิเคชัน  ภายใต้แนวคิดของการออกแบบมอดุลาร์และโปรแกรมแบบ โครงสร้าง บางแอพพลิเคชันสามารถทำงานได้อย่างมี ประสิทธิภาพเมื่อมีการเรียกใช้กระบวนการร่วมกัน l โครงสร้างระบบปฏิบัติการ  ระบบปฏิบัติการสมัยใหม่ได้มีการออกแบบให้กลุ่มกระบวนการ สามารถทำงานไปพร้อมๆ กันได้

7 Background (3) n การเข้าถึงข้อมูลในเวลาพร้อมๆ กันอาจเป็นเหตุให้เกิดความ ขัดแย้งกันของข้อมูลได้ n การดูแลให้ข้อมูลมีความสอดคล้องกันย่อมต้องอาศัยกลไก การจัดลำดับการประมวลผลเพื่อทำหน้าที่ประสานงานกับ กระบวนการต่างๆ n ถ้าเราใช้วิธีการแก้ปัญหา consumer-producer problem โดยใช้บัฟเฟอร์ทั้งหมด เราสามารถทำได้โดยการใช้ integer count เพื่อจัดเก็บจำนวน track ทั้งหมดของ บัฟเฟอร์ที่เต็ม n โดยกำหนดค่าเริ่มต้นเป็น 0 และจะเพิ่มค่าขึ้นโดย producer เมื่อมีบัฟเฟอร์ว่างใหม่เข้ามา n และจะลดค่าลงโดย consumer หลังจากใช้บัฟเฟอร์

8 Producer while (true) /* produce an item and put in nextProduced while (count == BUFFER_SIZE) ; // do nothing buffer [in] = nextProduced; in = (in + 1) % BUFFER_SIZE; count++; }

9 Consumer while (1) { while (count == 0) ; // do nothing nextConsumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; count--; /* consume the item in nextConsumed }

10 สภาวะการแย่งชิง สภาวะการแย่งชิง (race condition) n ในสถานการณ์ที่มีหลายกระบวนการเข้าถึงและ เปลี่ยนแปลงค่าข้อมูลที่ใช้ร่วมกันในเวลาพร้อมกัน เรียกว่า สภาวะการแย่งชิง (race condition) n ผลลัพธ์ที่ได้จะขึ้นอยู่กับนโยบายการจัดลำดับ (scheduling policy) ที่ใช้ n การแก้ปัญหานี้ต้องประกันว่า จะมีเพียงกระบวนการเดียว เท่านั้น ณ ขณะใดขณะหนึ่งที่สามารถเปลี่ยนแปลงค่าตัว แปร counter ได้ ซึ่งจำเป็นต้องอาศัยการประสานเวลา กระบวนการ (synchronized) เข้ามาช่วย

11 Race Condition count++ could be implemented as register1 = count register1 = register1 + 1 count = register1 count-- could be implemented as register2 = count register2 = register2 - 1 count = register2 Consider this execution interleaving with “count = 5” initially: S0: producer execute register1 = count {register1 = 5} S1: producer execute register1 = register1 + 1 {register1 = 6} S2: consumer execute register2 = count {register2 = 5} S3: consumer execute register2 = register2 - 1 {register2 = 4} S4: producer execute count = register1 {count = 6 } S5: consumer execute count = register2 {count = 4} count อาจเป็น 4 หรือ 6 ก็ได้ แต่ค่าที่ถูกต้องคือ 5

12 ส่วนวิกฤติ ส่วนวิกฤติ Critical Section n ถ้าในระบบหนึ่งประกอบด้วยกระบวนการหรือเธรดจำนวน n {T0, T1, …, Tn-1} n ในการควบคุมการเข้าถึงทรัพยากรที่สามารถใช้ร่วมกันได้โดยกระบวนการ หรือเธรดทั้งหมดนั้น สามารถทำได้โดยกำหนดให้แต่ละเธรดจะมีส่วนของ รหัสที่เรียกว่า ส่วนวิกฤติ (critical section) ที่เธรดใช้ในการเปลี่ยนค่าของ ตัวแปรร่วม, การแก้ไขตาราง, เขียนแฟ้ม และอื่นๆ n คุณลักษณะสำคัญของระบบนี้ก็คือ เมื่อมีเธรดหนึ่งกำลังกระทำการอยู่ใน ส่วนวิกฤติ จะต้องไม่มีเธรดใดๆ ที่ได้รับอนุญาตให้เข้าใช้ส่วนวิกฤตินี้ได้

13 การแก้ปัญหาส่วนวิกฤติ 1.การไม่เกิดร่วม (mutual exclusion) ถ้ามีเธรด Ti กำลังเข้ากระทำการบริเวณส่วนวิกฤติอยู่ จะต้องไม่มีเธรดอื่น ใดสามารถเข้าใช้ส่วนวิกฤตินี้ได้ 2.ความก้าวหน้า (Progress) ถ้าไม่มีเธรดใดเข้ากระทำการอยู่ในส่วนวิกฤติ และมีเธรดใดๆ รอเข้าใช้ส่วน วิกฤติ เธรดเหล่านั้นจะต้องได้รับอนุญาตให้เข้าใช้ส่วนวิกฤติได้ทันทีโดย ไม่ต้องรอเวลาใดๆ 3.การรอที่มีขอบเขต (Bounded waiting) เมื่อเธรดใดๆ ทำการร้องขอส่วนวิกฤติ การร้องขอนั้นจะต้องได้รับการ ตอบสนองอย่างรวดเร็วที่สุดเท่าที่จะเป็นไปได้นับตั้งแต่มีการร้องขอ โดย ไม่เกิดภาวะรอคอยอย่างไม่มีขอบเขตสิ้นสุด ทั้งนี้ เพื่อป้องกันภาวะงูกิน หาง (starvation)

14 Initial Attempts to Solve Problem Only 2 processes, P 0 and P 1 General structure of process P i (other process P j ) do { entry section critical section exit section reminder section } while (1); n กระบวนการทั้งหมดสามารถใช้ตัวแปรร่วมกันในการประสานการ ทำงานกัน n อัลกอริธึมที่ใช้พิสูจน์แบบจำลองนี้มี 3 แบบ

15 Algorithm 1 Shared variables: int turn; initially turn = 0 turn - i  P i can enter its critical section Process P i do { while (turn != i) ; critical section turn = j; reminder section } while (1); n อัลกอริธึมนี้รองรับการไม่เกิดร่วม (Mutual Exclusion) แต่ไม่ รองรับความก้าวหน้า (Progress)

16 Algorithm 2 Shared variables boolean flag[2]; initially flag [0] = flag [1] = false. flag [i] = true  P i ready to enter its critical section Process P i do { flag[i] := true; while (flag[j]) ; critical section flag [i] = false; remainder section } while (1); n อัลกอริธึมนี้ รองรับการไม่เกิดร่วม (Mutual Exclusion) แต่ไม่ รองรับความก้าวหน้า (Progress)

17 Algorithm 3 Combined shared variables of algorithms 1 and 2. Process P i do { flag [i]:= true; turn = j; while (flag [j] and turn = j) ; critical section flag [i] = false; remainder section } while (1); n อัลกอริธึมนี้ รองรับเงื่อนไขได้ทั้ง 3 ข้อ และสามารถแก้ปัญหาส่วน วิกฤติสำหรับ 2 กระบวนการได้

18 ฮาร์ดแวร์ประสานเวลา ฮาร์ดแวร์ประสานเวลา Synchronization Hardware n บนระบบโพรเซสเซอร์เดียวสามารถระงับการใช้ interrupts l สามารถรับประกันได้ว่าลำดับของชุดคำสั่งจะถูกกระทำการโดย ปราศจาการบังคับให้ออกจากเวลาซีพียู n บนมัลติโพรเซสเซอร์ ไม่สามารถใช้งานได้ l การห้ามขัดจังหวะบนโปรเซสเซอร์หลายตัวนั้นใช้เวลานานมากใน การส่งข่าวสารไปยังโปรเซสเซอร์ทุกตัว l การส่งข่าวสารจะก่อให้เกิดการหน่วงเวลาไปยังส่วนวิกฤติของทุก โปรเซสเซอร์ซึ่งส่งผลให้ประสิทธิภาพของระบบลดลง l ยังส่งผลกระทบต่อนาฬิกาของระบบอีกด้วยถ้านาฬิกาบันทึกเวลาที่ ถูกเปลี่ยนค่าโดยการขัดจังหวะ

19 ฮาร์ดแวร์ประสานเวลา ฮาร์ดแวร์ประสานเวลา Synchronization Hardware n เครื่องในหลายระบบจึงจัดเตรียมชุดคำสั่งระดับฮาร์ดแวร์ที่ ใช้สำหรับทดสอบและเปลี่ยนค่าของคำ หรือสำหรับสลับค่า ระหว่างคำ 2 คำแบบภาวะครบหน่วย (atomic instruction)  Atomic = non-interruptable n ชุดคำสั่งฮาร์ดแวร์ประสานเวลาที่จัดเตรียมไว้เพื่อแก้ปัญหา นี้ประกอบด้วย Test-and-Set Instruction Swap Instruction

20 Test-and-Set Instruction Definition: boolean TestAndSet (boolean *target) { boolean rv = *target; *target = TRUE; return rv: }

21 Solution using TestAndSet Shared boolean variable lock., initialized to false. Solution: do { while ( TestAndSet (&lock )) ; /* do nothing // critical section lock = FALSE; // remainder section } while ( TRUE);

22 Swap Instruction Definition: void Swap (boolean *a, boolean *b) { boolean temp = *a; *a = *b; *b = temp: }

23 Solution using Swap Shared Boolean variable lock initialized to FALSE; Each process has a local Boolean variable key. Solution: do { key = TRUE; while ( key == TRUE) Swap (&lock, &key ); // critical section lock = FALSE; // remainder section } while ( TRUE);

24 เซมาฟอร์ เซมาฟอร์ Semaphore n เป็นเครื่องมือประสานเวลาที่ไม่ต้องการเวลารอคอย n เซมาฟอร์ S เป็นตัวแปรจำนวนเต็ม (integer) ช่วยลดความ ซับซ้อน สามารถเข้าถึงได้ผ่านคำสั่งปฏิบัติการมาตรฐาน 2 คำสั่งปฏิบัติการแบบภาวะครบหน่วย (atomic operation) ได้แก่ l wait และ signal n คำสั่งปฏิบัติการแบบภาวะครบหน่วย (atomic operation) l เมื่อกระบวนการหนึ่งกำลังแก้ไขค่าเซมาฟอร์ จะต้องไม่มีกระบวนการ อื่นที่สามารถแก้ไขค่าเซมาฟอร์เดียวกันได้ในเวลาเดียวกัน l กรณีของ wait(S) การทดสอบค่าจำนวนเต็มของ S (S  0) และการ แก้ไขค่า (S--) จะต้องกระทำการโดยปราศจากขัดจังหวะ

25 เซมาฟอร์ (2) เซมาฟอร์ (2) Semaphore n S: wait() and signal() l Originally called P() and V() l wait (S) { while S <= 0 ; // no-op S--; } l signal (S) { S++; }

26 Semaphore as General Synchronization Tool n แบ่งตัวแปรเซมาฟอร์ออกเป็น 2 ชนิด ได้แก่ l เซมาฟอร์นับ (Counting semaphore) มีค่าที่เป็นไปได้ไม่จำกัด l เซมาฟอร์ไบนารี (Binary semaphore) มีค่าที่เป็นได้คือ 0 และ 1 ง่าย ต่อการใช้งาน บางทีเรียกว่า mutex locks n โดยค่าของเซมาฟอร์นับไม่จำกัดขอบเขต ส่วนค่าที่เป็นไปได้ของเซมาฟอร์ ไบนารีได้แก่ 0 กับ 1 เพื่อให้ใช้งานได้ง่าย n สามารถใช้ counting semaphore S เป็นไบนารีเซมาฟอร์ n Provides mutual exclusion l Semaphore S; // initialized to 1 l wait (S); Critical Section signal (S);

27 Semaphore Implementation n เราสามารถใช้เซมาฟอร์ไบนารีควบคุมการเข้าถึงส่วนวิกฤติสำหรับ กระบวนการหรือเธรดใดๆ โดยจะมีเพียงเธรดเดียวเท่านั้นที่สามารถเข้า สู่ส่วนวิกฤติได้ ณ ขณะใดขณะหนึ่ง n ส่วนเซมาฟอร์นับสามารถใช้ควบคุมการเข้าถึงทรัพยากรที่สอดคล้อง กันเพียงค่าจำนวนจำกัดเท่านั้น n โดยเซมาฟอร์จะกำหนดค่าของจำนวนทรัพยากรที่สามารถใช้งานได้ แต่ละเธรดที่ต้องการใช้ทรัพยากรดังกล่าวก็จะเรียกคำสั่งปฏิบัติการ P บนเซมาฟอร์ (เพื่อลดค่าจำนวนนับ) n เมื่อเธรดนั้นปลดปล่อยทรัพยากรก็จะเรียกคำสั่งปฏิบัติการ V (เพิ่มค่า จำนวนนับ) n เมื่อค่าจำนวนนับของเซมาฟอร์ไปจนถึงค่า 0 ก็แสดงว่าทรัพยากร ทั้งหมดกำลังถูกใช้งาน n ในระหว่างนี้ ถ้าเธรดใดร้องขอทรัพยากรก็จะต้องถูกหยุดให้รอ จนกระทั่งค่าตัวนับมากกว่า 0

28 Semaphore Implementation with no Busy waiting n เซมาฟอร์แต่ละตัวจะมีการเชื่อมโยงไปยังแถวคอย (waiting queue) แต่ละรายการในแถวคอยจะมีเพียง 2 รายการ l value (of type integer) l pointer (ตัวชี้ไปยังเรคคอร์ดถัดไปในรายการ) n Two operations: l block –หยุดกระบวนการที่ร้องขอ l wakeup(P) กลับมากระทำการกระบวนการ P ที่ถูกหยุดไว้ต่อ (โดยเปลี่ยนสถานะจากรอเป็นพร้อม)

29 Semaphore Implementation with no Busy waiting (Cont.) Implementation of wait: wait (S){ value--; if (value < 0) { add this process to waiting queue block(); } } Implementation of signal: Signal (S){ value++; if (value <= 0) { remove a process P from the waiting queue wakeup(P); } }

30 ภาวะติดตายและงูกินหาง ภาวะติดตายและงูกินหาง Deadlock and Starvation on Semaphore n ภาวะติดตาย (Deadlock) กระบวนการตั้งแต่ 2 กระบวนการขึ้นไปต่าง ฝ่ายต่างกำลังรอคอยซึ่งกันและกันอย่างไม่รู้จบ เพื่อให้เหตุการณ์ บางอย่างเกิดขึ้น โดยที่เหตุการณ์นั้นจะเกิดขึ้นได้โดยอาศัยกระบวนการหนึ่ง แต่กระบวนการก็กำลังรอคอยอะไรบางอย่างด้วย Let S and Q be two semaphores initialized to 1 P 0 P 1 wait (S); wait (Q); wait (Q); wait (S);. signal (S); signal (Q); signal (Q); signal (S); n ภาวะงูกินหาง (starvation) หรือ การหยุดรออย่างไม่มีกำหนด (indefinite blocking) เป็นสถานการณ์ที่มีหลายกระบวนการกำลังรอคอยอย่างไม่มี กำหนดอยู่ภายในเซมาฟอร์ เพราะมีกระบวนการหนึ่งกำลังใช้เซมาฟอร์อยู่

31 ปัญหาพื้นฐานของการประสานเวลา ปัญหาพื้นฐานของการประสานเวลา Classical Problems of Synchronization n ปัญหาพื้นฐานที่ใช้ทดสอบวิธีการแก้ปัญหาการประสาน เวลา l Bounded-Buffer problem (Producer/Consumer problem) l Readers and Writers problem l Dining-Philosophers problem

32 Bounded-Buffer Problem n บางทีเรียกว่าปัญหาผู้ผลิต-ผู้บริโภค (Producer/Consumer problem) n เป็นปัญหาที่นิยมใช้ในการทดสอบประสิทธิภาพของเทคนิค การประสานเวลา n มีผู้ผลิตหนึ่งคนหรือมากกว่าทำการผลิตข้อมูลบางชนิด (ระเบียน, อักขระ) และใส่ลงในบัฟเฟอร์ และมีผู้บริโภค เพียงคนเดียวเท่านั้นที่สามารถหยิบข้อมูลนั้นออกจาก บัฟเฟอร์ในขณะใดขณะหนึ่ง n ระบบจะต้องกำหนดเงื่อนไขเพื่อป้องกันไม่ให้เกิดการทับ ซ้อนกันในการปฏิบัติการบนบัฟเฟอร์นั้น หมายความว่า ณ ขณะใดขณะหนึ่ง จะมี (ผู้ผลิตหรือผู้บริโภค) เพียงคนเดียว เท่านั้นที่สามารถเข้าถึงบัฟเฟอร์ได้

33 Bounded-Buffer Problem (Cont.) N buffers, each can hold one item Semaphore mutex initialized to the value 1 Semaphore full initialized to the value 0 Semaphore empty initialized to the value N.

34 Bounded Buffer Problem (Cont.) The structure of the producer process do { // produce an item wait (empty); wait (mutex); // add the item to the buffer signal (mutex); signal (full); } while (true);

35 Bounded Buffer Problem (Cont.) The structure of the consumer process do { wait (full); wait (mutex); // remove an item from buffer signal (mutex); signal (empty); // consume the removed item } while (true);

36 Readers-Writers Problem n ปัญหาผู้อ่าน-ผู้เขียนถือเป็นปัญหาที่ใช้ในการทดสอบกลไกการ แก้ปัญหาเกี่ยวกับการควบคุมภาวะพร้อมกัน n ชุดข้อมูลที่ใช้ร่วมกันระหว่างกระบวนการทั้งหมดในเวลาเดียวกัน นั้น l ผู้อ่าน สามารถอ่านข้อมูลได้อย่างเดียว, ไม่มีการ update l ผู้เขียน สามารถทำได้ทั้งอ่านและเขียน n ปัญหานี้คือ มีพื้นที่ข้อมูลซึ่งใช้ร่วมกันได้ระหว่างกระบวนการ ทั้งหมด มีกระบวนการจำนวนมากที่ต้องการอ่าน (readers) พื้นที่ ดังกล่าวเพียงอย่างเดียว และมีกระบวนการที่ต้องการเขียน (writers) บนพื้นที่ดังกล่าวเพียงกระบวนการเดียวในเวลาเดียวกัน

37 Readers-Writers Problem (Cont.) n การจัดการจะต้องเข้ากันได้กับเงื่อนไขดังต่อไปนี้ 1.ผู้อ่านสามารถอ่านแฟ้มได้พร้อมกันหลายคน 2.มีผู้เขียนเพียงคนเดียวเท่านั้นที่สามารถเขียนแฟ้มได้ ณ เวลาใดเวลา หนึ่ง 3.ถ้ามีผู้เขียนรอที่จะเขียนแฟ้ม จะต้องไม่มีผู้อ่านคนใดสามารถอ่าน แฟ้มนั้นได้ n จากข้อกำหนดข้างต้นอาจนำไปสู่ปัญหาภาวะงูกินหาง l กรณีแรก ผู้เขียนอาจต้องเป็นฝ่ายรออย่างไม่รู้จบ l กรณีหลัง ผู้อ่านอาจต้องเป็นฝ่ายรออย่างไม่รู้จบ Shared Data Data set Semaphore mutex initialized to 1. Semaphore wrt initialized to 1. Integer readcount initialized to 0.

38 Readers-Writers Problem (Cont.) The structure of a writer process do { wait (wrt) ; // writing is performed signal (wrt) ; } while (true)

39 Readers-Writers Problem (Cont.) The structure of a reader process do { wait (mutex) ; readcount ++ ; if (readercount == 1) wait (wrt) ; signal (mutex) // reading is performed wait (mutex) ; readcount - - ; if redacount == 0) signal (wrt) ; signal (mutex) ; } while (true)

40 Dining-Philosophers Problem Shared data Bowl of rice (data set) Semaphore chopstick [5] initialized to 1

41 Dining-Philosophers Problem (Cont.) n นักปรัชญาจำนวน 5 คนนั่งบนเก้าอี้ล้อมรอบโต๊ะกลม n มีถ้วยใส่ข้าวจำนวน 5 ถ้วยวางไว้บนโต๊ะ n มีตะเกียบอยู่จำนวน 5 อันวางไว้ด้านซ้ายมือและด้านขวามือของเขา ข้างละหนึ่งอัน n เมื่อเวลาหิวก็จะพยายามหยิบตะเกียบจากด้านซ้ายและขวามือขึ้นมา ข้างละอันจึงจะสามารถบริโภคอาหารได้ และในระหว่างบริโภคก็จะ ไม่วางตะเกียบตลอดจนกระทั่งอิ่มจึงค่อยวางตะเกียบลง n ถ้ามีนักปรัชญาที่นั่งอยู่ด้านข้างหิวและพยายามหยิบตะเกียบขึ้นมา แต่ถ้าตะเกียบข้างใดข้างหนึ่งหรือทั้งสองข้างไม่ว่างก็จะต้องรอ

42 Dining-Philosophers Problem (Cont.) The structure of Philosopher i: Do { wait ( chopstick[i] ); wait ( chopStick[ (i + 1) % 5] ); // eat signal ( chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); // think } while (true) ;

43 Problems with Semaphores n สะท้อนถึงปัญหาสำคัญเกี่ยวกับการควบคุมภาวะพร้อมกันบน สภาพแวดล้อมของระบบปฏิบัติการ เช่น การจัดสรรทรัพยากร จำนวนมากให้แก่กระบวนการจำนวนมากที่อาจตกอยู่ภายใต้ สถานการณ์ของภาวะติดตายและงูกินหางที่มีการรออย่างไม่รู้จบ n การแก้ปัญหาอย่างง่ายวิธีหนึ่ง คือ l การแทนตะเกียบแต่ละอันด้วยเซมาฟอร์ l นักปรัชญาคนหนึ่งพยายามหยิบตะเกียบโดยการใช้คำสั่ง ปฏิบัติการ P บนเซมาฟอร์ l และวางตะเกียบโดยการใช้คำสั่งปฏิบัติการ V บนเซมาฟอร์ ที่เหมาะสม

44 Problems with Semaphores (Cont.) Correct use of semaphore operations: signal (mutex) …. wait (mutex) wait (mutex) … wait (mutex) Omitting of wait (mutex) or signal (mutex) (or both)

45 Problems with Semaphores (Cont.) n ในการป้องกันภาวะติดตายจากสถานการณ์นี้ สามารถกำหนด เงื่อนไข ดังต่อไปนี้ l อนุญาตให้นักปรัชญาเพียง 4 คนนั่งพร้อมๆ กันอยู่ที่โต๊ะกลมได้ l อนุญาตให้นักปรัชญาหยิบตะเกียบได้ก็ต่อเมื่อตะเกียบด้านซ้าย และขวาวางไว้อยู่ (เขาจะต้องหยิบตะเกียบทั้งคู่ในส่วนวิกฤติ) l ใช้วิธีแก้ปัญหาแบบอสมมาตร ตัวอย่างเช่น นักปรัชญาเลขคี่จะ หยิบตะเกียบด้านซ้ายก่อน ถ้าได้จึงหยิบด้านขวา ในขณะที่นัก ปรัชญาเลขคู่ให้เริ่มหยิบตะเกียบด้านขวาก่อนแลเวจึงหยิบ ตะเกียบด้านซ้าย n วิธีการนี้จะรับประกันว่าไม่มีการแย่งชิงที่เป็นสาเหตุให้นักปรัชญาคน หนึ่งเข้าสู่ภาวะติดตาย แต่วิธีนี้ไม่ได้ป้องกันภาวะการรออย่างไม่รู้จบ

46 ตัวเฝ้าสังเกต ตัวเฝ้าสังเกต Monitors n ตัวเฝ้าสังเกตเป็นซอฟต์แวร์มอดูลที่ประกอบด้วยหนึ่งหรือมากกว่ากระบวนงาน (procedure) ทำการกำหนดค่าการจัดลำดับ และตัวแปรข้อมูลเฉพาะที่ n เป็นกลไกที่ใช้งานง่ายกว่าเซมาฟอร์ และมีประสิทธิภาพที่ใช้สำหรับประสานเวลา กระบวนการ n คุณลักษณะสำคัญของตัวเฝ้าสังเกตประกอบด้วย l ตัวแปรข้อมูลเฉพาะที่จะสามารถเข้าถึงได้โดยกระบวนงานเฉพาะที่ของตัวเฝ้า สังเกตเท่านั้น และไม่สามารถเข้าถึงได้โดยกระบวนงานอื่นๆ จากภายนอก l กระบวนการเข้าสู่ตัวเฝ้าสังเกตได้โดยการเรียกกระบวนงานเฉพาะที่บางอย่าง ของตัวเฝ้าสังเกต l มีเพียงกระบวนการเดียวเท่านั้นที่ถูกกระทำการได้โดยตัวเฝ้าสังเกตในขณะใด ขณะหนึ่ง ถ้ามีกระบวนการอื่นต้องการใช้ตัวเฝ้าสังเกตก็จะต้องหยุดรอ จนกระทั่งตัวเฝ้าสังเกตว่างลง n ณ เวลาใดเวลาหนึ่ง จะมีเพียงกระบวนการเดียวเท่านั้นที่ active อยู่ภายในตัวเฝ้า สังเกต

47 ตัวเฝ้าสังเกต ตัวเฝ้าสังเกต Monitors monitor monitor-name { // shared variable declarations procedure P1 (…) { …. } … procedure Pn (…) {……} Initialization code ( ….) { … } … }

48 Schematic view of a Monitor

49 Condition Variables condition x, y; Two operations on a condition variable: x.wait () – a process that invokes the operation is suspended. x.signal () – resumes one of processes (if any) tha invoked x.wait ()

50 Monitor with Condition Variables Monitor with Condition Variables

51 Solution to Dining Philosophers n สำหรับการแก้ปัญหานักปรัชญาบริโภคนั้น กำหนดให้ การจ่ายตะเกียบถูกควบคุมโดยตัวเฝ้าสังเกต l กำหนดให้นักปรัชญาแต่ละคนก่อนจะเริ่มต้นบริโภค จะต้องเรียกคำสั่ง pickUp() จนกระทั่งสำเร็จจึงจะ เริ่มบริโภคได้ l หลังจากบริโภคเสร็จต้องเรียกคำสั่ง putDown() และเริ่มคิดต่อไป n ดังนั้น นักปรัชญา i จะต้องเรียกใช้คำสั่ง pickUp() และ putDown() ตามลำดับ

52 Solution to Dining Philosophers (cont.) monitor DP { enum { THINKING; HUNGRY, EATING) state [5] ; condition self [5]; void pickup (int i) { state[i] = HUNGRY; test(i); if (state[i] != EATING) self [i].wait; } void putdown (int i) { state[i] = THINKING; // test left and right neighbors test((i + 4) % 5); test((i + 1) % 5); }

53 Solution to Dining Philosophers (cont.) void test (int i) { if ( (state[(i + 4) % 5] != EATING) && (state[i] == HUNGRY) && (state[(i + 1) % 5] != EATING) ) { state[i] = EATING ; self[i].signal () ; } initialization_code() { for (int i = 0; i < 5; i++) state[i] = THINKING; }

54 Synchronization Examples Solaris Windows XP Linux Pthreads

55 Solaris Synchronization n การใช้ lock หลายแบบ เพื่อสนับสนุนระบบ multitasking และ multithreading (รวมทั้ง real-time threads) และ multiprocessing n ใช้ adaptive mutexes เพื่อความสะดวกในการป้องกันข้อมูลจาก รหัสเซ้กเมนท์สั้นๆ short code segments n ใช้ lock แบบ condition variables and readers-writers เมื่อเซ็ก ชันของรหัสที่ยาวกว่าต้องการใช้ข้อมูล n ใช้ turnstiles ในการจัดลำดับรายการเธรดที่กำลังรอคอย ที่ต้องการ adaptive mutex or reader-writer lock

56 Windows XP Synchronization n ใช้ interrupt เพื่อป้องกันการเข้าถึงทรัพยากรส่วนกลางบนระบบ โพรเซสเซอร์เดียว (uniprocessor systems) n ใช้ spinlocks บน multiprocessor systems n มีการเตรียม dispatcher objects ที่ทำหน้าที่เป็น mutexes และ semaphores n Dispatcher objects อาจจัดหาเหตุการณ์บางอย่าง (events) l เหตุการณ์ทำหน้าที่เช่นเดียวกันตัวแปรแบบมีเงื่อนไข (condition variable)

57 Linux Synchronization n Linux: l ระงับการใช้ interrupts โดยใช้ส่วนวิกฤติขนาดเล็ก (short critical sections) แทน n Linux provides: l semaphores l spin locks

58 Pthreads Synchronization Pthreads API is OS-independent It provides: mutex locks condition variables Non-portable extensions include: read-write locks spin locks

59 End of Process Synchronization

60


ดาวน์โหลด ppt การประสานเวลา กระบวนการ การประสานเวลา กระบวนการ Process Synchronization นงลักษณ์ พรมทอง วิเชษฐ์ พลาย มาศ.

งานนำเสนอที่คล้ายกัน


Ads by Google