การจัดการกระบวนการ (คอมพิวเตอร์)

จากวิกิพีเดีย สารานุกรมเสรี
ข้ามไปที่การนำทาง ข้ามไปที่การค้นหา

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

มัลติโปรแกรมมิ่ง

ในระบบปฏิบัติการสมัยใหม่ใดๆ สามารถโหลดโปรแกรมในหน่วยความจำได้มากกว่าหนึ่งอินสแตนซ์ในเวลาเดียวกัน ตัวอย่างเช่น ผู้ใช้มากกว่าหนึ่งรายสามารถเรียกใช้โปรแกรมเดียวกันได้ ผู้ใช้แต่ละคนมีสำเนาของโปรแกรมแยกต่างหากที่โหลดลงในหน่วยความจำ สำหรับบางโปรแกรม เป็นไปได้ที่จะโหลดสำเนาหนึ่งชุดลงในหน่วยความจำ ในขณะที่ผู้ใช้หลายคนได้แชร์การเข้าถึงเพื่อให้แต่ละโปรแกรมสามารถรันโค้ดโปรแกรมเดียวกันได้ โปรแกรมดังกล่าวจะกล่าวว่าเป็นอีกครั้งที่ผู้เข้าแข่งขัน ประมวลผลในชั่วพริบตาสามารถดำเนินการได้เพียงคำสั่งเดียวจากโปรแกรมเดียว แต่หลายกระบวนการสามารถคงอยู่ได้ในช่วงระยะเวลาหนึ่ง โดยกำหนดแต่ละกระบวนการให้กับโปรเซสเซอร์เป็นระยะๆ ในขณะที่ส่วนที่เหลือจะไม่ทำงานชั่วคราว จำนวนของกระบวนการถูกดำเนินการในช่วงเวลาแทนในเวลาเดียวกันที่เรียกว่าการดำเนินการพร้อมกัน

multiprogrammingหรือmultitasking OS เป็นระบบการดำเนินกระบวนการต่างๆควบคู่กันไป การเขียนโปรแกรมหลายโปรแกรมต้องการให้โปรเซสเซอร์ได้รับการจัดสรรให้กับแต่ละกระบวนการเป็นระยะเวลาหนึ่งและยกเลิกการจัดสรรในช่วงเวลาที่เหมาะสม หากโปรเซสเซอร์ถูกยกเลิกการจัดสรรระหว่างการดำเนินการของกระบวนการ จะต้องดำเนินการในลักษณะที่สามารถเริ่มต้นใหม่ในภายหลังได้อย่างง่ายดายที่สุด

มีสองวิธีที่เป็นไปได้สำหรับ OS ในการควบคุมโปรเซสเซอร์อีกครั้งระหว่างการทำงานของโปรแกรม เพื่อให้ OS ดำเนินการยกเลิกการจัดสรรหรือการจัดสรร:

  1. กระบวนการเรียกระบบ (บางครั้งเรียกว่าซอฟต์แวร์ขัดจังหวะ ); ตัวอย่างเช่น คำขอ I/O เกิดขึ้นเพื่อขอเข้าถึงไฟล์บนฮาร์ดดิสก์
  2. ฮาร์ดแวร์ขัดจังหวะเกิดขึ้น ตัวอย่างเช่น มีการกดแป้นบนแป้นพิมพ์ หรือหมดเวลา (ใช้ในการทำงานหลายอย่างพร้อมกันล่วงหน้า )

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

การเขียนโปรแกรมหลายโปรแกรมช่วยเพิ่มประสิทธิภาพได้อย่างไร

