Operating System

1. Operating System บทที่ 7 วงจรอับ (DEADLOCK)

2. รูปแบบของปัญหา (System Model)

3. รูปแบบของปัญหา (System Model)

4. รูปแบบของปัญหา (System Model) • เพื่อที่จะแสดงให้เห็นภาพของสถานะวงจรอับ เราจะมาพิจารณา ระบบที่ประกอบไปด้วยเครื่องขับเทป 3 เครื่อง สมมติว่า มีกระบวนการอยู่ 3 กระบวนการ และแต่ละกระบวนการ กำลังใช้เครื่องขับเทปอยู่ กระบวนการละเครื่อง ต่อมาถ้าแต่ละกระบวนการ ร้องขอเครื่องขับเทปเพิ่มอีกกระบวนการละ 1 เครื่อง ทั้ง 3 กระบวนการ จะติดอยู่ในวงจรอับทันที โดยแต่ละกระบวนการกำลังรอสถานการณ์ที่ “เครื่องขับเทปถูกปล่อยคืนสู่ระบบ” ซึ่งเป็นสถานการณ์ที่ขึ้นกับกระบวนการอื่น ในวงจร (ที่กำลังรอคอยทรัพยากรอยู่เช่นกัน) ตัวอย่างที่ยกมานี้เป็นการแสดงภาพของวงจรอับที่เกิดจากการที่กระบวนการพยายามที่จะแย่งกันใช้ทรัพยากรประเภทเดียวกัน

5. ลักษณะของวงจรอับ (Deadlock Characterization)

6. เงื่อนไขในการติดวงจรอับ(Necessary Conditions)

7. เงื่อนไขในการติดวงจรอับ(Necessary Conditions)

8. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) • P = { P1, P2, … , Pn} เป็นเซตของกระบวนการทั้งหมดที่มีอยู่ในระบบ • และเซต R = { R0, R1, … , Rn } เป็นเซตของทรัพยากรที่มีอยู่ในระบบ • โดยที่ลูกศรจาก Pi ไปยัง Rj (Pi Rj) นั้นเรียกว่า “เส้นร้องขอ” (Request Edge) • และลูกศรจาก Rj ไปยัง Pi (Rj Pi) เรียกว่า “เส้นถือครอง” (Assignment Edge)

9. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) • ในการเขียนกราฟ เราจะใช้วงกลมแทนกระบวนการ และใช้สี่เหลี่ยมแทนทรัพยากร และใช้จุด แทนจำนวนทรัพยากรแต่ละตัว ซึ่งจะอยู่ภายในสี่เหลี่ยม โดยที่เส้นร้องขอจะต้องชี้ไปยังกรอบสี่เหลี่ยม (ทรัพยากร Rj) เท่านั้น แต่เส้นถือครอง จะต้องชี้ไปยังจุดใดจุดหนึ่งในสี่เหลี่ยม

10. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) • กราฟการจัดสรรทรัพยากรในรูปข้างต้น แสดงสถานะของระบบ ดังนี้ • เซต P = { P1 , P2, P3} • เซต R = { R1 , R2 , R3 , R4 } • เซต E = { P1 R1, P2 R3 , R1 P2 , R2 P2 ,R2 P1 , R3 P3 } • ทรัพยากรในระบบ • ทรัพยากรประเภท R1 = 1 ตัว • ทรัพยากรประเภท R2 = 2 ตัว • ทรัพยากรประเภท R3 = 1 ตัว • ทรัพยากรประเภท R4 = 3 ตัว

11. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) • สถานะของกระบวนการ • กระบวนการ P1 กำลังถือครองทรัพยากรประเภท R2 และกำลังรอคอยที่จะใช้ทรัพยากรประเภท R1 • กระบวนการ P2 กำลังถือครองทรัพยากรประเภท R1 และ R2 และกำลังรอคอยที่จะใช้ทรัพยากรประเภท R3 • กระบวนการ P3 กำลังถือครองทรัพยากรประเภท R3 อยู่

12. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) • ถ้าเป็นระบบที่ทรัพยากรแต่ละประเภทมีเพียง 1 ตัว เมื่อมีวงจรในกราฟ ก็จะต้องมีวงจรอับในระบบแน่นอน • แต่ถ้าทรัพยากรแต่ละประเภทมีจำนวนมากกว่า 1 ตัว วงจรที่เกิดขึ้นในกราฟ ไม่อาจเป็นตัวบอกได้เสมอไปว่า เกิดวงจรอับในระบบ • สมมติว่ากระบวนการ P3 ได้ร้องขอทรัพยากรประเภท R2 แต่เนื่องจากไม่มีทรัพยากรตัวใด ในประเภท R2 ว่างเลย ดังนั้นเส้นร้องขอ P3 R2 จึงถูกใส่เพิ่ม เข้าไปในกราฟ ซึ่งแสดงในรูปถัดไป

13. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph)

14. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) • ณ จุดนี้ จะเกิดวงจรอย่างน้อย 2 วง ขึ้นในระบบ คือ • P1 R1 P2 R3 P3 R2 P1 • P2 R3 P3 R2 P2

15. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph)

16. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) P1 R1 P3 R2 P1

17. กราฟการจัดสรรทรัพยากร(Resource-Allocation Graph) • แต่อย่างไรก็ตามวงจรนี้จะไม่ก่อให้เกิดวงจรอับ โดยสังเกตว่า กระบวนการ P4 จะปล่อยทรัพยากรประเภท R2 ที่ตนเองถือครองอยู่ เมื่อใช้เสร็จ ซึ่งเมื่อทรัพยากร R2 ถูกปล่อยกลับสู่ระบบแล้วระบบก็สามารถที่จะจัดทรัพยากรประเภท R2 ให้แก่กระบวนการ P3 ได้ วงจรก็จะขาดทันที • เราอาจกล่าวโดยสรุปได้ว่า ถ้าไม่มีวงจรในกราฟการจัดสรรทรัพยากรแล้ว ระบบจะไม่อยู่ในสถานะวงจรอับ แต่ในทางกลับกัน ถ้ามีวงจรในกราฟแล้ว ระบบอาจจะเกิดวงจรอับ หรือไม่เกิดก็ได้

18. การจัดการปัญหาวงจรอับ (Methods for Handing Deadlocks) • การจัดการปัญหาวงจรอับมีอยู่ 3 วิธีหลัก ๆ คือ • กำหนดกฎเกณฑ์บางอย่างในการใช้ทรัพยากร เพื่อให้แน่ใจว่าระบบจะไม่มีทางเกิดวงจรอับได้ • ไม่ต้องป้องกันใด ๆ เลย ปล่อยให้ระบบเกิดวงจรอับขึ้นก่อน แล้วค่อยตามแก้ไขทีหลัง • มองข้ามปัญหาทั้งหมด แล้วแสร้งทำว่าวงจรอับไม่เคยเกิดขึ้นในระบบ วิธีการแก้ปัญหาวิธีนี้เป็นวิธีการหนึ่งที่ถูกใช้ในระบบปฏิบัติการส่วนใหญ่ รวมทั้ง UNIX ด้วย <restart>

19. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • ห้ามใช้ทรัพยากรร่วมกัน(Mutual Exclusion) • เงื่อนไขในข้อนี้ คือ การที่ระบบ ไม่อนุญาตให้ มีการใช้ทรัพยากรร่วมกัน เช่น เครื่องพิมพ์จะไม่สามารถ ให้กระบวนการหลาย ๆ กระบวนการ ใช้พร้อม ๆ กันได้ แต่ถ้าเรายอมให้ในระบบมีการใช้ทรัพยากรร่วมกันได้ ปัญหาวงจรอับก็จะไม่เกิด เช่น แฟ้มข้อมูลที่อ่านได้อย่างเดียวสามารถใช้ร่วมกันได้ • อย่างไรก็ตาม การที่เราจะป้องกันการเกิดวงจรอับในระบบ โดยการป้องกันเงื่อนไขนี้ ไม่สามารถทำได้เสมอไป เพราะยังมีทรัพยากรบางประเภท ที่ไม่มีทางใช้ร่วมกันได้

20. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • การถือครองแล้วรอคอย(Hold and Wait) • คือ การที่จะไม่ให้เกิด “การถือครองแล้วรอคอย” ขึ้นในระบบ โดยจะต้องกำหนดว่า เมื่อกระบวนการหนึ่งจะร้องขอทรัพยากร กระบวนการนั้นจะต้องไม่ได้ถือครองทรัพยากรใด ๆ อยู่ในขณะนั้น ซึ่งอาจทำได้ 2 วิธีการ คือ • ให้กระบวนการร้องขอทรัพยากรที่ต้องการใช้ทั้งหมด (ตลอดการทำงาน) ก่อนที่จะเริ่มต้นทำงาน • ยอมให้กระบวนการร้องขอทรัพยากรได้ ก็ต่อเมื่อกระบวนการนั้นมิได้ถือครองทรัพยากรใดไว้เลย

21. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • เราจะเห็นความแตกต่างของ 2 วิธีนี้ โดยการพิจารณาจากตัวอย่าง กระบวนการหนึ่งต้องการ • คัดลอกข้อมูลจากเทปลงไปเก็บที่แฟ้มข้อมูลในดิสก์ • เรียงลำดับข้อมูลของแฟ้มข้อมูลในดิสก์ • พิมพ์ผลลัพธ์ออกสู่เครื่องพิมพ์ • ถ้าทรัพยากรทั้งหมดต้องถูกร้องขอในตอนเริ่มต้นงานของกระบวนการ (นั่นคือใช้วิธีแรก) แสดงว่ากระบวนการนี้ ก็จะถือครองเครื่องพิมพ์ ไว้ตลอดเวลาที่กระบวนการทำงานอยู่ ถึงแม้ว่ากระบวนการนี้ จะใช้เครื่องพิมพ์เฉพาะในตอนท้ายของการทำงานเท่านั้น

22. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • สำหรับวิธีที่ 2 ให้กระบวนการร้องขอทรัพยากรในตอนเริ่มต้น แค่เครื่องขับเทป และแฟ้มข้อมูลในดิสก์ โดยเมื่อได้รับทรัพยากรแล้ว กระบวนการจะคัดลอกข้อมูล จากเทปลงไปสู่ดิสก์จากนั้นก็จะคืนทั้งเครื่องขับเทป และแฟ้มข้อมูลในดิสก์กลับสู่ระบบ จากนั้นกระบวนการก็จะต้องร้องขอแฟ้มข้อมูลในดิสก์และเครื่องพิมพ์ใหม่อีกครั้งหนึ่ง เมื่อพิมพ์เสร็จเรียบร้อยแล้วกระบวนการก็จะคืนทรัพยากรกลับสู่ระบบ เป็นอันสิ้นสุดการทำงานของกระบวนการ

23. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • วิธีการแรก มีข้อเสียคือ การใช้ทรัพยากรจะมีประสิทธิผลต่ำมาก อาจมี ปัญหาการแช่เย็น (starvation) อีกด้วย โดยถ้ามีบางกระบวนการต้องการใช้ทรัพยากร (ที่เป็นที่นิยมใช้กันมาก) หลาย ๆ ตัว อาจต้องรอคอย อย่างไม่มีที่สิ้นสุด • ส่วนวิธีการหลังก็มีข้อเสียคือ ต้องคืนทรัพยากรที่ถือครองอยู่ เพื่อที่จะร้องขอกลับมาใหม่อีก ร่วมกับทรัพยากรตัวใหม่ ทำให้เสียเวลาโดยเปล่าประโยชน์

24. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • ห้ามแทรกกลางคัน(No Preemption) • เราอาจกำหนดกฎเกณฑ์ดังนี้ • ถ้ากระบวนการหนึ่ง (ที่กำลังถือครองทรัพยากรบางส่วนอยู่) ร้องขอทรัพยากรเพิ่ม และระบบยังไม่สามารถจัดให้ได้ในทันที (แสดงว่ากระบวนการที่ร้องขอจะต้องรอ) เราจะให้ทรัพยากรทั้งหมด ที่กระบวนการนี้ถือครองอยู่ ถูกแทรกกลางคัน นั่นคือ ทรัพยากรที่กระบวนการนี้ถือครองอยู่ทั้งหมดจะถูกปล่อยคืนสู่ระบบโดยปริยาย กระบวนการที่ถูกแทรกกลางคันนี้จะต้องรอคอยทรัพยากร ทั้งที่ร้องขอไว้ตั้งแต่แรก และที่ถูกแทรกกลางคันไป ก่อนที่จะสามารถทำงานต่อไปได้

25. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • วิธีการนี้มักใช้กับทรัพยากรที่สามารถเก็บค่าสถานะและติดตั้งค่ากลับคืนมาได้ง่าย เช่น ค่าในรีจีสเตอร์ (ของหน่วยประมวลผลกลาง) เนื้อที่ในหน่วยความจำหลัก เป็นต้น แต่จะไม่สามารถใช้กับทรัพยากรทั่ว ๆ ไป เช่น เครื่องพิมพ์ และ หน่วยขับเทป เป็นต้น

26. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • วงจรรอคอย(Circular Wait) • เราอาจป้องกันการเกิดวงจรอับ โดยการป้องกันไม่ให้เกิดเงื่อนไขวงจรรอคอย ซึ่งสามารถทำได้โดย การกำหนดลำดับของทรัพยากรทั้งหมดในระบบ และกำหนดให้ กระบวนการต้องร้องขอใช้ทรัพยากร เรียงตามเลขลำดับนี้ • กำหนดให้ R = { R1 , R2, … , Rm } โดย R เป็นเซตของทรัพยากรในระบบ และ กำหนดให้ทรัพยากรแต่ละประเภทมี ค่าเลขลำดับเป็น เลขจำนวนเต็ม ที่ไม่ซ้ำกัน เขียนแทนด้วย F(Ri) เพื่อให้เราสามารถเปรียบเทียบทรัพยากร 2 ประเภทได้ว่าตัวใดมีลำดับก่อน-หลัง ตัวอย่างเช่น ถ้า

27. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • F (เครื่องขับเทป) = 1 • F (เครื่องขับดิสก์) = 5 • F (เครื่องพิมพ์) = 12 • และกำหนดวิธีการในการร้องขอทรัพยากรในระบบดังนี้ • กระบวนการแต่ละตัวสามารถร้องขอทรัพยากรได้ ในลำดับที่เพิ่มขึ้นเท่านั้น คือ เริ่มต้นกระบวนการอาจร้องขอทรัพยากรใด ๆ ก็ได้ เช่น ทรัพยากร Ri แต่ต่อจากนี้กระบวนการจะร้องขอทรัพยากร Rj ได้ก็ต่อเมื่อ F(Rj) > F(Ri) ถ้าเป็นการร้องขอทรัพยากร ประเภทเดียวกันหลาย ๆ ตัว กระบวนการจะต้องร้องขอทรัพยากรทีละตัว • ในทางตรงกันข้าม ถ้ากระบวนการต้องการร้องขอทรัพยากรประเภท Rj กระบวนการจะต้องปล่อยทรัพยากร Ri ซึ่ง F(Ri) F(Rj) คืนสู่ระบบทุกตัวเสียก่อน เช่นถือครอง R5 อยู่อยากได้ R1 ต้องคืน R5 ก่อน R5 R1

28. การป้องกันการเกิดวงจรอับ (Deadlock Prevention) • พึงสังเกตว่า การกำหนดค่าเลขลำดับของทรัพยากร ควรเรียงตามลำดับการใช้งานตามปกติในระบบ เช่น ปกติเรามักใช้เครื่องขับเทป ก่อนเครื่องพิมพ์เสมอ จึงควรกำหนดลำดับให้ F (เครื่องขับเทป) < F (เครื่องพิมพ์)

29. การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) • สถานะปลอดภัย (Safe State) • ระบบจะอยู่ในสถานะปลอดภัย (Safe State) ก็ต่อเมื่อมีลำดับการจัดสรรทรัพยากรอย่างปลอดภัยแก่กระบวนการ (Safe Sequence) โดยเราจะถือว่าลำดับของกระบวนการ <P1, P2 , … , Pn> เป็นลำดับที่ปลอดภัย สำหรับสถานะของการจัดสรรทรัพยากรปัจจุบัน

30. การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) • แต่ถ้าไม่สามารถหาลำดับกระบวนการที่ปลอดภัยในระบบได้ แสดงว่าระบบอยู่ในสถานะไม่ปลอดภัย (unsafe state) • สถานะปลอดภัยเป็นสถานะที่ไม่มีวงจรอับ และในทางกลับกัน สถานะไม่ปลอดภัยเป็นสถานะที่อาจเกิดวงจรอับได้ แต่ก็ไม่ได้หมายความว่า สถานะไม่ปลอดภัยทั้งหมดจะก่อให้เกิดวงจรอับเสมอไป ดังรูป

31. การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) • ตัวอย่างเช่น ระบบหนึ่งมีเครื่องขับเทป 12 เครื่อง และมีกระบวนการ 3 กระบวนการอยู่ในระบบ คือ P0 , P1 และ P2 โดยกระบวนการ P0 , P1 และ P2 ต้องการใช้เครื่องขับเทปสูงสุด 10 , 4 และ 9 เครื่อง ตามลำดับ ถ้า ณ เวลา T0 กระบวนการ P0 , P1 และ P2 ได้รับเครื่องขับเทป กระบวนการละ 5 , 2 และ 2 เครื่อง ตามลำดับ (แสดงว่า ณ เวลานั้นมีเครื่องขับเทปว่าอยู่ 3 เครื่อง)

32. การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) ณ เวลา T0 ลำดับกระบวนการ < P1, P0 , P2 > แสดงว่า ระบบอยู่ในสถานะปลอดภัย

33. การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) • บางครั้งระบบอาจจะเปลี่ยนจะสถานะปลอดภัย ไปเป็นสถานะไม่ปลอดภัยได้ เช่น สมมติว่า ณ เวลา T 1 กระบวนการ P2 ร้องขอเครื่องขับเทปเพิ่มอีก 1 เครื่อง และได้รับการจัดสรรจะทำให้สถานะของระบบกลายเป็นสถานะไม่ปลอดภัยทันที • โดยใช้แนวคิดของสถานะปลอดภัยนี้ เราสามารถสร้างขั้นตอนวิธีการหลีกเลี่ยงวงจรอับซึ่งจะประกันได้ว่า จะไม่เกิดวงจรอับขึ้นในระบบ โดยเมื่อใดก็ตามที่กระบวนการร้องขอทรัพยากรเพิ่มและทรัพยากรยังมีว่างพอ ระบบต้องตัดสินใจว่าจะให้ทรัพยากรตามที่ร้องขอทันทีหรือไม่ให้ (ให้กระบวนการรอไปก่อน) โดยพิจารณาจากว่าถ้าจัดสรรให้ตามที่ร้องขอแล้วระบบจะยังคงอยู่ในสถานะปลอดภัยหรือไม่

34. อัลกอริทึมของกราฟการจัดสรรทรัพยากร(Resource-Allocation Graph Algorithm) • โดยขั้นตอนวิธีนี้จะเพิ่มเส้นความต้องการ (Claim Edge) ขึ้นมาในกราฟการจัดสรรทรัพยากร โดยเส้นความต้องการที่ลากจาก Pi ไปยัง Rj (Pi Rj) หมายถึง ในอนาคตกระบวนการ Pi อาจจะร้องขอทรัพยากรประเภท Rj จะเห็นว่า เส้นความต้องการมีทิศทางเดียวกันกับ เส้นร้องขอ (จาก Pi ไป Rj) แต่จะต่างกันตรงที่เส้นความต้องการในกราฟการจัดสรรทรัพยากร จะแสดงด้วยเส้นประ แต่เส้นร้องขอแสดงด้วยเส้นทึบ

35. อัลกอริทึมของกราฟการจัดสรรทรัพยากร(Resource-Allocation Graph Algorithm) • สมมติว่ากระบวนการ Pi ได้ร้องขอทรัพยากรประเภท Rj ระบบจะอนุมัติการร้องขอนี้ ถ้าการเปลี่ยนเส้นร้องขอ (Pi Rj) ไปเป็นเส้นถือครอง (Rj Pi) ไม่ทำให้เกิดวงจรขึ้น แต่ถ้าพบว่าเส้นถือครองที่เกิดใหม่ทำให้เกิดวงจร กระบวนการนั้นจะต้องรอจนกว่าในระบบจะมีทรัพยากรว่างมากขึ้น และเส้นถือครองของกระบวนการที่ร้องขอจะไม่ก่อให้เกิดวงจรในกราฟการจัดสรรทรัพยากร • ถ้าไม่มีวงจรในกราฟ การอนุมัติทรัพยากรจะทำให้ระบบอยู่ในสถานะปลอดภัย ถ้าเกิดมีวงจรในกราฟแล้วการอนุมัติทรัพยากร จะทำให้ระบบอยู่ในสถานะไม่ปลอดภัย • เราจะแสดงขั้นตอนวิธีดังกล่าวโดยพิจารณากราฟการจัดสรรทรัพยากร ดังรูป

36. อัลกอริทึมของกราฟการจัดสรรทรัพยากร(Resource-Allocation Graph Algorithm)

