DEADLOCKS Advanced Operating System Operating System Technology

DEADLOCKS Advanced Operating System Operating System Technology
วงจรอับ DEADLOCKS

Deadlock Examples: Traffic Jam : Dining Philosophers Device allocation
process 1 requests tape drive 1 & gets it process 2 requests tape drive 2 & gets it process 1 requests tape drive 2 but is blocked process 2 requests tape drive 1 but is blocked Semaphores : P(s) P(t) P(t) P(s) Operating Systems: Deadlock

Deadlocks สภาวะที่กระบวนการบางตัวหรือทุกตัว ไม่สามารถทำงาน ต่อไปได้ ส่วนใหญ่เกิดจากการรอคอยทรัพยากรในกลุ่มเดียวกัน ทรัพยากรในระบบ เวลาของ CPU (CPU time) Address Space File I/O

System Model เมื่อกระบวนการต้องการใช้ทรัพยากรของระบบ
จะต้องทำตามลำดับขั้นตอนต่าง ๆ ดังนี้ การร้องขอ (Request) การใช้งาน (Use) การคืน (Release)

System Model การร้องขอและการคืนทรัพยากร คือ คำสั่งเรียกระบบ (System calls) ระบบจะตรวจสอบการร้องขอและจัดสรรทรัพยากรของกระบวนการโดยมีตารางที่ใช้บันทึก กลุ่มของกระบวนการจะตกอยู่ในสถานะวงจรอับ เมื่อทุก ๆ กระบวนการ ที่อยู่ในกลุ่มนั้น ต่างก็กำลังรอคอยที่จะใช้ทรัพยากรที่กำลังถูกใช้ โดยกระบวนการอื่นในกลุ่มนั้น

System Model ถ้าระบบจัดสรรทรัพยากรชนิดนั้นๆตัวใดก็ได้ แสดงว่า ทรัพยากรเหล่านั้นเป็นชนิดเดียวกัน (ใช้แทนกันได้) แต่ถ้าระบบจัดสรรทรัพยากรเฉพาะที่ระบุ แสดงว่า ทรัพยากรเหล่านั้นเป็นคนละชนิด (ใช้แทนกันไม่ได้หรือไม่เหมือนกัน)

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

ลักษณะของวงจรอับ (Deadlock Characterization)
เงื่อนไขในการติดวงจรอับ (Necessary Conditions) ทรัพยากรเป็นแบบใช้ร่วมกันไม่ได้ (Mutual exclusion) มีทรัพยากรอย่างน้อย 1 ตัว จัดอยู่ในกลุ่มทรัพยากรที่ใช้ร่วมกันไม่ได้ นั่นคือ จะมีเพียง 1 กระบวนการเท่านั้นที่จะใช้ทรัพยากรตัวนั้นได้ ถ้ามีกระบวนการอื่นร้องขอทรัพยากรที่กำลังถูกใช้อยู่ กระบวนการนั้นจะต้องรอ จนกระทั่งทรัพยากรนั้น ถูกคืนกลับสู่ระบบแล้ว

เงื่อนไขในการติดวงจรอับ (Necessary Conditions) การถือครองแล้วรอคอย (Hold and Wait) มีอย่างน้อยหนึ่งกระบวนการ ที่กำลังถือครองทรัพยากรอยู่อย่างน้อย 1 ตัว และขณะเดียวกันก็กำลังรอคอยทรัพยากรเพิ่มอีก แต่เป็นทรัพยากรที่กำลังถูกถือครองโดยกระบวนการอื่นอยู่ ห้ามแทรกกลางคัน (No Preemption) เมื่อกระบวนการกำลังใช้ทรัพยากรอยู่ จะไม่มีการแทรกกลางคัน และจะถูกปล่อยคืนสู่ระบบ โดยความสมัครใจของกระบวนการนั้น (เมื่อกระบวนการนั้นได้ทำงานจนเสร็จสมบูรณ์แล้ว)