ลักษณะทั่วไปในหมู่สังเกตกระบวนการที่เกี่ยวข้องกับโปรแกรมคอมพิวเตอร์มากที่สุดก็คือพวกเขาสลับกันระหว่างCPUรอบและI / Oรอบ สำหรับส่วนของเวลาที่จำเป็นสำหรับรอบ CPU กระบวนการจะถูกดำเนินการ คือครอบครองซีพียู ในช่วงเวลาที่จำเป็นสำหรับรอบ I/O กระบวนการนี้ไม่ได้ใช้โปรเซสเซอร์ แต่กำลังรอดำเนินการ Input/Output หรือกำลังดำเนินการ Input/Output อยู่ ตัวอย่างนี้คือการอ่านจากหรือเขียนไปยังไฟล์บนดิสก์ ก่อนที่จะมีการถือกำเนิดของmultiprogramming , คอมพิวเตอร์ดำเนินการเป็นระบบผู้ใช้คนเดียว ผู้ใช้ระบบดังกล่าวทราบอย่างรวดเร็วว่าส่วนใหญ่แล้วที่คอมพิวเตอร์ได้รับการจัดสรรให้กับผู้ใช้รายเดียว โปรเซสเซอร์ไม่ได้ใช้งาน เมื่อผู้ใช้ป้อนข้อมูลหรือโปรแกรมดีบั๊ก เป็นต้นนักวิทยาศาสตร์คอมพิวเตอร์สังเกตว่าประสิทธิภาพโดยรวมของเครื่องสามารถปรับปรุงได้โดยปล่อยให้กระบวนการอื่นใช้โปรเซสเซอร์เมื่อใดก็ตามที่กระบวนการหนึ่งกำลังรออินพุต/เอาท์พุต ในระบบuni-programmingถ้าผู้ใช้Nรันโปรแกรมโดยมีเวลาดำเนินการเป็นรายบุคคลt 1 , t 2 , ..., t N , เวลาทั้งหมด, t uni , เพื่อให้บริการNกระบวนการ (ติดต่อกัน) ของผู้ใช้Nทั้งหมดจะเป็น:

เสื้อuni = เสื้อ1 + เสื้อ2 + ... + เสื้อN .

อย่างไรก็ตาม เนื่องจากแต่ละกระบวนการใช้ทั้งรอบ CPU และรอบ I/O เวลาที่แต่ละกระบวนการใช้ CPU จริง ๆ จึงเป็นเศษเสี้ยวของเวลาดำเนินการทั้งหมดสำหรับกระบวนการเพียงเล็กน้อย ดังนั้นสำหรับกระบวนการi :

t ฉัน (ประมวลผล) « เสื้อฉัน (การดำเนินการ)

ที่ไหน

t ฉัน (ประมวลผล)เป็นกระบวนการเวลาที่ฉันใช้เวลาการใช้ซีพียูและ
t ฉัน (การดำเนินการ)เป็นเวลาดำเนินการรวมสำหรับกระบวนการ; กล่าวคือ เวลาสำหรับรอบของ CPU บวกกับรอบ I/O ที่จะดำเนินการ (ดำเนินการ) จนกว่ากระบวนการจะเสร็จสิ้น

อันที่จริง โดยปกติผลรวมของเวลาโปรเซสเซอร์ทั้งหมดที่ใช้โดยกระบวนการNแทบจะไม่มีเวลาดำเนินการใด ๆ เลยเกินกว่าเสี้ยวเวลาเล็กน้อย

ดังนั้น ในระบบ uni-programming โปรเซสเซอร์จึงไม่ได้ใช้งานในสัดส่วนที่มากของเวลา ที่จะเอาชนะการขาดประสิทธิภาพนี้ multiprogramming จะดำเนินการในขณะนี้ในระบบปฏิบัติการที่ทันสมัยเช่นLinux , UNIXและMicrosoft Windows ซึ่งช่วยให้โปรเซสเซอร์เปลี่ยนจากกระบวนการหนึ่ง X ไปเป็นอีกกระบวนการหนึ่ง Y เมื่อใดก็ตามที่ X เกี่ยวข้องกับเฟส I/O ของการดำเนินการ เนื่องจากเวลาในการประมวลผลน้อยกว่ารันไทม์ของงานเดียวมาก เวลาทั้งหมดในการให้บริการผู้ใช้Nทั้งหมดที่มีระบบมัลติโปรแกรมมิงสามารถลดลงเหลือประมาณ:

t หลาย = สูงสุด ( t 1 , t 2 , ... , t N )

การสร้างกระบวนการ

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

  • การเริ่มต้นระบบ
  • ดำเนินการเรียกระบบการสร้างกระบวนการโดยกระบวนการที่ทำงานอยู่
  • คำขอของผู้ใช้เพื่อสร้างกระบวนการใหม่
  • การเริ่มต้นของงานแบทช์

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