37. อัลกอริทึมของกราฟการจัดสรรทรัพยากร(Resource-Allocation Graph Algorithm) • สมมติว่า P2 ร้องขอ R2 ระบบจะไม่อนุมัติการร้องขอดังกล่าว ถึงแม้ว่าทรัพยากร R2 จะว่างอยู่ก็ตาม เพราะว่าถ้าระบบอนุมัติ การร้องขอดังกล่าวแล้ว เส้นถือครอง R2 P2 จะก่อให้เกิดวงจรในกราฟการจัดสรรทรัพยากร ดังรูป

38. อัลกอริทึมของกราฟการจัดสรรทรัพยากร(Resource-Allocation Graph Algorithm) • ซึ่งจะทำให้ระบบอยู่ในสถานะไม่ปลอดภัย โดยอาจเกิดวงจรอับขึ้นในระบบ ถ้ากระบวนการ P1 เกิดร้องขอทรัพยากรประเภท R2 และ P2 ร้องขอ R1

39. อัลกอริทึมของนายธนาคาร (Banker’s Algorithm) • เมื่อมีกระบวนการใหม่เกิดขึ้นในระบบ กระบวนการนั้นจะต้องประกาศจำนวนทรัพยากรสูงสุดที่ต้องการในแต่ละประเภท โดยจำนวนที่ต้องการนี้จะต้องไม่เกินกว่าจำนวนที่มีอยู่จริงในระบบ และเมื่อกระบวนการร้องขอทรัพยากร ระบบจะต้องพิจารณาว่าเมื่อจัดสรรทรัพยากรให้แต่ละกระบวนการแล้ว จะทำให้ระบบอยู่ในสถานะปลอดภัยหรือไม่ ถ้าอยู่ระบบก็จะจัดสรรทรัพยากรให้ตามที่ขอ แต่ถ้าไม่กระบวนการที่ร้องขอก็จะต้องรอจนกว่ากระบวนการอื่นได้คืนทรัพยากรบางส่วนให้แก่ระบบจนเพียงพอ • ระบบต้องเก็บโครงสร้างข้อมูลหลายตัวเพื่อใช้ในขั้นตอนวิธีแบบนายธนาคาร โครงสร้างข้อมูลเหล่านี้ เป็นตัวบอกสถานะของการจัดสรรทรัพยากรในระบบ • กำหนดให้ n เป็นจำนวนกระบวนการในระบบ และ • m เป็นจำนวนของประเภททรัพยากร

40. อัลกอริทึมของนายธนาคาร (Banker’s Algorithm) • โครงสร้างข้อมูลที่จำเป็นมีดังนี้ • Available : เป็นเวคเตอร์ขนาด m ซึ่งใช้เก็บ ค่าจำนวนทรัพยากรที่ว่างของทรัพยากรแต่ละประเภท เช่น Available[j] = k หมายถึง ทรัพยากรประเภท Rj มีจำนวนทรัพยากรว่างอยู่ k ตัว • Max : เป็นเมทริกซ์ขนาด n x m ซึ่งใช้เก็บค่าจำนวนสูงสุดของทรัพยากรแต่ละประเภทที่กระบวนการแต่ละตัวต้องการใช้ เช่น Max[i,j] = k หมายถึง กระบวนการ Pi ต้องการทรัพยากรประเภท Rj มากที่สุด k ตัว

41. อัลกอริทึมของนายธนาคาร (Banker’s Algorithm) • Allocation : เป็นเมทริกซ์ขนาด n x m ซึ่งใช้เก็บค่าจำนวนทรัพยากรแต่ละประเภทที่กระบวนการแต่ละตัว กำลังถือครองอยู่ เช่น Allocation[i,j] = k หมายถึง กระบวนการ Pi กำลังถือครองทรัพยากรประเภท Rj อยู่ k ตัว • Need : เป็นเมทริกซ์ขนาด n x m ซึ่งใช้เก็บค่าจำนวนทรัพยากรแต่ละประเภทที่กระบวนการแต่ละตัว อาจร้องขอเพิ่มอีกได้ เช่น Need[i,j] = k หมายถึง กระบวนการ Pi อาจร้องขอทรัพยากรประเภท Rj ได้อีก k ตัว จะเห็นว่า Need [i,j] = Max[i,j] – Allocation[i,j]

42. ขั้นตอนวิธีตรวจดูสถานะปลอดภัย(Safety Algorithm) • ขั้นตอนวิธีในการตรวจสอบว่า ระบบจะอยู่ในสถานะปลอดภัยหรือไม่ เป็นดังนี้ • กำหนดให้ Work และ Finish เป็นเวคเตอร์ขนาด m และ n ตามลำดับ และกำหนดค่าเริ่มต้น ดังนี้ • Work := Available; • For i := 1 TO n DO • Finish[i] := FALSE;