เงื่อนไขในการติดวงจรอับ (Necessary Conditions) วงจรรอคอย (Circular Wait) เซตของกระบวนการ ที่กำลังรอคอยทรัพยากร (P0, P1, … , Pn) P0 กำลังรอคอยทรัพยากรที่ถือครองโดย P1 P1 กำลังรอคอยทรัพยากรที่ถือครองโดย P2 , … Pn-1 กำลังรอคอยทรัพยากรที่ถือครองโดย Pn และ Pn ก็กำลังรอคอยทรัพยากรที่ถือครองโดย P0

วงจรรอคอย (Circular Wait)

เงื่อนไขในการติดวงจรอับ (Necessary Conditions) ต้องมีเงื่อนไขทั้ง 4 ข้อนี้ครบ จึงจะเกิดวงจรอับได้ เงื่อนไขทั้ง 4 ไม่ได้เป็นอิสระต่อกันอย่างแท้จริง เช่น วงจรรอคอย จะเกิดจากการที่มีเงื่อนไข การถือครองแล้วรอคอย ในระบบ

กราฟการจัดสรรทรัพยากร (Resource-Allocation Graph)
กราฟทางเดียว (direct graph)  กราฟการจัดสรรทรัพยากร(resource-allocation graph) เซตของ Node (V) Process (P) Resource (R) เซตของ Edge (E)

P = { P1, P2, … , Pn} เป็นเซตของกระบวนการทั้งหมดที่มีอยู่ในระบบ R = { R0, R1, … , Rn } เป็นเซตของทรัพยากรที่มีอยู่ในระบบ กระบวนการ Pi ร้องขอใช้ทรัพยากรไปยัง Rj (PiRj) เรียกว่า “เส้นร้องขอ” (Request Edge) ทรัพยากร Rj ถูกถือครองโดยกระบวนการ Pi (RjPi) เรียกว่า “เส้นถือครอง” (Assignment Edge)

แทนกระบวนการ แทนทรัพยากร  แทนจำนวนทรัพยากรแต่ละตัวซึ่งจะอยู่ภายในสี่เหลี่ยม เส้นร้องขอจะต้องชี้ไปยังกรอบสี่เหลี่ยม (ทรัพยากร; Rj) เท่านั้น เส้นถือครองจะต้องชี้ไปยังจุดใดจุดหนึ่งในสี่เหลี่ยม

Process Resource Type with 4 instances Pi requests instance of Rj Pi is holding an instance of Rj Pi Pi

กราฟการจัดสรรทรัพยากรในรูปข้างต้น แสดงสถานะของระบบ ดังนี้ เซต 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 ตัว

สถานะของกระบวนการ กระบวนการ P1 กำลังถือครองทรัพยากรประเภท R2 และกำลังรอคอยที่จะใช้ทรัพยากรประเภท R1 กระบวนการ P2 กำลังถือครองทรัพยากรประเภท R1 และ R2 และกำลังรอคอยที่จะใช้ทรัพยากรประเภท R3 กระบวนการ P3 กำลังถือครองทรัพยากรประเภท R3 อยู่

ถ้าเป็นระบบที่ทรัพยากรแต่ละประเภทมีเพียง 1 ตัว เมื่อมีวงจรในกราฟ ก็จะต้องมีวงจรอับในระบบแน่นอน ถ้าทรัพยากรแต่ละประเภทมีจำนวนมากกว่า 1 ตัว วงจรที่เกิดขึ้นในกราฟ ไม่อาจเป็นตัวบอกได้เสมอไปว่า เกิดวงจรอับในระบบ สมมติว่ากระบวนการ P3 ได้ร้องขอทรัพยากรประเภท R2 แต่เนื่องจากไม่มีทรัพยากรตัวใด ในประเภท R2 ว่างเลย เส้นร้องขอ P3  R2 จึงถูกใส่เพิ่ม เข้าไปในกราฟ

ณ จุดนี้ จะเกิดวงจรอย่างน้อย 2 วง ขึ้นในระบบ คือ P1  R1  P2  R3  P3  R2  P1 P2  R3  P3  R2  P2

ทำให้เกิดวงจรอับกับกระบวนการ P1 , P2 และ P3 กระบวนการ P2 กำลังรอคอยทรัพยากรประเภท R3 ซึ่งถูกถือครอง โดยกระบวนการ P3 กระบวนการ P3 ก็กำลังร้องขอทรัพยากรประเภท R2 ซึ่งถูกถือครอง โดยกระบวนการ P1 และ P2 กระบวนการ P3 กำลังรอคอยให้ P1 หรือ P2 คืนทรัพยากรประเภท R2 กลับสู่ระบบ