การสร้างกระบวนการใน UNIX และ Linux ทำได้ผ่านการเรียกระบบ fork() หรือ clone() มีหลายขั้นตอนที่เกี่ยวข้องกับการสร้างกระบวนการ ขั้นตอนแรกคือการตรวจสอบว่ากระบวนการหลักมีสิทธิ์เพียงพอในการสร้างกระบวนการหรือไม่ เมื่อตรวจสอบความถูกต้องสำเร็จ กระบวนการหลักจะถูกคัดลอกเกือบทั้งหมด โดยจะเปลี่ยนเฉพาะรหัสกระบวนการเฉพาะ กระบวนการหลัก และพื้นที่ผู้ใช้เท่านั้น แต่ละกระบวนการใหม่จะมีพื้นที่ผู้ใช้ของตัวเอง [1]

ยุติกระบวนการ

มีหลายสาเหตุในการยุติกระบวนการ:

  • ปัญหางานแบทช์หยุดการเรียนการสอน
  • ผู้ใช้ออกจากระบบ
  • กระบวนการดำเนินการตามคำขอบริการเพื่อยุติ
  • เงื่อนไขข้อผิดพลาดและข้อบกพร่อง
  • สำเร็จตามปกติ
  • เกินกำหนดเวลา
  • หน่วยความจำไม่พร้อมใช้งาน
  • การละเมิดขอบเขต ตัวอย่างเช่น: พยายามเข้าถึงองค์ประกอบที่ 11 (ไม่มีอยู่จริง) ของอาร์เรย์ 10 องค์ประกอบ
  • ข้อผิดพลาดในการป้องกัน ตัวอย่างเช่น: พยายามเขียนไปยังไฟล์แบบอ่านอย่างเดียว
  • ข้อผิดพลาดทางคณิตศาสตร์ ตัวอย่างเช่น: พยายามหารด้วยศูนย์
  • เกินเวลา; ตัวอย่างเช่น: กระบวนการรอนานกว่าค่าสูงสุดที่กำหนดไว้สำหรับเหตุการณ์
  • ความล้มเหลวของI/O
  • คำสั่งไม่ถูกต้อง; ตัวอย่างเช่น เมื่อกระบวนการพยายามเรียกใช้ข้อมูล (ข้อความ)
  • คำสั่งพิเศษ
  • การใช้ข้อมูลในทางที่ผิด
  • การแทรกแซงระบบปฏิบัติการ ตัวอย่างเช่น: เพื่อแก้ไขการหยุดชะงัก
  • ผู้ปกครองยุติเพื่อให้กระบวนการย่อยสิ้นสุดลง (การยกเลิกแบบเรียงซ้อน)
  • คำขอของผู้ปกครอง

โมเดลการจัดการกระบวนการสองสถานะ

ระบบปฏิบัติการเป็นความรับผิดชอบที่สำคัญคือในการควบคุมการดำเนินการของกระบวนการซึ่งรวมถึงการกำหนดรูปแบบการแทรกระหว่างการดำเนินการและการจัดสรรทรัพยากรให้กับกระบวนการ ส่วนหนึ่งของการออกแบบระบบปฏิบัติการคือการอธิบายพฤติกรรมที่เราต้องการให้แต่ละกระบวนการแสดง โมเดลที่ง่ายที่สุดนั้นขึ้นอยู่กับข้อเท็จจริงที่ว่ากระบวนการนั้นถูกดำเนินการโดยตัวประมวลผลหรือไม่ก็ตาม ดังนั้นกระบวนการที่อาจจะได้รับการพิจารณาให้เป็นหนึ่งในสองรัฐRUNNINGหรือไม่ได้ทำงานเมื่อระบบปฏิบัติการสร้างกระบวนการใหม่ กระบวนการนั้นในขั้นต้นจะมีป้ายกำกับว่าไม่ทำงานและวางลงในคิวในระบบในการไม่ทำงานสถานะ. กระบวนการ (หรือบางส่วนของมัน) นั้นอยู่ในหน่วยความจำหลักและรอในคิวสำหรับโอกาสในการดำเนินการ หลังจากช่วงเวลาหนึ่งกระบวนการRUNNINGในปัจจุบันจะถูกขัดจังหวะ และย้ายจากสถานะRUNNING เป็นสถานะNOT RUNNINGทำให้โปรเซสเซอร์พร้อมใช้งานสำหรับกระบวนการอื่น จากนั้น ส่วนการจัดส่งของระบบปฏิบัติการจะเลือกจากคิวของกระบวนการที่ไม่ทำงานซึ่งเป็นหนึ่งในกระบวนการที่รอการถ่ายโอนไปยังโปรเซสเซอร์ กระบวนการที่เลือกจะติดป้ายกำกับใหม่จากสถานะไม่ทำงานเป็นRUNNING สถานะและการดำเนินการจะเริ่มขึ้นหากเป็นกระบวนการใหม่หรือกลับมาทำงานต่อหากเป็นกระบวนการที่ถูกขัดจังหวะก่อนหน้านี้