43. ขั้นตอนวิธีตรวจดูสถานะปลอดภัย(Safety Algorithm) • ให้ i = 1 • WHILE i n DO BEGIN • IF Finish[i] = FALSE AND Need[i] Work • THEN BEGIN • Work := Work + Allocation[i]; • Finish[i] := TRUE; • i := i +1; END • ELSE i := i+1; • END • IF some Finish[i] = FALSE THEN “unsafe” ELSE “safe”

44. อัลกอริทึมร้องขอทรัพยากร(Resource-Request Algorithm) • ให้ Requestiเป็นเวคเตอร์ แสดงคำร้องขอของกระบวนการ Pi โดยที่ Requestiหมายถึง กระบวนการ Pi ได้ร้องขอทรัพยากรประเภท Rj เป็นจำนวน k ตัว • เมื่อกระบวนการ Pi ร้องขอทรัพยากร ระบบจะจัดการ ดังนี้ • 1. ถ้า Requesti > Neediแล้ว ระบบจะแจ้งข้อผิดพลาดว่า “กระบวนการขอทรัพยากรมากกว่าที่ระบุ” แล้วกระบวนการจะถูกขับออกจากระบบ แต่ถ้า Requesti Neediแล้ว จะไปทำงานในขั้นตอนที่ 2

45. อัลกอริทึมร้องขอทรัพยากร(Resource-Request Algorithm) • 2. ถ้า Requesti > Available แล้วให้ Pi รอจนกว่าทรัพยากรที่ร้องขอจะว่าง จากนั้นจึงไปทำงานในขั้นตอนที่ 3 แต่ถ้า Requesti Available แล้ว จะไปทำงานในขั้นตอนที่ 3 ทันที • 3. ระบบจะสมมติว่าได้จัดสรรทรัพยากรให้ตามที่กระบวนการ Pi ร้องขอมา โดยระบบจะมีสถานะเปลี่ยนไป ดังนี้ • Available := Available – Requesti; • Allocationi := Allocationi + Requesti; • Needi := Needi – Requesti;

46. อัลกอริทึมร้องขอทรัพยากร(Resource-Request Algorithm) • แล้วตรวจสอบดูว่าสถานะของการจัดสรรทรัพยากรขณะนี้เป็นสถานะปลอดภัยหรือไม่ ถ้าเป็นระบบก็จะจัดสรรทรัพยากรให้ตามที่สมมติทันที แต่ถ้าระบบอยู่ในสถานะไม่ปลอดภัยแล้วระบบก็จะให้กระบวนการ Pi รอ และ ถอยกลับไปอยู่ในสถานะเดิม (ก่อน การสมมติค่า Available , Allocationiและ Neediเป็นค่าเดิม)

47. ตัวอย่าง(An Illustrative Example) • ระบบหนึ่งมีกระบวนการอยู่ 5 ตัว คือ P0 , P1 , P2 , P3 และ P4 มีทรัพยากรอยู่ 3 ประเภท คือ A , B และ C โดยที่ในแต่ละประเภท มีจำนวนทรัพยากร 10 , 5 และ 7 ตัว ตามลำดับ

48. ตัวอย่าง(An Illustrative Example)

49. ตัวอย่าง(An Illustrative Example) • และเนื่องจาก เมทริกซ์ Need เกิดจาก Max – Allocation ดังนั้นจะได้ว่า

50. ตัวอย่าง(An Illustrative Example) • และ เราพบว่า ระบบอยู่ในสถานะปลอดภัยเนื่องจากกระบวนการอาจทำงานได้ตามลำดับ • <P1, P3, P4 , P2 , P0> ซึ่งเป็นไปตามเงื่อนไขของสถานะปลอดภัย • สมมติว่า กระบวนการ P1 ร้องขอทรัพยากรประเภท A และ C เพิ่มอย่างละ 1 และ 2 ตัวตามลำดับ ดังนั้น Request1 = (1,0,2) ระบบจะตัดสินใจว่าจะอนุมัติทรัพยากรให้ ตามที่ร้องขอหรือไม่ตามขั้นตอนดังนี้ • Request1 Need1 เนื่องจาก (1,0,2) (1,2,2) • Request1 Available เนื่องจาก (1,0,2) (3,3,2)