จะเห็นว่ามี วงจร P1  R1  P3  R2  P1

วงจรนี้จะไม่ก่อให้เกิดวงจรอับ ถ้ากระบวนการ P4 จะปล่อยทรัพยากร R2 ที่ตนเองถือครองอยู่เมื่อใช้เสร็จ ทรัพยากร R2 ถูกปล่อยกลับสู่ระบบ ระบบจะจัดทรัพยากร R2 ให้แก่กระบวนการ P3 ได้ วงจรก็จะขาดทันที สรุปได้ว่า ถ้าไม่มีวงจรในกราฟการจัดสรรทรัพยากรแล้ว ระบบจะไม่อยู่ในสถานะวงจรอับ ถ้ามีวงจรในกราฟ ระบบอาจจะเกิดวงจรอับหรือไม่เกิดก็ได้ กรณีทรัพยากรแต่ละประเภทมีมากกว่า 1 ตัว

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

การป้องกันการเกิดวงจรอับ (Deadlock Prevention)
ป้องกันเงื่อนไขการเกิดวงจรอับ 4 ประการ Mutual exclusion Hold and wait No preemption Circular wait ป้องกันเพียงข้อใดข้อหนึ่ง ก็สามารถป้องกันวงจรอับไม่ให้เกิดขึ้นได้

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

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

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

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

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

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

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

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

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

ในทางตรงกันข้าม ถ้ากระบวนการต้องการร้องขอทรัพยากรประเภท Rj กระบวนการจะต้องปล่อยทรัพยากร Ri คืนสู่ระบบก่อน เช่นถือครอง R5 อยู่อยากได้ R1 ต้องคืน R5 ก่อน ; R5  R1 การกำหนดค่าเลขลำดับของทรัพยากร ควรเรียงตามลำดับการใช้งานตามปกติในระบบ เช่น ปกติเรามักใช้เทปก่อนเครื่องพิมพ์เสมอ จึงควรกำหนดลำดับให้ F(เทป) < F (เครื่องพิมพ์)

Deadlock Example /* thread one runs in this function */ void *do_work_one(void *param) { pthread_mutex_lock(&first_mutex); pthread_mutex_lock(&second_mutex); /** * Do some work */ pthread_mutex_unlock(&second_mutex); pthread_mutex_unlock(&first_mutex); pthread_exit(0); } /* thread two runs in this function */ void *do_work_two(void *param) { /** * Do some work */ pthread_mutex_unlock(&first_mutex); pthread_mutex_unlock(&second_mutex);

Deadlock Example with Lock Ordering
void transaction(Account from, Account to, double amount) { mutex lock1, lock2; lock1 = get_lock(from); lock2 = get_lock(to); acquire(lock1); acquire(lock2); withdraw(from, amount); deposit(to, amount); release(lock2); release(lock1); } Transactions 1 and 2 execute concurrently. Transaction 1 transfers $25 from account A to account B, and Transaction 2 transfers $50 from account B to account A

การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance)
ต้องมีข้อมูลการร้องขอทรัพยากรในระบบโดยรวม กระบวนการต้องประกาศทรัพยากรสูงสุดแต่ละประเภทที่ต้องการ ตรวจดูสถานะของการจัดสรรทรัพยากรของระบบ ทรัพยากรทั้งหมด จำนวนทรัพยากรที่ถูกจัดสรรให้กระบวนการ ความต้องการสูงสุดของกระบวนการ ระบบจะอยู่สถานะปลอดภัยถ้ากระบวนการเสร็จโดยไม่เกิดวงจรอับ

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

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

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

ความต้องการปัจจุบัน (Current Needs)
การหลีกเลี่ยงวงจรอับ (Deadlock Avoidance) กระบวนการ (Process) ความต้องการสูงสุด (Maximum Needs) ความต้องการปัจจุบัน (Current Needs) P0 P1 P2 10 4 9 5 2 ณ เวลา T0 ลำดับกระบวนการ < P1, P0 , P2 > แสดงว่า ระบบอยู่ในสถานะปลอดภัย