จากแบบจำลองนี้ เราสามารถระบุองค์ประกอบการออกแบบบางอย่างของระบบปฏิบัติการได้:

  • จำเป็นต้องเป็นตัวแทนและติดตามแต่ละกระบวนการ
  • สถานะของกระบวนการ
  • การเข้าคิวของกระบวนการNON RUNNING

โมเดลการจัดการกระบวนการสามสถานะ

แม้ว่าทั้งสองรัฐรูปแบบการจัดการกระบวนการคือการออกแบบที่ถูกต้องสมบูรณ์สำหรับระบบปฏิบัติการกรณีที่ไม่มีการบล็อกหมายถึงรัฐที่หน่วยประมวลผลการโกหกไม่ได้ใช้งานเมื่อมีการเปลี่ยนแปลงขั้นตอนการใช้งานจากรอบการทำงานไปยังI / Oรอบ การออกแบบนี้ไม่ได้ใช้โปรเซสเซอร์อย่างมีประสิทธิภาพ สามรัฐรูปแบบการจัดการกระบวนการถูกออกแบบมาเพื่อเอาชนะปัญหานี้โดยการแนะนำของรัฐใหม่ที่เรียกว่าBLOCKEDรัฐ สถานะนี้อธิบายกระบวนการใดๆ ที่รอให้เหตุการณ์ I/O เกิดขึ้น ในกรณีนี้ เหตุการณ์ I/O อาจหมายถึงการใช้อุปกรณ์บางอย่างหรือสัญญาณจากกระบวนการอื่น สามสถานะในแบบจำลองนี้คือ:

  • กำลังทำงาน:กระบวนการที่กำลังดำเนินการอยู่
  • พร้อม:กระบวนการที่เข้าคิวและเตรียมดำเนินการเมื่อได้รับโอกาส
  • ถูกบล็อก:กระบวนการที่ไม่สามารถดำเนินการได้จนกว่าจะมีเหตุการณ์บางอย่างเกิดขึ้น เช่น การดำเนินการ I/O ให้เสร็จสิ้น

ในชั่วพริบตา กระบวนการจะอยู่ในสถานะเดียวและเพียงหนึ่งในสามสถานะเท่านั้น สำหรับคอมพิวเตอร์ตัวประมวลผลเดียว กระบวนการเดียวเท่านั้นที่สามารถอยู่ในสถานะRUNNING ได้ในทันที สามารถมีหลายกระบวนการในสถานะ READYและBLOCKEDและแต่ละสถานะเหล่านี้จะมีคิวที่เกี่ยวข้องสำหรับกระบวนการ