ระบบอาจจะเปลี่ยนจากสถานะปลอดภัยไปเป็นสถานะไม่ปลอดภัยได้ เช่น สมมติว่า ณ เวลา T1 กระบวนการ P2 ร้องขอเทปเพิ่มอีก 1 เครื่องและได้รับการจัดสรรจะทำให้สถานะของระบบกลายเป็นสถานะไม่ปลอดภัยทันที ทำให้ P1 ได้รับทรัพยากรและทำงานเสร็จเพียงกระบวนการเดียว โดยคืนกลับสู่ระบบเพียง 4 เครื่อง ซึ่งไม่เพียงพอต่อกระบวนการ P0 และ P2 ไม่สามารถหาลำดับของกระบวนการที่ปลอดภัยได้

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

อัลกอริทึมของกราฟการจัดสรรทรัพยากร (Resource-Allocation Graph Algorithm)
ใช้กราฟการจัดสรรทรัพยากร เพิ่มเส้นความต้องการ (Claim Edge) คือ ในอนาคตกระบวน Pi ร้องขอ Rj เขียนแทนด้วย Pi Rj เส้นความต้องการมีทิศทางเดียวกันกับเส้นร้องขอ เส้นความต้องการจะแสดงด้วยเส้นประ แต่เส้นร้องขอแสดงด้วยเส้นทึบ

สมมติว่ากระบวนการ Pi ได้ร้องขอทรัพยากรประเภท Rj ระบบจะอนุมัติการร้องขอนี้ ถ้าการเปลี่ยน PiRj ไปเป็น RjPi แล้ว ไม่ทำให้เกิดวงจรขึ้น กระบวนการนั้นจะต้องรอระบบมีทรัพยากรมากขึ้น เมื่อพบว่า เส้นถือครองที่เกิดใหม่ทำให้เกิดวงจร เส้นถือครองของกระบวนการที่ร้องขอจะไม่ก่อให้เกิดวงจร ถ้าไม่มีวงจรในกราฟ การอนุมัติทรัพยากรจะทำให้ระบบอยู่ในสถานะปลอดภัย ถ้าเกิดมีวงจรในกราฟแล้วการอนุมัติทรัพยากร จะทำให้ระบบอยู่ในสถานะไม่ปลอดภัย

สมมติว่า P2 ร้องขอ R2 ระบบจะไม่อนุมัติถึงแม้ว่าทรัพยากร R2 จะว่างอยู่ก็ตาม ถ้าระบบอนุมัติ ; R2P2 จะก่อให้เกิดวงจรในกราฟ

ทำให้ระบบอยู่ในสถานะไม่ปลอดภัย โดยอาจเกิดวงจรอับขึ้นในระบบ ถ้ากระบวนการ P1 เกิดร้องขอ R2 กระบวนการ P2 ร้องขอ R1

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

ระบบต้องเก็บโครงสร้างข้อมูลหลายตัวเพื่อใช้ โครงสร้างข้อมูลเหล่านี้ เป็นตัวบอกสถานะของการจัดสรรทรัพยากรในระบบ กำหนดให้ n เป็นจำนวนกระบวนการในระบบ m เป็นจำนวนของประเภททรัพยากร

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

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]

ขั้นตอนวิธีตรวจดูสถานะปลอดภัย (Safety Algorithm)
ขั้นตอนวิธีการตรวจสอบว่าระบบอยู่ในสถานะปลอดภัยหรือไม่ ดังนี้ กำหนดให้ Work และ Finish เป็นเวคเตอร์ขนาด m และ n ตามลำดับ

1. Initialize: Work = Available Finish [i] = false for i = 0, 1, …, n- 1 2. Find an i such that both: (a) Finish [i] = false (b) Needi  Work If no such i exists, go to step 4

3. Work = Work + Allocationi Finish[i] = true go to step 2 4. If Finish [i] == true for all i, then the system is in a safe state

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

ขั้นที่ 2 ถ้า Requesti > Available ให้ Pi รอจนกว่าทรัพยากรที่ร้องขอจะว่าง จากนั้นจึงไปทำงานในขั้นตอนที่ 3 ถ้า Requesti  Available จะไปทำงานในขั้นตอนที่ 3 ทันที

ขั้นที่ 3 ระบบจะสมมติว่าได้จัดสรรทรัพยากรให้ตามที่กระบวนการ Pi ร้องขอมา โดยระบบจะมีสถานะเปลี่ยนไปดังนี้ Available := Available – Requesti; Allocationi := Allocationi + Requesti; Needi := Needi – Requesti;

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

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

ตัวอย่าง Allocation Max Available A B C P0 P1 P2 P3 P4 0 1 0 2 0 0
3 0 2 2 1 1 0 0 2 7 5 3 3 2 2 9 0 2 2 2 2 4 3 3 3 3 2

ตัวอย่าง เนื่องจากเมทริกซ์ Need เกิดจาก Max – Allocation ดังนั้นจะได้ว่า Need A B C P0 P1 P2 P3 P4 7 4 3 1 2 2 6 0 0 0 1 1 4 3 1

ตัวอย่าง เราพบว่า ระบบอยู่ในสถานะปลอดภัยเนื่องจากกระบวนการอาจทำงานได้ตามลำดับ <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)

ตัวอย่าง Available := Available – Requesti;
เมื่อผ่าน 2 ขั้นแรกแล้ว ระบบจะมีสถานะเปลี่ยนไปดังนี้ Available := Available – Requesti; Allocationi := Allocationi + Requesti; Needi := Needi – Requesti;

ตัวอย่าง เมื่อผ่าน 2 ขั้นแรกแล้ว ระบบก็จะสมมติว่า ได้จัดสรรทรัพยากรให้ตามที่ร้องขอ ทำให้ระบบมีสถานะใหม่ดังนี้ Allocation Need Available A B C P0 P1 P2 P3 P4 0 1 0 3 0 2 2 1 1 0 0 2 7 4 3 0 2 0 6 0 0 0 1 1 4 3 1 2 3 0

ตัวอย่าง จากนั้นก็จะตรวจสอบว่าสถานะใหม่นี้จะเป็นสถานะปลอดภัยหรือไม่ โดยใช้ขั้นตอนวิธีสถานะปลอดภัย (safety algorithm) พบว่า กระบวนการอาจทำงานได้ ตามลำดับ <P1, P3, P4, P0, P2> ซึ่งเป็นไปตามเงื่อนไขของสถานะปลอดภัย เมื่อเป็นเช่นนี้ ระบบจะสามารถอนุมัติการร้องขอของ P1 ได้ ในบางกรณี ระบบอาจไม่อนุมัติการร้องขอของกระบวนการเพิ่ม แม้ว่าจะมีทรัพยากรพอ เพราะว่าเมื่อระบบลองสมมติว่าได้จัดสรรทรัพยากรให้ตามที่ขอแล้วพบว่าสถานะใหม่เป็นสถานะไม่ปลอดภัย

การตรวจหาวงจรอับ (Deadlock Detection)
ถ้าในระบบปฏิบัติการไม่มีการป้องกันหรือหลีกเลี่ยงวงจรอับแล้ว ในที่สุดระบบก็อาจจะตกอยู่ในสถานะวงจรอับได้ ดังนั้นระบบจึงจำต้องมีวิธีอื่นทดแทน ขั้นตอนวิธีที่จะตรวจหาวงจรอับในระบบว่าเกิดขึ้นแล้วหรือยัง ขั้นตอนวิธีในการแก้ไขวงจรอับ

ระบบที่มีทรัพยากรแต่ละประเภทเพียงตัวเดียว (Single Instance of Each Resource Type)
นำกราฟการจัดสรรทรัพยากรมาแปลงสภาพเล็กน้อยเป็นกราฟการรอคอยทรัพยากร (Wait-for-Graph) ทำโดยเอาสี่เหลี่ยมที่แทนทรัพยากรออก และยุบรวมลูกศรเข้าด้วยกัน ดังนี้ ถ้ามีลูกศรจาก Pi  Pj ในกราฟการรอคอยทรัพยากร แสดงว่า Pi กำลังรอทรัพยากรซึ่ง Pj ถือครองอยู่