กระบวนการที่เข้าสู่ระบบจะต้องเข้าสู่สถานะ READYในขั้นต้นกระบวนการสามารถเข้าสู่สถานะRUNNINGผ่านสถานะ READYเท่านั้น โดยปกติกระบวนการจะออกจากระบบจากสถานะRUNNINGสำหรับแต่ละสถานะทั้งสาม กระบวนการจะใช้พื้นที่ในหน่วยความจำหลัก แม้ว่าสาเหตุของการเปลี่ยนผ่านจากสถานะหนึ่งไปยังอีกสถานะหนึ่งอาจชัดเจน แต่บางส่วนอาจไม่ชัดเจนนัก

  • RUNNING → READYสาเหตุที่พบบ่อยที่สุดสำหรับการเปลี่ยนแปลงนี้คือกระบวนการที่ทำงานอยู่ถึงเวลาสูงสุดที่อนุญาตสำหรับการดำเนินการอย่างต่อเนื่อง กล่าวคือหมดเวลาเกิดขึ้น สาเหตุอื่นๆ อาจเป็นการกำหนดระดับความสำคัญตามที่กำหนดโดยนโยบายการจัดกำหนดการที่ใช้สำหรับ Low Level Schedulerและการมาถึงของกระบวนการที่มีลำดับความสำคัญสูงกว่าในสถานะ READY
  • RUNNING → BLOCKEDกระบวนการจะเข้าสู่สถานะ BLOCKEDหากร้องขอบางสิ่งที่ต้องรอ คำขอไปยังระบบปฏิบัติการมักจะอยู่ในรูปแบบของการเรียกระบบ (เช่น การเรียกจากกระบวนการที่ทำงานอยู่ไปยังฟังก์ชันที่เป็นส่วนหนึ่งของรหัส OS) ตัวอย่างเช่น การขอไฟล์จากดิสก์หรือการบันทึกส่วนของรหัสหรือข้อมูลจากหน่วยความจำไปยังไฟล์บนดิสก์

คำอธิบายและการควบคุมกระบวนการ

แต่ละกระบวนการในระบบจะแสดงด้วยโครงสร้างข้อมูลที่เรียกว่าProcess Control Block (PCB) หรือ Process Descriptor ในLinuxซึ่งทำหน้าที่เดียวกันกับหนังสือเดินทางของผู้เดินทาง PCB มีข้อมูลพื้นฐานเกี่ยวกับงาน ได้แก่ :

  • มันคืออะไร
  • จะไปไหน
  • ประมวลผลเสร็จไปเท่าไหร่แล้ว
  • เก็บไว้ที่ไหน
  • ได้ “ใช้” ทรัพยากรไปเท่าไร

การระบุกระบวนการ : แต่ละกระบวนการจะถูกระบุโดยไม่ซ้ำกันโดยการระบุตัวตนของผู้ใช้และตัวชี้ที่เชื่อมต่อกับตัวอธิบาย

สถานะกระบวนการ : แสดงสถานะปัจจุบันของกระบวนการ READY , วิ่ง , บล็อก , พร้อมระงับ , BLOCKED ระงับ

สถานะกระบวนการ : ประกอบด้วยข้อมูลทั้งหมดที่จำเป็นในการระบุสถานะปัจจุบันของงาน

การบัญชี : ประกอบด้วยข้อมูลที่ใช้เป็นหลักในการเรียกเก็บเงินและเพื่อการวัดประสิทธิภาพ ซึ่งบ่งชี้ว่ากระบวนการใช้ทรัพยากรประเภทใดและนานเท่าใด

โหมดโปรเซสเซอร์

โปรเซสเซอร์ร่วมสมัยรวมบิตโหมดเพื่อกำหนดความสามารถในการดำเนินการของโปรแกรมในตัวประมวลผล บิตนี้สามารถตั้งค่าให้โหมดเคอร์เนลหรือโหมดผู้ใช้โหมดเคอร์เนลยังเป็นปกติจะเรียกว่าโหมดผู้บังคับบัญชา , โหมดจอภาพหรือแหวน 0

ในโหมดเคอร์เนล โปรเซสเซอร์สามารถดำเนินการทุกคำสั่งในละครฮาร์ดแวร์ ในขณะที่ในโหมดผู้ใช้ จะสามารถดำเนินการได้เพียงชุดย่อยของคำสั่งเท่านั้น คำสั่งที่สามารถดำเนินการได้เฉพาะในโหมดเคอร์เนลเท่านั้นที่เรียกว่าเคอร์เนล คำสั่งพิเศษหรือคำสั่งที่ได้รับการป้องกัน เพื่อแยกความแตกต่างจากคำสั่งโหมดผู้ใช้ ตัวอย่างเช่นคำสั่งI/Oได้รับสิทธิพิเศษ ดังนั้น หากโปรแกรมแอปพลิเคชันทำงานในโหมดผู้ใช้ จะไม่สามารถดำเนินการI/Oของตัวเองได้ แต่จะต้องร้องขอระบบปฏิบัติการเพื่อดำเนินการI/Oแทน

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

แนวคิดของระบบเคอร์เนล

ส่วนของระบบปฏิบัติการที่สำคัญในการทำงานที่ถูกต้องของการดำเนินการในโหมดเคอร์เนลในขณะที่คนอื่น ๆซอฟแวร์ (เช่นซอฟต์แวร์ระบบทั่วไป) และโปรแกรมประยุกต์ใช้งานทั้งหมดดำเนินการในโหมดผู้ใช้นี้ความแตกต่างพื้นฐานมักจะมีความแตกต่างหักล้างไม่ได้ระหว่างระบบปฏิบัติการและอื่น ๆซอฟต์แวร์ระบบส่วนหนึ่งของระบบที่ดำเนินการในสถานะผู้ดูแลเคอร์เนลเรียกว่าเคอร์เนลหรือนิวเคลียสของระบบปฏิบัติการ. เคอร์เนลทำงานเป็นซอฟต์แวร์ที่เชื่อถือได้ ซึ่งหมายความว่าเมื่อได้รับการออกแบบและใช้งาน เคอร์เนลมีจุดประสงค์เพื่อใช้กลไกการป้องกันที่ไม่สามารถเปลี่ยนแปลงอย่างลับๆ ผ่านการกระทำของซอฟต์แวร์ที่ไม่น่าเชื่อถือซึ่งดำเนินการในพื้นที่ของผู้ใช้ ส่วนขยายของระบบปฏิบัติการทำงานในโหมดผู้ใช้ดังนั้น OS จึงไม่อาศัยความถูกต้องของส่วนต่าง ๆ ของซอฟต์แวร์ระบบสำหรับการทำงานที่ถูกต้องของระบบปฏิบัติการ ดังนั้น การตัดสินใจออกแบบพื้นฐานสำหรับฟังก์ชันใดๆ ที่จะรวมเข้ากับระบบปฏิบัติการคือต้องใช้งานในเคอร์เนลหรือไม่ หากมีการใช้งานในเคอร์เนล เคอร์เนลจะดำเนินการในพื้นที่เคอร์เนล (ผู้ดูแล) และสามารถเข้าถึงส่วนอื่น ๆ ของเคอร์เนลได้ มันจะเป็นซอฟต์แวร์ที่เชื่อถือได้โดยส่วนอื่น ๆ ของเคอร์เนล หากมีการใช้ฟังก์ชันเพื่อดำเนินการในโหมดผู้ใช้จะไม่สามารถเข้าถึงโครงสร้างข้อมูลเคอร์เนลได้ อย่างไรก็ตาม ข้อดีคือ โดยปกติแล้วจะต้องใช้ความพยายามอย่างจำกัดมากในการเรียกใช้ฟังก์ชัน แม้ว่าฟังก์ชันที่ใช้เคอร์เนลอาจใช้งานได้ง่าย แต่กลไกการดักจับและการตรวจสอบสิทธิ์ในขณะที่โทรมักจะค่อนข้างแพง รหัสเคอร์เนลทำงานได้อย่างรวดเร็ว แต่มีค่าใช้จ่ายสูงในการเรียกใช้จริง นี่เป็นจุดที่ละเอียดอ่อน แต่สำคัญ

การขอใช้บริการระบบ

มีสองเทคนิคที่โปรแกรมดำเนินการในโหมดผู้ใช้สามารถร้องขอบริการของเคอร์เนลได้:

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

ในแนวทางการส่งข้อความกระบวนการของผู้ใช้จะสร้างข้อความที่อธิบายบริการที่ต้องการ จากนั้นก็จะใช้ฟังก์ชั่นการส่งที่เชื่อถือได้ที่จะส่งข้อความไปยังที่เชื่อถือได้ของระบบปฏิบัติการ กระบวนการฟังก์ชัน send มีจุดประสงค์เดียวกับกับดัก นั่นคือจะตรวจสอบข้อความอย่างระมัดระวัง สลับโปรเซสเซอร์เป็นโหมดเคอร์เนล แล้วส่งข้อความไปยังกระบวนการที่ใช้ฟังก์ชันเป้าหมาย ในขณะเดียวกัน กระบวนการของผู้ใช้จะรอผลลัพธ์ของการร้องขอบริการพร้อมการดำเนินการรับข้อความ เมื่อกระบวนการ OS เสร็จสิ้น การดำเนินการจะส่งข้อความกลับไปยังกระบวนการของผู้ใช้