(a) เป็นต้นแบบกราฟการจัดสรรทรัพยากร (b) แปลงเป็นกราฟการรอคอยทรัพยากร

ถ้าในกราฟการรอคอยทรัพยากรมีวงจรแล้วก็จะเกิดวงจรอับ ในทางกลับกัน ถ้าเกิดวงจรอับแล้ว ก็จะมีวงจรในกราฟการรอคอยทรัพยากร ระบบต้องเก็บข้อมูลของกราฟการรอคอยทรัพยากรไว้ และใช้ขั้นตอนวิธีการตรวจหาวงจรในกราฟ เพื่อตรวจหาวงจรอับในระบบ โดยคอยตรวจดูทุก ๆ ช่วงเวลา

ระบบที่มีทรัพยากรแต่ละประเภทหลายตัว (Several Instances of a Resource Type)
ขั้นตอนวิธีในการตรวจหาวงจรอับนี้คล้ายกับ Banker’s Algorithm ซึ่งจำเป็นต้องใช้โครงสร้างข้อมูลดังต่อไปนี้ Available : เวคเตอร์ขนาด m แสดงจำนวนทรัพยากรแต่ละชนิด ที่ยังว่างอยู่ (ไม่ได้ถูกกระบวนการใดถือครองอยู่) Allocation : เมทริกซ์ n x m ใช้เก็บค่าจำนวนทรัพยากรแต่ละชนิดที่กระบวนการแต่ละตัวถือครองอยู่ Request : เมทริกซ์ n x m ใช้เก็บค่าจำนวนทรัพยากรแต่ละชนิดที่กระบวนการแต่ละตัวกำลังร้องขอ

ขั้นตอนวิธีตรวจหาวงจรอับ 1. Work := Available; 2. FOR i:= 1 TO n DO IF Allocationi 0 THEN Finish[i] := FALSE ELSE Finish[i] := TRUE;

WHILE i n DO BEGIN IF Finish[i] = FALSE AND Request[i]  Work THEN BEGIN Work := Work + Allocationi; Finish[i] := TRUE; i := i+1; END ELSE i := i+1; END;

4. FOR i=1 TO n DO IF Finish[i] = FALSE THEN process Pi is in a deadlocked. 5. IF Finish[i] = TRUE ทั้งหมด แสดงว่าขณะนี้ระบบไม่เกิดวงจรอับ.

ตัวอย่าง ระบบมี 5 กระบวนการ P0 , P1 , P2 , P3 และ P4
มีทรัพยากรชนิด A 7 ตัว , ชนิด B 2 ตัว , ชนิด C 6 ตัว ณ เวลา T0 ระบบอยู่ในสถานะดังนี้ Allocation Request Available A B C P0 P1 P2 P3 P4 0 1 0 2 0 0 3 0 3 2 1 1 0 0 2 0 0 0 2 0 2 1 0 0

ตัวอย่าง สรุปได้ว่า ขณะนี้ไม่มีวงจรอับเกิดขึ้นหรือระบบไม่ได้อยู่ในสถานะวงจรอับ โดยการดำเนินตามขั้นตอนวิธีตรวจหาวงจรอับ (Deadlock Detection) พบว่ามีลำดับการทำงานหนึ่ง คือ <P0 , P2 , P3 , P1 , P4> ซึ่งจะให้ Finish [i] = TRUE ทั้งหมด

ตัวอย่าง สมมติว่ากระบวนการ P2 ร้องขอทรัพยากรประเภท C เพิ่มอีก 1 ตัว สถานะของระบบจะกลายเป็น พบว่ามีวงจรอับเกิดขึ้นในระบบ แม้ว่า P0 อาจทำงานเสร็จ แล้วคืนทรัพยากรชนิด Bสู่ระบบ กระบวนการอื่น ๆ ก็ไม่อาจทำงานต่อได้ เพราะทรัพยากรที่ว่างอยู่ ไม่พอตามคำร้องขอ ดังนั้นระบบจึงตกอยู่ในสถานะวงจรอับ โดยมีกระบวนการ P1 , P2 , P3 และ P4 อยู่ในวงจรอับ Request A B C P0 P1 P2 P3 P4 0 0 0 2 0 2 0 0 1 1 0 0 0 0 2