ความแตกต่างระหว่างสองวิธีมีผลที่ตามมาที่สำคัญเกี่ยวกับความเป็นอิสระของพฤติกรรม OS จากพฤติกรรมของกระบวนการแอปพลิเคชันและประสิทธิภาพที่เป็นผลลัพธ์ ตามกฎทั่วไประบบปฏิบัติการที่ใช้อินเทอร์เฟซการเรียกของระบบสามารถทำให้มีประสิทธิภาพมากกว่าระบบที่ต้องการแลกเปลี่ยนข้อความระหว่างกระบวนการที่แตกต่างกัน เป็นกรณีนี้ แม้ว่าการเรียกระบบจะต้องดำเนินการด้วยคำสั่งกับดัก นั่นคือ แม้ว่ากับดักจะค่อนข้างแพงในการดำเนินการ แต่ก็มีประสิทธิภาพมากกว่าวิธีการส่งข้อความ ซึ่งโดยทั่วไปแล้วจะมีค่าใช้จ่ายสูงที่เกี่ยวข้องกับกระบวนการมัลติเพล็กซ์, การสร้างข้อความและการคัดลอกข้อความ วิธีการเรียกระบบมีคุณสมบัติที่น่าสนใจซึ่งไม่จำเป็นต้องมีกระบวนการของระบบปฏิบัติการใดๆ กระบวนการที่ดำเนินการในโหมดผู้ใช้จะเปลี่ยนเป็นโหมดเคอร์เนลแทนเมื่อมีการเรียกใช้โค้ดเคอร์เนล และสลับกลับไปยังโหมดผู้ใช้เมื่อกลับมาจากการเรียก OS ในทางกลับกัน หาก OS ได้รับการออกแบบเป็นชุดของกระบวนการที่แยกจากกัน การออกแบบโดยทั่วไปง่ายกว่าเพื่อให้สามารถควบคุมเครื่องในสถานการณ์พิเศษได้ มากกว่าหากเคอร์เนลเป็นเพียงชุดของฟังก์ชันที่ผู้ใช้ดำเนินการ กระบวนการในโหมดเคอร์เนล แม้แต่ระบบปฏิบัติการที่ใช้โพรซีเดอร์ก็มักจะพบว่าจำเป็นต้องรวมกระบวนการของระบบอย่างน้อยสองสามอย่าง (เรียกว่าdaemonsในUNIX) เพื่อจัดการกับสถานการณ์ที่เครื่องไม่ได้ใช้งาน เช่นการตั้งเวลาและการจัดการเครือข่าย

ดูเพิ่มเติม

อ้างอิง

ที่มา

  • ระบบปฏิบัติการที่รวม Windows และ UNIX, Colin Ritchie ไอเอสบีเอ็น 0-8264-6416-5
  • ระบบปฏิบัติการ, William Stallings, Prentice Hall, (รุ่นที่ 4, 2000)
  • การเขียนโปรแกรมหลายโปรแกรม คำอธิบายกระบวนการ และการควบคุม
  • ระบบปฏิบัติการ – มุมมองสมัยใหม่, Gary Nutt, Addison Wesley, (ฉบับพิมพ์ครั้งที่ 2, 2001)
  • โมเดลการจัดการกระบวนการ การจัดกำหนดการ UNIX System V รีลีส 4:
  • ระบบปฏิบัติการสมัยใหม่ โดย Andrew Tanenbaum, Prentice Hall (ฉบับที่ 2, 2001)
  • แนวคิดระบบปฏิบัติการ, Silberschatz & Galvin & Gagne ( http://codex.cs.yale.edu/avi/os-book/OS9/slide-dir/ ), John Wiley & Sons, (รุ่นที่ 6, 2003)