การใช้วิธีการตรวจหาวงจรอับ (Detection-Algorithm Usage)
เราจะใช้วิธีการตรวจหาวงจรอับ เมื่อใดบ้าง ขึ้นอยู่กับ 2 ปัจจัย คือ 1. ความถี่ของการเกิดวงจรอับในระบบ 2. จำนวนกระบวนการที่ติดอยู่ในวงจรอับ วงจรอับจะเกิดขึ้นเมื่อมีเหตุการณ์ที่บางกระบวนการร้องขอทรัพยากรแล้วระบบไม่สามารถอนุมัติให้ได้ทันที เราจึงอาจตรวจหาวงจรอับโดยตรวจทุกครั้งที่เหตุการณ์นี้เกิดขึ้น การตรวจหาวงจรอับบ่อยเกินไป ย่อมทำให้เสียค่าใช้จ่าย(เวลา)มาก เพื่อที่จะประหยัดค่าใช้จ่าย เราอาจตรวจหาทุก ๆ ช่วงเวลาแทน

การแก้ไขวงจรอับ (Recovery from Deadlock)
เมื่อตรวจพบว่าเกิดวงจรอับขึ้นในระบบแล้ว ระบบอาจจัดการได้ 2 วิธี คือ 1. รายงานให้ผู้ควบคุมทราบว่าขณะนี้เกิดวงจรอับขึ้นในระบบแล้ว และให้ผู้ควบคุมจัดการแก้ไขวงจรอับเอง 2. ระบบแก้ไขวงจรอับเองโดยอัตโนมัติ ยกเลิกกระบวนการที่ติดอยู่ในวงจรอับบางกระบวนการ อนุญาตให้มีการแทรกกลางคันทรัพยากรบางส่วนที่ติดอยู่ในวงจรอับได้

การยกเลิกกระบวนการ (Process Termination)
การยกเลิกกระบวนการในวงจรอับ มีอยู่ 2 วิธี (เมื่อกระบวนการถูกยกเลิก ทรัพยากรที่กระบวนการถือครองอยู่จะคืนกลับสู่ระบบ) ยกเลิกกระบวนการทั้งหมดที่ติดอยู่ในวงจรอับ ค่าใช้จ่ายสูงแต่แก้ไขได้แน่นอน ยกเลิกกระบวนการในวงจรอับทีละกระบวนการ จนกระทั่งระบบกลับสู่สภาวะปกติ ค่าใช้จ่ายสูง ตรวจสอบสถานะวงจรอับใหม่

สำหรับวิธีการยกเลิกกระบวนการทีละตัว
กระบวนการที่ถูกยกเลิกจะต้องก่อให้เกิดค่าใช้จ่ายน้อยสุด การพิจารณาค่าใช้จ่ายต่ำที่สุด อาจพิจารณาได้จากหลายปัจจัยดังนี้ ลำดับความสำคัญของกระบวนการ (Priority) กระบวนการนั้นทำงานมานานเท่าไรแล้ว และจะใช้เวลาอีกนานเท่าไรกว่างานจะเสร็จสมบูรณ์ กระบวนการนั้นได้ถือครองหรือใช้ทรัพยากรประเภทใดไปเท่าไร กระบวนการยังต้องการทรัพยากรอีกเท่าไร จึงจะทำงานจนเสร็จสมบูรณ์ได้ มีกี่กระบวนการที่จะต้องถูกยกเลิก กระบวนการเป็นประเภทใด (แบบโต้ตอบ (interactive) หรือแบบกลุ่ม(batch))

(Resource Preemption)
การแทรกกลางคัน (Resource Preemption) ในการเลือกใช้วิธีการแทรกกลางคัน เราจะต้องพิจารณาผลที่จะเกิด 3 ข้อดังนี้ การเลือกผู้รับเคราะห์ (Selection a victim) โดยการเลือกว่ากระบวนการใดจะถูกแทรกกลางคันแล้ว จะเสียค่าใช้จ่ายน้อยที่สุด จำนวนทรัพยากรที่ถือครอง, ระยะเวลาที่ทำงานไปแล้ว การถอยกลับ (Rollback) ให้กระบวนการนั้นถอยกลับไปอยู่ในจุดที่ปลอดภัย และให้เริ่มทำงานใหม่อีกครั้งจากจุดนี้ ถอยกลับไปที่จุดเริ่มต้น ถอยกลับไปเท่าที่จำเป็นในการแก้ไข การแช่เย็น (Starvation) เช่น มีกระบวนการหนึ่งถูกแทรกกลางคันทรัพยากรที่กำลังใช้อยู่เสมอ ๆ

การจัดการปัญหาวงจรอับโดยวิธีผสมผสาน (Combined Approach to Deadlock Handling)
จัดแบ่งกลุ่มทรัพยากรและเลือกวิธีที่เหมาะสม มีประสิทธิภาพสูงสุดสำหรับแต่ละกลุ่ม เราอาจพิสูจน์ได้ว่าระบบที่ใช้วิธีผสมผสานนี้จะไม่เกิดวงจรอับ ดังนี้คือ วงจรอับไม่อาจจะเกิดข้ามกลุ่มของทรัพยากรได้ เพราะเราใช้วิธีการจัดเรียงลำดับทรัพยากร ในแต่ละกลุ่มก็จะไม่เกิดวงจรอับเพราะเราได้เลือกวิธีจัดการที่กล่าวมาแล้ว ดังนั้นระบบโดยรวมจะไม่เกิดวงจรอับ

ตัวอย่าง สมมติว่าระบบของเราประกอบไปด้วยทรัพยากร 4 ประเภท คือ
ทรัพยากรภายในของระบบ (Internal Resources) ทรัพยากรที่ระบบใช้เอง เช่น PCB (Process Control Block) หน่วยความจำหลัก (Main Memory) ผู้ใช้ระบบต้องใช้ อุปกรณ์ต่าง ๆ ในระบบ (Job Resources) หน่วยความจำสำรอง (Swappable space) พื้นที่ในการบันทึก (Backing Store) สำหรับสำรองแต่ละงาน

ตัวอย่าง จัดแบ่งกลุ่มของทรัพยากรเป็น 4 กลุ่ม ตามที่กล่าวมาและในแต่ละกลุ่มใช้วิธีจัดการดังนี้ ทรัพยากรภายในของระบบ ป้องกันโดยการจัดลำดับทรัพยากร เพราะกระบวนการที่ร้องขอเป็นกระบวนการภายในของระบบเอง หน่วยความจำหลัก ป้องกันโดยการให้มีการแทรกกลางคันได้ เพราะอาจย้ายงานออกจากหน่วยความจำหลักไปเก็บไว้ในหน่วยความจำสำรอง (Backing Store) เมื่อมีกระบวนการต้องการใช้หน่วยความจำเพิ่ม และหน่วยความจำเต็มแล้ว

ตัวอย่าง อุปกรณ์ต่าง ๆ ในระบบ ใช้วิธีการหลีกเลี่ยง เพราะข้อมูลเกี่ยวกับความต้องการสูงสุดของแต่ละงานอาจรู้ล่วงหน้าได้ เช่น จากบัตรควบคุมงาน (Job Control Card) กรณีที่ใช้บัตรเจาะรู (Punch cards) หน่วยความจำสำรอง ป้องกันโดย การจัดสรรล่วงหน้า เพราะจำนวนหน่วยความจำสำรองสูงสุดของแต่ละงาน มักจะถูกกำหนดไว้แล้ว

DEADLOCKS Advanced Operating System Operating System Technology

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

งานนำเสนอเรื่อง: "DEADLOCKS Advanced Operating System Operating System Technology"— ใบสำเนางานนำเสนอ:

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

เรื่องโครงการ

การติดต่อกลับ

เข้าสู่ระบบ

ลงทะเบียนผ่านเครือข่ายสังคม:

DEADLOCKS Advanced Operating System Operating System Technology

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

งานนำเสนอเรื่อง: "DEADLOCKS Advanced Operating System Operating System Technology"— ใบสำเนางานนำเสนอ:

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

เรื่องโครงการ

การติดต่อกลับ