ระบบย่อยการควบคุมกระบวนการในระบบปฏิบัติการ แนวคิดของกระบวนการ ระบบย่อยของระบบปฏิบัติการควบคุมกระบวนการ สถานะกระบวนการ บริบทและการจัดการกระบวนการ หน้าที่ของ PC OS สมัยใหม่

กระทรวงคมนาคมของสหพันธรัฐรัสเซีย

หน่วยงานของรัฐบาลกลางเพื่อการขนส่งทางรถไฟ

GOU VPO "DVGUPS"

แผนก: "เทคโนโลยีสารสนเทศและระบบ"

หลักสูตรการทำงาน

ในหัวข้อ "ระบบย่อยการจัดการกระบวนการ"

เสร็จสมบูรณ์โดย: Sholkov I.D.

กลุ่ม230

ตรวจสอบโดย: Reshetnikova O.V.

Khabarovsk 2010

บทนำ

1. คำอธิบายของโปรแกรม

1.1 ฟังก์ชั่น

1.2 วิธีการทางเทคนิคที่ใช้ในการสร้างโปรแกรม

1.3 มัลติเธรดและมัลติโพรเซสซิง

1.4 ลำดับความสำคัญของเธรดและกระบวนการ

1.5 วิธีการซิงโครไนซ์เธรด

1.3 โครงสร้างตรรกะของโปรแกรม

2. คู่มือผู้ใช้สำหรับการทำงานกับโปรแกรม

2.1 ข้อมูลทั่วไปและวัตถุประสงค์ของโครงการ

2.2 GUI

2.3 การทำงานกับโปรแกรม

2.4 คุณสมบัติหลักของ ProcessManager

บทสรุป

บรรณานุกรม

C # รองรับการเรียกใช้โค้ดแบบขนานผ่านมัลติเธรด เธรดคือพาธการดำเนินการอิสระที่สามารถรันพร้อมกับเธรดอื่นได้

โปรแกรม C# เริ่มต้นเป็นเธรดเดียวที่สร้างโดยอัตโนมัติโดย CLR และระบบปฏิบัติการ (เธรด "หลัก") และกลายเป็นมัลติเธรดโดยการสร้างเธรดเพิ่มเติม

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

บนคอมพิวเตอร์ตัวประมวลผลเดียว ตัวจัดกำหนดการเธรดใช้การแบ่งเวลา—สลับอย่างรวดเร็วระหว่างการดำเนินการของแต่ละเธรดที่แอ็คทีฟ สิ่งนี้นำไปสู่พฤติกรรมที่คาดเดาไม่ได้ ดังในตัวอย่างแรก โดยที่แต่ละลำดับของอักขระ 'X' และ 'Y' จะสัมพันธ์กับการแบ่งส่วนของเวลาที่จัดสรรให้กับเธรด ใน Windows XP ค่าการแบ่งเวลาทั่วไป - สิบมิลลิวินาที - จะถูกเลือกให้มากกว่าต้นทุน CPU ของการสลับบริบทระหว่างเธรด (หลายไมโครวินาที)

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

มีการกล่าวกันว่าเธรดถูกจองไว้เมื่อการดำเนินการถูกระงับเนื่องจากปัจจัยภายนอก เช่น การแบ่งเวลา ในกรณีส่วนใหญ่ เธรดไม่สามารถควบคุมเวลาและสถานที่ที่จะถูกจองไว้ก่อนได้

เธรดทั้งหมดของแอปพลิเคชันมีอยู่ภายในกระบวนการ ซึ่งเป็นโมดูลระบบปฏิบัติการที่แอปพลิเคชันกำลังทำงานอยู่

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

คุณสมบัติ Priority กำหนดระยะเวลาที่เธรดจะได้รับอนุญาตให้ดำเนินการสัมพันธ์กับเธรดอื่นในกระบวนการเดียวกัน ลำดับความสำคัญของเธรดมี 5 ระดับ: enum ThreadPriority ( ต่ำสุด ต่ำกว่าปกติ ปกติ สูงกว่าปกติ สูงสุด )

ค่าลำดับความสำคัญจะมีความสำคัญเมื่อมีการดำเนินการหลายเธรดพร้อมกัน

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

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

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

คำสั่งล็อก (aka Monitor.Enter/Monitor.Exit) เป็นตัวอย่างหนึ่งของการสร้างการซิงโครไนซ์เธรด การล็อกเป็นวิธีที่เหมาะสมที่สุดในการจัดระเบียบการเข้าถึงทรัพยากรหรือส่วนของโค้ดแบบเอกสิทธิ์เฉพาะบุคคล แต่มีงานการซิงโครไนซ์ (เช่น การส่งสัญญาณการเริ่มต้นงานไปยังเธรดที่รอ) ซึ่งการล็อกจะไม่เพียงพอและสะดวกที่สุด

Win32 API มีชุดโครงสร้างการซิงโครไนซ์ที่สมบูรณ์ และมีอยู่ใน .NET Framework เป็นคลาส EventWaitHandle, Mutex และ Semaphore บางอย่างใช้งานได้จริงมากกว่าอย่างอื่น: ตัวอย่างเช่น Mutex ทำซ้ำความสามารถในการล็อคเป็นส่วนใหญ่ ในขณะที่ EventWaitHandle ให้ความสามารถในการส่งสัญญาณที่ไม่เหมือนใคร

ทั้งสามคลาสนั้นใช้คลาสนามธรรมของ WaitHandle แต่พฤติกรรมของพวกมันค่อนข้างแตกต่างกัน คุณลักษณะทั่วไปประการหนึ่งคือความสามารถในการตั้งชื่อ ซึ่งทำให้สามารถทำงานกับเธรดได้ ไม่เพียงแต่หนึ่งรายการเท่านั้น แต่ยังรวมถึงกระบวนการที่แตกต่างกันด้วย

EventWaitHandle มีคลาสที่ได้รับมาสองคลาสคือ AutoResetEvent และ ManualResetEvent (ซึ่งไม่มีส่วนเกี่ยวข้องกับเหตุการณ์ C# และผู้รับมอบสิทธิ์) ทั้งสองคลาสมีสิทธิ์เข้าถึงฟังก์ชันทั้งหมดของคลาสพื้นฐาน ความแตกต่างเพียงอย่างเดียวคือคอนสตรัคเตอร์คลาสพื้นฐานถูกเรียกด้วยพารามิเตอร์ที่แตกต่างกัน

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

AutoResetEvent เป็นคลาส WaitHandle ที่ใช้บ่อยที่สุดและโครงสร้างการซิงโครไนซ์หลักพร้อมกับการล็อค

AutoResetEvent คล้ายกับ turnstile มาก - ตั๋วหนึ่งใบอนุญาตให้บุคคลหนึ่งคนเข้าได้ คำนำหน้า "อัตโนมัติ" ในชื่อหมายถึงข้อเท็จจริงที่ว่าประตูหมุนที่เปิดอยู่จะปิดโดยอัตโนมัติหรือ "รีเซ็ต" หลังจากที่อนุญาตให้ใครบางคนผ่าน เธรดถูกบล็อกที่ turnstile โดยเรียก WaitOne (รอ (รอ) ที่ (หนึ่ง) turnstile นี้จนกว่าจะเปิด) และตั๋วจะถูกแทรกโดยเรียก Set method หากหลายเธรดเรียก WaitOne คิวจะก่อตัวขึ้นหลังประตูหมุน ตั๋วสามารถ "แทรก" เธรดใดก็ได้ กล่าวคือ เธรดใดๆ (ไม่บล็อก) ที่เข้าถึงออบเจกต์ AutoResetEvent สามารถเรียก Set เพื่อข้ามเธรดที่ถูกบล็อกได้

ถ้า Set ถูกเรียกเมื่อไม่มีเธรดที่รอ หมายเลขอ้างอิงจะยังคงเปิดอยู่จนกว่าเธรดจะเรียก WaitOne คุณลักษณะนี้ช่วยหลีกเลี่ยงการแข่งขันระหว่างเธรดที่เข้าใกล้ turnstile และเธรดที่ใส่ตั๋ว ("อ๊ะ ตั๋วถูกแทรกก่อนเวลาไมโครวินาที ขออภัย แต่คุณจะต้องรออีกสักหน่อย!") อย่างไรก็ตาม การโทรหลายครั้งเพื่อตั้งค่าให้หมุนฟรีไม่อนุญาตให้ฝูงชนทั้งหมดผ่านในแต่ละครั้ง - มีเพียงคนเดียวเท่านั้นที่จะสามารถผ่านได้ ตั๋วอื่น ๆ ทั้งหมดจะสูญเปล่า

WaitOne ใช้พารามิเตอร์การหมดเวลาซึ่งเป็นทางเลือก - เมธอดจะส่งกลับค่าเท็จ หากการรอสิ้นสุดลงด้วยการหมดเวลา ไม่ใช่ด้วยสัญญาณ นอกจากนี้ยังสามารถฝึก WaitOne ให้ออกจากบริบทการซิงโครไนซ์ปัจจุบันเพื่อรอต่อไป (หากใช้โหมดการบล็อกอัตโนมัติ) เพื่อหลีกเลี่ยงการบล็อกมากเกินไป

วิธีการรีเซ็ตช่วยให้มั่นใจได้ว่าประตูหมุนที่เปิดอยู่ถูกปิดโดยไม่ต้องรอหรือปิดกั้น

AutoResetEvent สามารถสร้างได้สองวิธี ก่อนอื่นด้วยตัวสร้าง: EventWaitHandle wh = ใหม่ AutoResetEvent(เท็จ);

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

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

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

ปฏิสัมพันธ์ระหว่างกระบวนการดำเนินการโดยใช้ตัวแปรที่ใช้ร่วมกันและการดำเนินการพื้นฐานพิเศษที่เรียกว่า ดึกดำบรรพ์.

ระบบย่อยการจัดการกระบวนการและเธรดมีความสามารถในการดำเนินการต่อไปนี้บนกระบวนการ:

– การสร้าง (วางไข่)/การทำลายกระบวนการ;

– การระงับ / การเริ่มต้นใหม่ของกระบวนการ

– การบล็อก/ปลุกกระบวนการ;

– เริ่มกระบวนการ;

– การเปลี่ยนแปลงลำดับความสำคัญของกระบวนการ

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

1. การสร้างและการลบกระบวนการและเธรด

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

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

การสร้างและการลบงานจะดำเนินการตามคำขอที่เหมาะสมจากผู้ใช้หรือจากงานอื่นๆ งานสามารถวางไข่งานใหม่ได้ - ในหลายระบบ เธรดสามารถติดต่อ OS เพื่อขอสร้างสิ่งที่เรียกว่า ลำธารลูกหลาน งานหลักเรียกว่า "บรรพบุรุษ" "งานหลัก" และงานย่อยเรียกว่า "งานย่อย" หรือ "งานย่อย" "บรรพบุรุษ" สามารถระงับหรือลบงานย่อยได้ ในขณะที่ "ลูก" ไม่สามารถควบคุม "บรรพบุรุษ" ได้

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

หลังจากกระบวนการสิ้นสุดลง ระบบปฏิบัติการ "ล้างร่องรอย" ของการอยู่ในระบบ - จะปิดไฟล์ทั้งหมดที่กระบวนการทำงานด้วย เพิ่มพื้นที่ของ RAM ที่จัดสรรสำหรับรหัส ข้อมูล และโครงสร้างข้อมูลระบบของกระบวนการ . คิว OS และรายการทรัพยากรที่มีการอ้างอิงถึงกระบวนการที่ถูกยกเลิกจะได้รับการแก้ไข

2. กำหนดการและกระบวนการจัดส่งและเธรด

กลยุทธ์การวางแผนกำหนดกระบวนการที่ได้รับเลือกให้ดำเนินการเพื่อให้บรรลุเป้าหมาย กลยุทธ์อาจแตกต่างกัน ตัวอย่างเช่น

– ถ้าเป็นไปได้ ให้เสร็จสิ้นการคำนวณในลำดับเดียวกันกับที่เริ่ม

– ให้ความสำคัญกับกระบวนการที่สั้นกว่า

– ให้ผู้ใช้ทุกคน (งานของผู้ใช้) ได้รับบริการเดียวกัน รวมถึงเวลารอที่เท่ากัน

ในช่วงอายุของกระบวนการ การดำเนินการของเธรดสามารถถูกขัดจังหวะซ้ำแล้วซ้ำอีก

การเปลี่ยนจากการดำเนินการของเธรดหนึ่งไปอีกเธรดนั้นเป็นผลมาจาก การวางแผนและ การจัดส่ง.

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

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

การวางแผนประกอบด้วยสองงาน:

กำหนดช่วงเวลาในการเปลี่ยนเธรดที่ใช้งานอยู่

การเลือกสำหรับการดำเนินการของเธรดจากคิวของเธรดที่พร้อมใช้งาน

มีอัลกอริธึมการตั้งเวลามากมายที่แก้ปัญหาเหล่านี้ด้วยวิธีต่างๆ เป็นคุณลักษณะการวางแผนที่กำหนดลักษณะเฉพาะของระบบปฏิบัติการ ลองดูที่พวกเขาเล็กน้อยในภายหลัง

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

คงที่ประเภทของการจัดตารางเวลาสามารถใช้ในระบบพิเศษที่มีการกำหนดชุดของงานที่ดำเนินการพร้อมกันทั้งหมดไว้ล่วงหน้า (ระบบเรียลไทม์) ตัวจัดกำหนดการสร้างกำหนดการตามความรู้เกี่ยวกับลักษณะของชุดงาน ระบบปฏิบัติการจะใช้กำหนดการนี้สำหรับการจัดกำหนดการ

การจัดส่งคือการนำแนวทางแก้ไขที่พบจากการวางแผนไปปฏิบัติ กล่าวคือ ในการเปลี่ยนจากกระบวนการหนึ่งไปอีกกระบวนการหนึ่ง การจัดส่งมีดังนี้:

การบันทึกบริบทของเธรดปัจจุบันที่ต้องเปลี่ยน

เปิดตัวเธรดใหม่สำหรับการดำเนินการ

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

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

3. อัลกอริทึมการวางแผน

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

ไม่พลัดถิ่น- เธรดที่ใช้งานอยู่สามารถดำเนินการได้จนกว่าจะโอนการควบคุมไปยังระบบเพื่อเลือกเธรดอื่นที่พร้อมใช้งานจากคิว

การพลัดถิ่น– ระบบปฏิบัติการตัดสินใจเปลี่ยนงานที่กำลังทำงานอยู่และเปลี่ยนโปรเซสเซอร์เป็นเธรดอื่น

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

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

ข้อดีแนวทางนี้:

– การหยุดชะงักของการไหลในช่วงเวลาที่ไม่สะดวกสำหรับมันไม่ได้;

– ปัญหาการใช้ข้อมูลพร้อมกันหมดไปเพราะ ในแต่ละรอบการรัน งานใช้เฉพาะและแน่ใจว่าไม่มีใครสามารถเปลี่ยนแปลงได้

- ความเร็วในการเปลี่ยนจากสตรีมเป็นสตรีมเร็วขึ้น

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

อัลกอริธึมยึดเอาเสียก่อน- ประเภทการตั้งเวลาแบบวงกลมหรือแบบวงกลม ซึ่งระบบปฏิบัติการเองตัดสินใจว่าจะขัดจังหวะแอปพลิเคชันที่ใช้งานอยู่และเปลี่ยนโปรเซสเซอร์จากงานหนึ่งไปอีกงานหนึ่งตามเกณฑ์ข้อใดข้อหนึ่ง ในระบบที่มีอัลกอริธึมดังกล่าว โปรแกรมเมอร์ไม่ต้องกังวลว่าแอปพลิเคชันของเขาจะทำงานพร้อมกันกับงานอื่นๆ ตัวอย่าง ได้แก่ ระบบปฏิบัติการ UNIX, Windows NT/2000, OS/2 อัลกอริธึมของคลาสนี้เน้นไปที่การดำเนินการแอปพลิเคชันที่มีประสิทธิภาพสูง

อัลกอริธึมยึดเอาเสียก่อนสามารถยึดตามแนวคิดของการหาปริมาณหรือกลไกที่มีลำดับความสำคัญ

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

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

อัลกอริธึมเหล่านี้ไม่ได้ใช้ข้อมูลก่อนหน้านี้เกี่ยวกับงาน ความแตกต่างของบริการในกรณีนี้ขึ้นอยู่กับ "ประวัติการมีอยู่" ของโฟลว์ในระบบ

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

ตอนนี้ มาดูสาขาวิชาการวางแผนทั่วไปบางส่วนกัน

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

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

ศักดิ์ศรีของอัลกอริธึมนี้คือความง่ายในการใช้งาน ข้อเสีย– ด้วยภาระงานหนัก งานสั้น ๆ ถูกบังคับให้รอในระบบเป็นเวลานาน วิธีการต่อไปนี้ช่วยขจัดข้อบกพร่องนี้

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

อัลกอริธึมอยู่ในหมวดหมู่ของอัลกอริธึมที่ไม่มีความสำคัญ

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

ระเบียบวินัยม้าหมุน, หรือ วงกลม – RR(โรบินกลม). ระเบียบวินัยนี้เป็นของอัลกอริธึมยึดเอาเสียก่อนและขึ้นอยู่กับการหาปริมาณ งานแต่ละงานจะได้รับเวลาของตัวประมวลผลเป็นส่วนๆ - ควอนตั้ม หลังจากสิ้นสุดเวลาควอนตัม งานจะถูกลบออกจากตัวประมวลผลและวางไว้ที่ส่วนท้ายของคิวของกระบวนการที่พร้อมสำหรับการดำเนินการ และงานถัดไปจะได้รับการยอมรับสำหรับการประมวลผลโดยตัวประมวลผล เพื่อให้ระบบทำงานได้อย่างเต็มประสิทธิภาพ จำเป็นต้องเลือกกฎหมายอย่างถูกต้องตามเวลาที่กำหนดให้กับงาน

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

ในระบบปฏิบัติการบางระบบ เป็นไปได้ที่จะระบุค่าของควอนตัมเวลาหรือช่วงค่าที่อนุญาตได้อย่างชัดเจน ตัวอย่างเช่น ใน OS/2 ไฟล์ CONFIG.SYS จะระบุค่าต่ำสุดและสูงสุดสำหรับการแบ่งเวลาโดยใช้คำสั่ง TIMESLICE: TIMESLICE=32,256 ระบุว่าส่วนเวลาสามารถเปลี่ยนแปลงได้ระหว่าง 32 ถึง 256 มิลลิวินาที

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

ในการใช้งานที่ง่ายที่สุด วินัยในการให้บริการแบบหมุนจะถือว่างานทั้งหมดมีลำดับความสำคัญเท่ากัน หากจำเป็นต้องแนะนำกลไกการบริการที่มีลำดับความสำคัญ โดยปกติแล้วจะมีการจัดคิวหลายรายการ ขึ้นอยู่กับลำดับความสำคัญ และคิวที่มีลำดับความสำคัญต่ำกว่าจะได้รับบริการเมื่อคิวที่มีลำดับความสำคัญสูงกว่าว่างเปล่าเท่านั้น อัลกอริทึมนี้ใช้สำหรับจัดตารางเวลาบนระบบ OS/2 และ Windows NT

วางแผนตามลำดับความสำคัญ.

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

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

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

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

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

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

การวางแผนแบบผสมใช้ในระบบปฏิบัติการหลายระบบ: อัลกอริธึมการจัดตารางเวลาตามลำดับความสำคัญถูกรวมเข้ากับแนวคิดของการหาปริมาณ

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

• การสร้างและการลบกระบวนการ
• การกระจายทรัพยากรระบบ (หน่วยความจำ ทรัพยากรการคำนวณ) ระหว่างกระบวนการ
• การซิงโครไนซ์กระบวนการ
• การสื่อสารระหว่างกระบวนการ

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

โมดูลการจัดการหน่วยความจำ จัดสรร RAM สำหรับงานแอปพลิเคชัน ในกรณีที่มีหน่วยความจำไม่เพียงพอสำหรับกระบวนการทั้งหมด เคอร์เนลจะย้ายส่วนต่าง ๆ ของกระบวนการ
หรือหลายกระบวนการไปยังหน่วยความจำรอง (โดยปกติคือพื้นที่พิเศษของฮาร์ดดิสก์) ทำให้ทรัพยากรว่างสำหรับกระบวนการทำงาน

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

พื้นฐานการควบคุมกระบวนการ

กระบวนการ UNIX เป็นอิมเมจโปรแกรมที่เรียกใช้งานได้ซึ่งมีการแมปหน่วยความจำ - ไฟล์ปฏิบัติการที่ได้รับจากการคอมไพล์ เช่น o มีการแปลโมดูลโปรแกรมภาษาระดับสูงเป็นโมดูลโปรแกรมเทียบเท่าของภาษาระดับต่ำเช่นนี้:ข้อมูลสแต็ก รหัส และไลบรารี ตลอดจนโครงสร้างข้อมูลเคอร์เนลจำนวนหนึ่งที่จำเป็นสำหรับการควบคุมกระบวนการ ซึ่งเป็นจุดสำคัญมากสำหรับการทำความเข้าใจหลักการจัดสรรหน่วยความจำให้มากขึ้น เป็นหนึ่งในทรัพยากรที่สำคัญที่สุดใน "การแข่งขัน" ของกระบวนการ นั่นคือ data มีโครงสร้าง!, มีเงื่อนไขเมื่อ:

• กอง (c ปัจจุบัน ) เป็นพื้นที่หน่วยความจำที่โปรแกรมเก็บข้อมูลเกี่ยวกับฟังก์ชันที่เรียกว่า อาร์กิวเมนต์ และตัวแปรท้องถิ่นแต่ละตัวในฟังก์ชัน ขนาดของพื้นที่สามารถเปลี่ยนแปลงได้เมื่อโปรแกรมทำงาน เมื่อเรียกใช้ฟังก์ชัน สแต็กจะโตขึ้น และเมื่อสิ้นสุด สแต็กจะเล็กลง
• กอง (เพื่อการสอน ) เป็นพื้นที่ของหน่วยความจำที่โปรแกรมสามารถทำทุกอย่างที่ต้องการได้ ขนาดของพื้นที่สามารถเปลี่ยนแปลงได้ โปรแกรมเมอร์มีโอกาสที่จะใช้ส่วนหนึ่งของหน่วยความจำฮีพโดยใช้ฟังก์ชัน malloc() จากนั้นพื้นที่หน่วยความจำนี้จะเพิ่มขึ้น ทรัพยากรถูกส่งกลับโดยใช้ free() หลังจากนั้นฮีปจะลดลง
• รหัส (เป็นหนึ่งส่วน ) เป็นพื้นที่ของหน่วยความจำที่เก็บคำสั่งเครื่องของโปรแกรมที่คอมไพล์แล้ว คอมไพเลอร์สร้างขึ้น แต่สามารถเขียนด้วยมือได้ โปรดทราบว่าพื้นที่หน่วยความจำนี้สามารถแบ่งออกเป็นสามส่วน (ข้อความ ข้อมูล และ BSS) พื้นที่หน่วยความจำนี้มีขนาดคงที่ซึ่งกำหนดโดยคอมไพเลอร์ยูนิกซ์ การเขียนโปรแกรมมืออาชีพ art.259

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

ระบบปฏิบัติการ UNIX แรกเกิดมีเพียงสองกระบวนการ หนึ่งกระบวนการสำหรับแต่ละเทอร์มินัลที่เชื่อมต่อกับ PDP-7 หนึ่งปีต่อมา ใน PDP-7 เดียวกัน จำนวนกระบวนการเพิ่มขึ้นอย่างเห็นได้ชัด มีการเรียกระบบปรากฏขึ้น ส้อม. รุ่นแรกของ UNIX นำเสนอความท้าทาย exesแต่ระบบปฏิบัติการยังคงอนุญาตให้วางกระบวนการในหน่วยความจำได้ครั้งละหนึ่งกระบวนการเท่านั้น หลังจากการนำระบบย่อยการจัดการหน่วยความจำฮาร์ดแวร์ไปใช้ใน PDP-11 ระบบปฏิบัติการได้รับการแก้ไขเพื่อให้สามารถโหลดกระบวนการต่างๆ ลงในหน่วยความจำพร้อมกันได้ ซึ่งจะช่วยลดเวลาที่ใช้ในการจัดเก็บอิมเมจกระบวนการในหน่วยความจำรอง (บนดิสก์) และอ่านในขณะที่กระบวนการยังดำเนินการอยู่ อย่างไรก็ตาม จนถึงปี 1972 UNIX ไม่ใช่ระบบมัลติทาสก์อย่างแท้จริง เนื่องจากการดำเนินการ I/O ยังคงเป็นแบบซิงโครนัส และกระบวนการอื่นๆ ไม่สามารถรันได้จนกว่า "เพื่อนร่วมงาน" จะเสร็จสิ้นการดำเนินการ I/O การทำงานหลายอย่างที่เกิดขึ้นจริงเกิดขึ้นหลังจากโค้ด UNIX ถูกเขียนใหม่ใน C ในปี 1973 ตั้งแต่นั้นมา พื้นฐานของการจัดการกระบวนการก็ไม่เปลี่ยนแปลงมากนัก

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

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

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

ประมวลผลโครงสร้างข้อมูล

แต่ละกระบวนการจะแสดงในระบบโดยโครงสร้างข้อมูลหลักสองโครงสร้าง procและ ผู้ใช้,

อธิบายตามลำดับในไฟล์ sys/proc.hและ sys/user.h. เนื้อหาและรูปแบบของโครงสร้างเหล่านี้แตกต่างกันไปตามเวอร์ชันของ UNIX

....................................................................................................

https://m.habr.com/ru/company/*nix<-----------
….................................................................................................
โครงสร้างเหล่านี้ในเวลาใดก็ตาม procสำหรับกระบวนการทั้งหมดจะต้องอยู่ในหน่วยความจำ แม้ว่าโครงสร้างข้อมูลอื่น ๆ รวมถึงภาพกระบวนการ อาจถูกย้ายไปยังหน่วยความจำรอง พื้นที่สลับ ซึ่งช่วยให้เคอร์เนลมีข้อมูลขั้นต่ำที่จำเป็นในการค้นหาส่วนที่เหลือของข้อมูลที่เกี่ยวข้องกับกระบวนการ แม้ว่าจะไม่ได้อยู่ในหน่วยความจำก็ตาม โครงสร้าง procเป็นรายการในตารางกระบวนการของระบบซึ่งอย่างที่เราเพิ่งสังเกตเห็นว่าอยู่ใน RAM เสมอ รายการในตารางนี้สำหรับกระบวนการที่ดำเนินการอยู่ในปัจจุบันได้รับการแก้ไขโดยตัวแปรระบบ curproc ทุกครั้งที่มีการสลับบริบท เมื่อทรัพยากรของตัวประมวลผลถูกถ่ายโอนไปยังที่อื่น
กระบวนการ ค่าของตัวแปรจะเปลี่ยนแปลงไปตามนั้น Curprocซึ่งตอนนี้ชี้ไปที่โครงสร้าง procกระบวนการที่ใช้งานอยู่ โครงสร้างที่กล่าวถึงที่สอง ผู้ใช้เรียกอีกอย่างว่า u-areaหรือ u-blockมีข้อมูลเพิ่มเติมเกี่ยวกับกระบวนการที่เคอร์เนลต้องการเฉพาะในขณะที่กระบวนการกำลังทำงาน (นั่นคือ เมื่อตัวประมวลผลดำเนินการตามคำสั่งของกระบวนการในโหมดเคอร์เนลหรือโหมดงาน) ต่างจากโครงสร้าง proc, จ่าหน้าถึงโดยพอยน์เตอร์ Curproc, ข้อมูล ผู้ใช้ถูกวางไว้
(แสดงให้ชัดเจนยิ่งขึ้น) ในตำแหน่งหนึ่งในหน่วยความจำเสมือนของเคอร์เนลและระบุโดยตัวแปร ยู. โครงสร้างข้อมูลกระบวนการหลักสองแบบและวิธีที่เคอร์เนล UNIX จัดการได้แสดงไว้ด้านล่าง
ที่ u-areaเก็บข้อมูลที่ใช้โดยระบบย่อยเคอร์เนลจำนวนมากและไม่เพียง แต่สำหรับการควบคุมกระบวนการเท่านั้น โดยเฉพาะอย่างยิ่ง มันมีข้อมูลเกี่ยวกับตัวอธิบายไฟล์ที่เปิดอยู่ การจัดการสัญญาณ สถิติการดำเนินการตามกระบวนการ และค่าการลงทะเบียนที่บันทึกไว้เมื่อกระบวนการถูกระงับ เห็นได้ชัดว่ากระบวนการไม่ควรแก้ไขข้อมูลนี้โดยพลการ ดังนั้น พื้นที่ u ได้รับการปกป้องจากการเข้าถึงในโหมดงาน ดังจะเห็นได้จากรูปที่ u-areaยังมีสแต็กขนาดคงที่ สแต็กระบบ หรือเคอร์เนลสแต็ก เมื่อกระบวนการดำเนินการในโหมดเคอร์เนล ระบบปฏิบัติการจะใช้สแต็กนี้แทนสแต็กกระบวนการปกติ

สถานะกระบวนการ

วงจรชีวิตของกระบวนการสามารถแบ่งออกเป็นหลายสถานะ การเปลี่ยนแปลงของกระบวนการจากสถานะหนึ่งไปอีกสถานะหนึ่งเกิดขึ้นขึ้นอยู่กับเหตุการณ์บางอย่างในระบบ

• 1. กระบวนการทำงานในโหมดงาน ในเวลาเดียวกัน คำสั่งแอปพลิเคชันของกระบวนการนี้จะถูกดำเนินการโดยโปรเซสเซอร์
• 2. กระบวนการทำงานในโหมดเคอร์เนล ในเวลาเดียวกัน โปรเซสเซอร์จะดำเนินการตามคำสั่งของระบบเคอร์เนลระบบปฏิบัติการในนามของกระบวนการ
• 3 . กระบวนการไม่ทำงาน แต่พร้อมที่จะรันทันทีที่ตัวกำหนดตารางเวลาจะเลือกมัน (สถานะรันได้) กระบวนการอยู่ในคิวสำหรับการดำเนินการและมีทั้งหมดทรัพยากรที่จำเป็น ยกเว้นการคำนวณ
• 4. กระบวนการอยู่ในสถานะสลีป (นอนหลับ) รอให้ไม่สามารถเข้าถึงได้ช่วงเวลาปัจจุบันของทรัพยากร เช่น การเสร็จสิ้นการดำเนินการ I/O
• 5. กระบวนการส่งคืนจากโหมดเคอร์เนลเป็นโหมดงาน แต่เคอร์เนลขัดจังหวะและดำเนินการสลับบริบทเพื่อเรียกใช้กระบวนการที่มีลำดับความสำคัญสูงกว่า
• 6. กระบวนการนี้เพิ่งสร้างขึ้นโดยส้อมและอยู่ในช่วงเปลี่ยนผ่านstate: มีอยู่แล้ว แต่ไม่พร้อมที่จะรันและไม่อยู่ในสถานะสลีป
• 7. กระบวนการดำเนินการเรียกระบบออกและเข้าสู่สถานะซอมบี้ (ซอมบี้ ตาย) ดังนั้นกระบวนการจึงไม่มีอยู่ แต่บันทึกยังคงอยู่มีโค้ดส่งคืนและสถิติชั่วคราวของการดำเนินการ ซึ่งมีให้สำหรับกระบวนการหลักสถานะนี้เป็นสถานะสุดท้ายในวงจรชีวิตของกระบวนการ

ควรสังเกตว่าไม่ใช่กระบวนการทั้งหมดที่จะผ่านชุดของสถานะทั้งหมดที่ระบุไว้ข้างต้น กระบวนการเริ่มต้น เส้นทางชีวิตจากสถานะ 6 เมื่อกระบวนการหลักทำการเรียกระบบ ส้อม(). หลังจากสร้างกระบวนการเสร็จสมบูรณ์แล้ว กระบวนการจะยุติ "ลูก" ของการโทรและเข้าสู่สถานะ 3 พร้อมเปิดตัวรอคุณ
คิวดำเนินการ เมื่อตัวจัดกำหนดการเลือกกระบวนการที่จะรัน มันจะเข้าสู่สถานะ 1 และทำงานในโหมดงาน การดำเนินการในโหมดงานสิ้นสุดลงเนื่องจากการเรียกของระบบหรือการขัดจังหวะ และกระบวนการจะเข้าสู่โหมดเคอร์เนล ซึ่งจะมีการเรียกใช้ระบบหรือโค้ดขัดจังหวะ กระบวนการสามารถกลับสู่โหมดงานได้อีกครั้ง อย่างไรก็ตาม ในระหว่างการเรียกระบบในโหมดเคอร์เนล กระบวนการอาจต้องการทรัพยากรที่ไม่พร้อมใช้งานในขณะนี้ เพื่อรอการเข้าถึงทรัพยากรดังกล่าว กระบวนการเรียกฟังก์ชันเคอร์เนล นอน()และเข้านอน 4 . ในเวลาเดียวกัน กระบวนการจะปล่อยทรัพยากรการคำนวณโดยสมัครใจ ซึ่งมอบให้กับกระบวนการที่มีลำดับความสำคัญสูงสุดถัดไป เมื่อทรัพยากรพร้อมใช้งาน เคอร์เนล "ปลุกกระบวนการ" โดยใช้ฟังก์ชัน ตื่นนอน()เข้าคิวเพื่อดำเนินการและกระบวนการเข้าสู่สถานะ "พร้อมที่จะเรียกใช้" 3 .
เมื่อกระบวนการได้รับทรัพยากรการคำนวณ การสลับบริบทจะเกิดขึ้น ซึ่งเป็นผลมาจากการบันทึกภาพหรือบริบทของกระบวนการปัจจุบัน และการควบคุมจะถูกโอนไปยังกระบวนการใหม่ การสลับบริบทอาจเกิดขึ้นได้ ตัวอย่างเช่น หากกระบวนการเข้าสู่โหมดสลีป หรือหากกระบวนการที่มีลำดับความสำคัญสูงกว่าปัจจุบันพร้อมที่จะทำงาน ในกรณีหลัง เคอร์เนลไม่สามารถยุติกระบวนการปัจจุบันทันทีและดำเนินการสลับบริบท ความจริงก็คือการสลับบริบทเมื่อดำเนินการในโหมดเคอร์เนลสามารถนำไปสู่การละเมิดความสมบูรณ์ของระบบได้
ดังนั้น การสลับบริบทจะถูกเลื่อนออกไปจนกว่ากระบวนการจะเปลี่ยนจากโหมดเคอร์เนลเป็นโหมดงาน เมื่อการดำเนินการของระบบทั้งหมดเสร็จสิ้นและโครงสร้างข้อมูลเคอร์เนลอยู่ในสถานะปกติ
ดังนั้น หลังจากที่ตัวจัดกำหนดการได้เลือกกระบวนการที่จะรัน ตัวหลังก็จะเริ่ม
ดำเนินการในโหมดเคอร์เนล โดยที่การสลับบริบทสิ้นสุดลง รัฐเพิ่มเติม
กระบวนการขึ้นอยู่กับประวัติ: หากกระบวนการเพิ่งสร้างหรือถูกขัดจังหวะ กลับสู่โหมดงาน กระบวนการจะเปลี่ยนเป็นโหมดนี้ทันที หากกระบวนการเริ่มดำเนินการหลังจากสถานะสลีป กระบวนการนั้นจะยังคงทำงานในโหมดเคอร์เนล เป็นการสิ้นสุดการเรียกของระบบ โปรดทราบว่ากระบวนการดังกล่าวอาจถูกขัดจังหวะหลังจากการเรียกของระบบเสร็จสิ้น ณ จุดเปลี่ยนจากโหมดเคอร์เนลเป็นโหมดงาน หากมีกระบวนการที่มีลำดับความสำคัญสูงกว่าในคิว UNIX 4xBSD กำหนดสถานะกระบวนการเพิ่มเติม ซึ่งส่วนใหญ่เกี่ยวข้องกับระบบควบคุมงานและการโต้ตอบระหว่างกระบวนการกับเทอร์มินัล กระบวนการสามารถเข้าสู่สถานะ "หยุด" โดยใช้สัญญาณหยุด SIGSTOP, SIGTTINหรือ ซิกโตว. ซึ่งแตกต่างจากสัญญาณอื่น ๆ ซึ่งได้รับการประมวลผลเฉพาะสำหรับกระบวนการที่กำลังทำงานอยู่ การส่งสัญญาณเหล่านี้ส่งผลให้เกิดการเปลี่ยนแปลงสถานะในทันที ในกรณีนี้ หากกระบวนการกำลังทำงานหรืออยู่ในคิวเพื่อเริ่มต้น สถานะของกระบวนการจะเปลี่ยนเป็น "หยุด" หากกระบวนการอยู่ในสถานะสลีป สถานะของกระบวนการจะเปลี่ยนเป็น "หยุดในสถานะสลีป" ทางออกจากรัฐเหล่านี้ดำเนินการโดยสัญญาณต่อเนื่อง ซิกคอนด้วยกระบวนการที่เปลี่ยนจากสถานะ "หยุด" เป็นสถานะ "พร้อมที่จะทำงาน" และสำหรับกระบวนการที่หยุดในสถานะสลีป ปลายทางถัดไปคือการ "สลีป" ต่อ
คุณลักษณะที่อธิบายไว้ได้รับการนำไปใช้อย่างสมบูรณ์ใน SVR4

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

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

หลักการจัดการหน่วยความจำ

Marshal Kirk McKusick FreeBSD - สถาปัตยกรรมและการนำไปใช้<<-----------PDF ст.166

การจัดการหน่วยความจำ part-1

12:51 - ความละเอียดที่อยู่ 34:21 - โอเวอร์เลย์โครงสร้างไดนามิก

59:26 - การทำแผนที่ต่อเนื่องเชิงเส้น - เชิงเส้นเป็นชิ้นเล็กชิ้นน้อย (มาตรา 25)

การจัดการหน่วยความจำ part-2

อะไรเป็นจุดเริ่มต้น? OOP หรือหน่วยความจำเสมือน

51:44--> "หน่วยความจำเสมือน";<-(стр. 18)->56:03--> "กลุ่ม";

สมาคมการแปลบัฟเฟอร์ การแปล lookaside buffer(TLB) เป็นแคชของ CPU แบบพิเศษที่ใช้ในการเร่งการแปลที่อยู่หน่วยความจำเสมือนเป็นที่อยู่หน่วยความจำจริง https://th.wikipedia.org https://www.ibm.com/support/knowledgecenter/.performance/cache_tlbs.htm

หนึ่งในหน้าที่หลักของระบบปฏิบัติการคือการจัดการหน่วยความจำอย่างมีประสิทธิภาพ
RAM หรือหน่วยความจำหลัก หรือหน่วยความจำเข้าถึงโดยสุ่ม (Random Access Memory, RAM) เวลาในการเข้าถึงหน่วยความจำมีเพียงไม่กี่รอบของโปรเซสเซอร์ ดังนั้นการทำงานกับข้อมูลในหน่วยความจำจึงให้ประสิทธิภาพสูงสุด
ทรัพยากรนี้มักจะมีจำกัด ในระดับที่มากขึ้น สิ่งนี้เป็นจริงสำหรับระบบปฏิบัติการเอนกประสงค์ที่ทำงานหลายอย่างพร้อมกัน ซึ่งก็คือ UNIX
ดังนั้นข้อมูลที่ไม่สามารถอยู่ในหน่วยความจำหลักจึงอยู่ในอุปกรณ์จัดเก็บข้อมูลสำรองหรือในหน่วยความจำรองซึ่งมักจะทำหน้าที่โดย
ดิสก์ไดรฟ์ เวลาในการเข้าถึงหน่วยความจำรองนั้นมีขนาดยาวกว่าเวลาเข้าถึงหน่วยความจำหลักหลายขนาด และต้องการความช่วยเหลือจากระบบปฏิบัติการ
ระบบย่อยการจัดการหน่วยความจำ UNIX มีหน้าที่ในการจัดสรร . ที่ยุติธรรมและมีประสิทธิภาพ
ทรัพยากร RAM ที่ใช้ร่วมกันระหว่างกระบวนการและสำหรับการแลกเปลี่ยนข้อมูลระหว่าง RAM และหน่วยความจำรอง การดำเนินการบางอย่างดำเนินการโดยฮาร์ดแวร์
หน่วยการจัดการหน่วยความจำ (MMU) ของโปรเซสเซอร์ที่ใช้ระบบปฏิบัติการ ซึ่งบรรลุประสิทธิภาพตามที่ต้องการ
การจัดการหน่วยความจำดั้งเดิมช่วยลดการทำงานของระบบปฏิบัติการอย่างมาก ตามกฎแล้วระบบดังกล่าวอนุญาตให้โหลดงานเดียวลงในตำแหน่งที่กำหนดไว้ล่วงหน้าใน RAM และควบคุมเพื่อถ่ายโอนไปยังมัน ในกรณีนี้งานจะได้รับ
การกำจัดทรัพยากรคอมพิวเตอร์ทั้งหมด (แน่นอนว่ามีการแบ่งปันกับระบบปฏิบัติการ)
และที่อยู่ที่ใช้โดยงานคือที่อยู่จริงของหน่วยความจำหลัก
เนื่องจากวิธีการเปิดและเรียกใช้โปรแกรมเดียวนี้เป็นวิธีที่รวดเร็วที่สุด จึงมักใช้ในระบบไมโครโปรเซสเซอร์เฉพาะทาง แต่ในทางปฏิบัติไม่สามารถใช้งานได้จริงในระบบปฏิบัติการทั่วไป เช่น UNIX
เราสามารถกำหนดคุณสมบัติจำนวนหนึ่งที่ระบบย่อยการจัดการหน่วยความจำของระบบปฏิบัติการมัลติทาสกิ้งสมัยใหม่ควรมี:

• ปฏิบัติงานที่มีขนาดใหญ่กว่าขนาดของการปฏิบัติงานหน่วยความจำ.
• เรียกใช้งานที่โหลดบางส่วนในหน่วยความจำเพื่อลดขนาดเวลาเปิดตัวของพวกเขา
• การวางหลายงานในหน่วยความจำพร้อมกันเพื่อปรับปรุงประสิทธิภาพของ CPU
• การวางงานในตำแหน่งใดก็ได้ใน RAM
• การวางงานในส่วนต่างๆ ของ RAM
• การแบ่งปันพื้นที่หน่วยความจำเดียวกันโดยหลายงานตัวอย่างเช่น หลายกระบวนการที่รันโปรแกรมเดียวกันสามารถแบ่งส่วนของรหัสได้
• ความเป็นไปได้ในการสร้างรหัสที่ไม่ขึ้นกับเครื่อง กล่าวคือ เบื้องต้น ไม่ควรมีการเชื่อมต่อระหว่างโปรแกรมและหน่วยความจำกายภาพ

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

PS: Linux นอกจากนี้ กระบวนการทำงานด้วยที่อยู่เสมือน ไม่ใช่ที่อยู่จริง การแปลงทำได้โดยการคำนวณโดยใช้ตารางอธิบายและแค็ตตาล็อกตาราง Linux รองรับตารางได้ 3 ระดับ: ไดเร็กทอรีตารางระดับแรก ( PGD- ไดเรกทอรีตารางหน้า) ไดเร็กทอรีตารางระดับที่สอง ( PMD- ไดเร็กทอรีตารางหน้ากลาง) และสุดท้ายคือ ตารางอธิบาย (ปตท- รายการตารางหน้า). ในความเป็นจริง โปรเซสเซอร์บางตัวอาจไม่รองรับทุกระดับแต่ headroom ช่วยให้สามารถรองรับสถาปัตยกรรมที่เป็นไปได้มากขึ้น (Intel มีตาราง 2 ระดับและอัลฟ่า - มากถึง 3) การแปลงที่อยู่เสมือนเป็นที่อยู่จริงเกิดขึ้นใน 3 ขั้นตอนตามลำดับ ตัวชี้ถูกนำมาใช้ PGDที่มีอยู่ในโครงสร้างที่อธิบายแต่ละกระบวนการจะถูกแปลงเป็นตัวชี้บันทึก PMDและตัวหลังจะถูกแปลงเป็นตัวชี้ในตารางตัวอธิบาย ปตท. และในที่สุดก็ถึงที่อยู่จริงชี้ไปที่จุดเริ่มต้นของหน้าจะเพิ่มออฟเซ็ตจากจุดเริ่มต้น ตัวอย่างที่ดีของขั้นตอนดังกล่าวสามารถพบได้ในฟังก์ชันเคอร์เนล< บางส่วน_ชัดเจน>.

หน่วยความจำเสมือนและกายภาพ

RAM เป็นหนึ่งในองค์ประกอบสำคัญของระบบคอมพิวเตอร์ ระบบ UNIX รุ่นแรกมี RAM ขนาด 64 KB และจำนวนนี้ไม่เพียงพออย่างชัดเจน คอมพิวเตอร์สมัยใหม่มี RAM กิกะไบต์ และยังไม่เพียงพอ
RAM สามารถแสดงเป็นลำดับของไบต์ ซึ่งแต่ละอันมีที่อยู่เฉพาะของตัวเอง ซึ่งเรียกว่าที่อยู่จริงเป็นที่อยู่เหล่านี้ที่โปรเซสเซอร์ใช้ในที่สุดเมื่อแลกเปลี่ยนข้อมูลกับ RAM อย่างไรก็ตาม พื้นที่ที่อยู่ของกระบวนการแตกต่างอย่างมากจากพื้นที่ที่อยู่ของ RAM จริง ลองนึกภาพว่าพื้นที่ที่อยู่ของกระบวนการจับคู่โดยตรงกับหน่วยความจำหลัก กล่าวคือ ที่อยู่ที่ใช้โดยกระบวนการนั้นเป็นที่อยู่จริง ด้วยวิธีนี้ อุปสรรคที่ผ่านไม่ได้จำนวนหนึ่งจะรอเราอยู่บนทางเพื่อสร้างระบบมัลติทาสก์:

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

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

พื้นที่ที่อยู่เสมือนเป็นสวรรค์สำหรับกระบวนการ

• ประการแรก กระบวนการมีความรู้สึกพิเศษ - ท้ายที่สุด พื้นที่ที่อยู่ทั้งหมดเป็นของเขาเท่านั้น
• ประการที่สอง ไม่จำกัดจำนวนหน่วยความจำกายภาพอีกต่อไป - หน่วยความจำเสมือนสามารถมีได้มากเกินทางกายภาพ. ส่งผลให้กระบวนการถูกแยกออกจากกันและไม่มีโอกาส (แม้ว่าจะต้องการ)"โฮสต์" ในช่องที่อยู่ของเพื่อนบ้าน หน่วยความจำกายภาพได้รับการจัดสรรให้มากที่สุดมีประสิทธิภาพ - ไม่ขึ้นอยู่กับการจัดสรรหน่วยความจำเสมือนของแต่ละกระบวนการ

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

ตามกฎแล้วโปรเซสเซอร์สมัยใหม่รองรับการรวมพื้นที่ที่อยู่ (การแบ่งส่วน - การจัดระเบียบหน้าของหน่วยความจำ):

ใน ขอบเขตของขนาดตัวแปร - เซ็กเมนต์และ

ใน พื้นที่ขนาดคงที่ - หน้า,

แนวคิดของ "หน้า" สามารถตีความได้ว่าเป็นวิธีการจัดระเบียบหน่วยความจำเมื่อหน่วยความจำกายภาพแบ่งออกเป็นบล็อกที่มีขนาดคงที่ (512-2Kb ทวีคูณ 2) รวมถึงแนวคิดของ "ส่วน", "หน้า" เป็นหนึ่งในนามธรรมพื้นฐานในการทำความเข้าใจสถาปัตยกรรมและการทำงานของระบบปฏิบัติการ ในกรณีนี้ สำหรับแต่ละเซ็กเมนต์หรือเพจ สามารถตั้งค่าการแมปแอดเดรสเสมือนกับที่อยู่จริงได้
โดยทั่วไปแล้ว พื้นที่ที่อยู่เสมือนของกระบวนการจะมีโครงสร้างตามลำดับในเซ็กเมนต์ - โค้ด ข้อมูล สแตก และไลบรารี ตำแหน่งของหน่วยความจำกายภาพพื้นที่ที่สอดคล้องกันสามารถ กระจัดกระจายอักขระ. ขนาดของหน่วยความจำเสมือนอาจเกินขนาดของหน่วยความจำกายภาพได้อย่างมาก เนื่องจากการใช้หน่วยความจำสำรองหรือพื้นที่สว็อป ซึ่งมักจะเป็นพื้นที่ดิสก์ ซึ่งสามารถจัดเก็บส่วนที่ไม่ได้ใช้ชั่วคราวของพื้นที่ที่อยู่ของกระบวนการได้ ตัวอย่างเช่น หากกระบวนการเข้าถึงที่อยู่เสมือนซึ่งมีหน้าหน่วยความจำกายภาพที่สอดคล้องกัน การดำเนินการอ่านหรือเขียนจะสำเร็จ หากไม่มีเพจใน RAM โปรเซสเซอร์จะสร้างการขัดจังหวะของฮาร์ดแวร์ที่เรียกว่า page fault ( หน้าผิดพลาด)เพื่อตอบสนองต่อที่เคอร์เนลกำหนดตำแหน่งของเนื้อหาหน้าที่บันทึกไว้ในพื้นที่สลับ อ่านหน้าลงในหน่วยความจำ ตั้งค่าพารามิเตอร์สำหรับการแมปที่อยู่เสมือนกับที่อยู่จริง และบอกให้โปรเซสเซอร์ทำซ้ำการดำเนินการ การกระทำทั้งหมดเหล่านี้จะไม่ปรากฏให้เห็นในแอปพลิเคชันที่ทำงานกับหน่วยความจำเสมือน
กลไกสำหรับการจับคู่ที่อยู่เสมือนกับที่อยู่จริง (การแปลที่อยู่) เป็นสิ่งสำคัญ

วิธีขึ้นอยู่กับการใช้งานฮาร์ดแวร์เฉพาะ ส่วนนี้อธิบายกลไกสำหรับการแมปเสมือนกับที่อยู่จริงในระบบปฏิบัติการ SCO UNIX โดยใช้โปรเซสเซอร์ตระกูล Intel เป็นตัวอย่าง อย่างไรก็ตาม เช่นเดียวกับระบบย่อย UNIX อื่นๆ หลักการพื้นฐานแตกต่างกันเล็กน้อย และการนำเสนอนี้จะช่วยในการแนะนำกลไกการจัดการหน่วยความจำ และทำความเข้าใจการใช้งานเฉพาะ หากจำเป็น

กลุ่ม

ตระกูลโปรเซสเซอร์ Intel อนุญาตให้แบ่งหน่วยความจำออกเป็นหลายส่วนที่เรียกว่าเซกเมนต์ ในกรณีนี้ พื้นที่ที่อยู่ของกระบวนการสามารถแสดงเป็นส่วนตรรกะได้หลายส่วน ซึ่งแต่ละส่วนประกอบด้วยลำดับที่อยู่อย่างต่อเนื่องซึ่งอยู่ในช่วงที่กำหนด การแปลที่อยู่ตามการแบ่งส่วน
ให้การทำแผนที่ที่ชัดเจนของที่อยู่กลุ่มเป็นลำดับต่อเนื่อง
ที่อยู่ทางกายภาพ ที่อยู่เสมือนในกรณีนี้ประกอบด้วยสองส่วน: ตัวเลือกกลุ่มและ
ชดเชยจากจุดเริ่มต้นของส่วน ตัวเลือก(ให้เจาะจงมากขึ้นคือช่องตัวเลือก ดัชนี) ชี้ไปที่
ตัวบอกเซกเมนต์ที่เรียกว่ามีพารามิเตอร์เช่นตำแหน่งในหน่วยความจำ
ขนาดและการอนุญาต โปรเซสเซอร์สนับสนุนการกำหนดที่อยู่ทางอ้อมของเซ็กเมนต์ผ่านตัวบอกเซ็กเมนต์ ซึ่งอยู่ในตารางพิเศษ - พื้นที่หน่วยความจำที่ชี้ไปที่
การลงทะเบียนโปรเซสเซอร์สำหรับวัตถุประสงค์นี้ เคอร์เนลของระบบปฏิบัติการมีหน้าที่ในการเติมตารางเหล่านี้และตั้งค่าการลงทะเบียน กล่าวอีกนัยหนึ่ง เคอร์เนลตั้งค่าการแมป และตัวประมวลผลทำการแมปในฮาร์ดแวร์ ด้วยการกำหนดแอดเดรสทางอ้อมนี้ ลอจิคัลเซ็กเมนต์ได้รับการปกป้องจากกันและกัน ซึ่งทำให้มั่นใจถึงความสมบูรณ์ของกระบวนการและช่องว่างที่อยู่เคอร์เนล
ตัวอธิบายเซ็กเมนต์จะอยู่ในตารางระบบสองตาราง - local descriptor table
(ตารางอธิบายท้องถิ่น - LDT) และ Global Descriptor Table - GDT).
ตามชื่อที่แนะนำ LDT ให้การแปลที่อยู่เสมือนของเซ็กเมนต์กระบวนการ
ในขณะที่ GDT รักษาพื้นที่ที่อยู่ของเคอร์เนล (เช่น เมื่อประมวลผล system
โทรหรือขัดจังหวะ) แต่ละกระบวนการสร้าง LDT ของตัวเองในขณะที่ GDT
แบ่งปันโดยกระบวนการทั้งหมด ข้อมูลเกี่ยวกับตารางที่ตัวเลือกชี้ไปนั้นอยู่ในตัวเลือกเอง

1 5 3 2 1 0

ดัชนี

Ti

RPL

ตัวเลือกกลุ่ม

• สนาม ดัชนีคือตัวเลข (ดัชนี) ของ descriptor ในตาราง descriptor ซึ่งควรใช้เมื่อคำนวณที่อยู่เชิงเส้น
• นิดหน่อย Tiระบุว่าควรใช้ตารางคำอธิบายใดØ - สอดคล้องกับ GDT1 - สอดคล้องกับ LDT
• สนาม RPLใช้เพื่อควบคุมสิทธิ์การเข้าถึงของโปรแกรมในส่วน ถูกร้องขอระดับสิทธิ์และเป็นหนึ่งในกลไกในการสร้างความมั่นใจในการป้องกันกลุ่มตัวอย่างเช่น หากกระบวนการพยายามเข้าถึงเซ็กเมนต์ขณะอยู่ในโหมดงานที่เป็นของเคอร์เนล โปรเซสเซอร์จะสร้างข้อยกเว้น ซึ่งเคอร์เนลจะส่งสัญญาณ SIGSEGV ไปยังกระบวนการ

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

ตัวอธิบายเซ็กเมนต์ (โค้ด ข้อมูล สแต็ก) มีหลายฟิลด์:

• ที่อยู่ฐาน ฟิลด์นี้เก็บที่อยู่แบบ 32 บิตของจุดเริ่มต้นของเซ็กเมนต์ โปรเซสเซอร์เพิ่มเข้าไปออฟเซ็ตและรับที่อยู่เชิงเส้น 32 บิต
• จำกัด ฟิลด์นี้ระบุขนาดของเซ็กเมนต์ ถ้าผลลัพธ์ที่อยู่เชิงเส้นอยู่นอกเซ็กเมนต์ โปรเซสเซอร์สร้างข้อยกเว้นขอบเขตของเซ็กเมนต์ช่วยให้โปรเซสเซอร์ตรวจจับข้อผิดพลาดทั่วไป เช่น สแต็กโอเวอร์โฟลว์ตัวชี้ที่ไม่ถูกต้อง ที่อยู่การโทรที่ไม่ถูกต้อง และการเปลี่ยนแปลง เมื่อระบบปฏิบัติการพิจารณาว่าการเข้าถึงนอกกลุ่มไม่ใช่ข้อผิดพลาด(เช่นบนสแต็กโอเวอร์โฟลว์) มันสามารถขยายเซ็กเมนต์โดยการจัดสรรหน่วยความจำเพิ่มเติมและขอให้ดำเนินการคำสั่งอีกครั้ง
• สิทธิ์ ฟิลด์นี้เรียกว่า Descriptor Privilege Level (DPL) กำหนดระดับสิทธิ์ของเซ็กเมนต์และใช้ร่วมกับฟิลด์ตัวเลือก RPL เพื่ออนุญาตหรือปฏิเสธการเข้าถึงไปที่ส่วน ในการเข้าถึงเซ็กเมนต์ งานต้องมีอย่างน้อยระดับเดียวกันสิทธิพิเศษเช่นเซ็กเมนต์ เช่น RPL DPL
• สัญญาณของการมีอยู่ บิตนี้เป็นหนึ่งในกลไกสำหรับการนำหน่วยความจำเสมือนไปใช้หากไม่ได้ตั้งค่าบิตเมื่อพยายามเข้าถึงสำหรับเซ็กเมนต์ ตัวประมวลผลจะสร้างข้อยกเว้นที่ขาดหายไปเซ็กเมนต์ทำให้เคอร์เนลโหลดเซ็กเมนต์จากหน่วยความจำรองและทำซ้ำคำสั่งอีกครั้งโดยไม่กระทบต่อการดำเนินการตามกระบวนการ อย่างไรก็ตามในเวอร์ชันที่ทันสมัยที่สุดหน่วยความจำเสมือน UNIX ขึ้นอยู่กับกลไกการเพจโดยส่วนที่อยู่ในหน่วยความจำเสมอและการแลกเปลี่ยนระหว่างการปฏิบัติงานและที่เก็บข้อมูลรองเกิดขึ้นที่ระดับเพจ
• Type ฟิลด์นี้ระบุประเภทเซ็กเมนต์ โปรเซสเซอร์ตรวจสอบประเภทส่วนเพื่อให้ตรงกับคำสั่งปฏิบัติการ โดยเฉพาะอย่างยิ่งสิ่งนี้ไม่อนุญาตให้ใครตีความข้อมูลเซ็กเมนต์ข้อมูลเป็นคำสั่งโปรเซสเซอร์
• สิทธิ์ ฟิลด์นี้กำหนดสิทธิ์ที่จำกัดชุดของการดำเนินการที่สามารถทำได้ในส่วน ตัวอย่างเช่น,ส่วนรหัสมักจะถูกทำเครื่องหมายเป็นปฏิบัติการและอ่านได้กลุ่มข้อมูลมีสิทธิ์เข้าถึงแบบอ่านอย่างเดียวหรือสำหรับการอ่านและการเขียน

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

กลไกหน้า

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

กลไกการเพจมีความยืดหยุ่นมากขึ้น ในกรณีนี้ พื้นที่ที่อยู่เสมือนทั้งหมด (4 GB สำหรับโปรเซสเซอร์ Intel) จะถูกแบ่งออกเป็นบล็อกที่มีขนาดเท่ากัน เรียกว่าเพจ โปรเซสเซอร์ Intel ส่วนใหญ่ทำงานกับเพจขนาด 4 KB ในกรณีของการแบ่งส่วน หน้าสามารถแสดงอยู่ใน RAM ได้
หรืออยู่ในพื้นที่สว็อปหรือประมวลผลได้ ข้อได้เปรียบหลักของรูปแบบดังกล่าวคือระบบจัดการหน่วยความจำทำงานในพื้นที่ที่มีขนาดเล็กเพียงพอ
ขนาดเพื่อให้แน่ใจว่ามีการกระจายทรัพยากรหน่วยความจำระหว่างกระบวนการอย่างมีประสิทธิภาพ
กลไกการเพจช่วยให้ส่วนของเซ็กเมนต์อยู่ใน RAM และไม่ใช่ส่วนหนึ่ง สิ่งนี้ทำให้เคอร์เนลสามารถจัดสรรในหน่วยความจำได้เฉพาะเพจที่กระบวนการใช้งานอยู่ในปัจจุบัน ซึ่งจะทำให้ RAM ว่างมากขึ้นอย่างมาก ข้อดีอีกประการหนึ่งคือหน้าเซ็กเมนต์สามารถอยู่ในหน่วยความจำกายภาพในตำแหน่งและลำดับตามอำเภอใจ ซึ่งช่วยให้ใช้พื้นที่ว่างได้อย่างมีประสิทธิภาพ
วิธีการนี้คล้ายกับรูปแบบการจัดเก็บไฟล์บนดิสก์ - แต่ละไฟล์ประกอบด้วย
จำนวนบล็อกการจัดเก็บข้อมูลที่แตกต่างกันซึ่งสามารถอยู่ในพื้นที่ว่างของดิสก์ไดรฟ์ได้ สิ่งนี้นำไปสู่การแตกแฟรกเมนต์ที่สำคัญ แต่ช่วยปรับปรุงประสิทธิภาพพื้นที่ดิสก์ได้อย่างมาก
เมื่อใช้กลไกการเพจ ที่อยู่เชิงเส้นที่ได้รับจากการเพิ่มที่อยู่พื้นฐานของเซ็กเมนต์และออฟเซ็ตยังเป็นที่อยู่แบบลอจิคัล ซึ่งจะถูกประมวลผลเพิ่มเติมโดยหน่วยเพจของโปรเซสเซอร์ ในกรณีนี้ ตัวประมวลผลจะถือว่าที่อยู่เชิงเส้นตรงโดยประกอบด้วยสามส่วน

รายการไดเรกทอรีหน้า PDE- ช่องที่อยู่แรก บิต 22 ถึง 31 ชี้ไปที่รายการไดเรกทอรีตารางหน้า PDE. ไดเร็กทอรีตารางหน้ามีความยาวหนึ่งหน้าและมีตัวชี้ตารางหน้าสูงสุด 1024 หน้า ดังนั้นฟิลด์แรกจะระบุตารางเพจเฉพาะ
รายการตารางหน้า PTE- ฟิลด์ที่สอง ครอบครองตั้งแต่ 12 ถึง 21 บิต ระบุรายการตารางหน้า RTE. ตารางหน้ายังยาว 4 KB และรายการตารางมีทั้งหมด 1024 หน้า กล่าวอีกนัยหนึ่ง ฟิลด์ที่สองระบุหน้าเฉพาะ
สุดท้าย ออฟเซ็ตหน้าจะถูกกำหนดโดยฟิลด์ที่สาม ซึ่งครอบครอง 12 บิตที่ต่ำกว่าของที่อยู่เชิงเส้น ดังนั้น ด้วยไดเร็กทอรีตารางเดียว กระบวนการจึงสามารถระบุได้

1024 x 1024 x 4096 = หน่วยความจำกายภาพ 4 GB

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

โปรเซสเซอร์ที่ทันสมัยส่วนใหญ่ และโดยเฉพาะอย่างยิ่งตระกูลโปรเซสเซอร์ Intel ใส่ข้อมูลเกี่ยวกับสองสามหน้าสุดท้ายที่ใช้ในแคชที่เร็วเป็นพิเศษ เฉพาะเมื่อโปรเซสเซอร์ไม่พบเพจที่ต้องการในแคชนี้ โปรเซสเซอร์จึงจะเข้าถึงไดเร็กทอรีและตารางเพจได้ ตามกฎแล้ว 99-98% ของลิงก์ที่อยู่จะเข้าไปในแคช โดยไม่ต้องใช้ที่อยู่ของการเข้าถึง RAM ซึ่งเป็นที่ตั้งของไดเร็กทอรีและตารางสำหรับการแปล
แต่ละองค์ประกอบตารางหน้าประกอบด้วยหลายฟิลด์ที่อธิบายต่างๆ

ลักษณะหน้า. ทุ่งนา ปตท:

พี	สัญญาณของการมีอยู่ใน RAM การเข้าถึงเพจที่ไม่ได้อยู่ในหน่วยความจำ (P=0) ทำให้เกิดข้อบกพร่องของเพจ ซึ่งเป็นเงื่อนไขพิเศษที่โปรเซสเซอร์แจ้งเคอร์เนลเกี่ยวกับ ซึ่งจัดการได้อย่างเหมาะสม
R/W	สิทธิ์ในการอ่านเฉพาะหน้า (R/W=0) หรืออ่านเขียนได้ (R/W=1)
เรา	สิทธิ์การเข้าถึง ถ้า U/S=0 เฉพาะงานที่ได้รับสิทธิพิเศษ(หลัก) มีสิทธิ์เข้าถึงที่อยู่เพจ มิเช่นนั้นให้เข้าถึงหน้ามีงานทั้งหมด
ที่อยู่	ที่อยู่ทางกายภาพของจุดเริ่มต้นของหน้า (ที่อยู่ฐาน)

ประมวลผลพื้นที่ที่อยู่

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

หนึ่งในระบบย่อยหลักของระบบปฏิบัติการหลายโปรแกรมสมัยใหม่ที่ส่งผลโดยตรงต่อการทำงานของคอมพิวเตอร์คือระบบย่อยการควบคุมกระบวนการและเธรด หน้าที่หลักของระบบย่อยนี้:

การสร้างกระบวนการและเธรด

จัดหากระบวนการและโฟลว์ด้วยทรัพยากรที่จำเป็น

การแยกกระบวนการ;

การจัดกำหนดการการดำเนินการของกระบวนการและเธรด (โดยทั่วไป เราควรพูดถึงการจัดตารางงานด้วย)

การตั้งเวลาเธรด

การจัดระบบการสื่อสารระหว่างกระบวนการ

การซิงโครไนซ์กระบวนการและเธรด

การยุติและการทำลายกระบวนการและเธรด

1. ห้าเหตุการณ์หลักนำไปสู่การสร้างกระบวนการ:

ดำเนินการตามคำขอของกระบวนการที่ทำงานอยู่เพื่อสร้างกระบวนการ

แจ้งให้ผู้ใช้สร้างกระบวนการ เช่น เมื่อเข้าสู่ระบบแบบโต้ตอบ

การเริ่มต้นงานแบทช์

การสร้างโดยระบบปฏิบัติการของกระบวนการที่จำเป็นสำหรับการทำงานของบริการใด ๆ

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

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

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

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

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

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

บันทึกบริบทของเธรดปัจจุบัน

เปิดตัวเธรดใหม่สำหรับการดำเนินการ

6. เมื่องานอิสระหลายงานกำลังทำงานอยู่บนระบบพร้อมกัน ปัญหาเพิ่มเติมก็จะเกิดขึ้น แม้ว่าเธรดจะถูกสร้างขึ้นและดำเนินการพร้อมกัน แต่ก็อาจจำเป็นต้องโต้ตอบเช่น เมื่อมีการแลกเปลี่ยนข้อมูล กระบวนการและเธรดสามารถใช้ความสามารถที่หลากหลายในการสื่อสารระหว่างกัน: ช่องทาง (in UNIX), กล่องจดหมาย ( Windows), การเรียกโพรซีเดอร์ระยะไกล, ซ็อกเก็ต (in Windowsเชื่อมต่อกระบวนการบนเครื่องต่างๆ) การจับคู่อัตราเธรดเป็นสิ่งสำคัญมากในการป้องกันสภาวะการแข่งขัน (เมื่อหลายเธรดพยายามเปลี่ยนเหมือนกัน ไฟล์) การหยุดชะงัก และการชนกันอื่นๆ ที่เกิดขึ้นเมื่อแชร์ทรัพยากร

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

8. ทุกครั้งที่กระบวนการสิ้นสุดลง, - และสิ่งนี้เกิดขึ้นเนื่องจากเหตุการณ์ใดเหตุการณ์หนึ่งต่อไปนี้: ปกติ ผลผลิต, ผลผลิต บนความผิดพลาด, ผลผลิต บนข้อผิดพลาดร้ายแรง การทำลายโดยกระบวนการอื่น - ระบบปฏิบัติการทำตามขั้นตอนเพื่อ "ล้างร่องรอย" ของการอยู่ในระบบ ระบบย่อยการควบคุมกระบวนการปิดไฟล์ทั้งหมดที่กระบวนการทำงานด้วย เพิ่มพื้นที่ของ RAM ที่จัดสรรสำหรับรหัส ข้อมูล และโครงสร้างข้อมูลระบบของกระบวนการ ดำเนินการแล้ว การแก้ไขคิว OS ทุกชนิดและ รายการทรัพยากรที่มีการอ้างอิงถึงกระบวนการที่ถูกยกเลิก

การแยกกระบวนการ;

การจัดกำหนดการการดำเนินการของกระบวนการและเธรด (โดยทั่วไป เราควรพูดถึงการจัดตารางงานด้วย)

การตั้งเวลาเธรด

การจัดระบบการสื่อสารระหว่างกระบวนการ

การซิงโครไนซ์กระบวนการและเธรด

การยุติและการทำลายกระบวนการและเธรด

ห้าเหตุการณ์หลักนำไปสู่การสร้างกระบวนการ:

ดำเนินการตามคำขอของกระบวนการที่ทำงานอยู่เพื่อสร้างกระบวนการ

แจ้งให้ผู้ใช้สร้างกระบวนการ เช่น เมื่อเข้าสู่ระบบแบบโต้ตอบ

การเริ่มต้นงานแบทช์

การสร้างโดยระบบปฏิบัติการของกระบวนการที่จำเป็นสำหรับการทำงานของบริการใด ๆ

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

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

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

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

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

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

• บันทึกบริบทของเธรดปัจจุบัน
• กำลังโหลดบริบทของเธรดที่เลือกอันเป็นผลมาจากการตั้งเวลา
• เปิดตัวเธรดใหม่สำหรับการดำเนินการ

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

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

ทุกครั้งที่กระบวนการยุติ - และนี่เป็นเพราะเหตุการณ์ใดเหตุการณ์หนึ่งต่อไปนี้: ทางออกปกติ, ออกจากข้อผิดพลาด, ออกจากข้อผิดพลาดร้ายแรง, ถูกฆ่าโดยกระบวนการอื่น - ระบบปฏิบัติการทำตามขั้นตอนเพื่อ "ล้างร่องรอย" ของการมีอยู่ ระบบ. ระบบย่อยการควบคุมกระบวนการปิดไฟล์ทั้งหมดที่กระบวนการทำงานด้วย เพิ่มพื้นที่ของ RAM ที่จัดสรรสำหรับรหัส ข้อมูล และโครงสร้างข้อมูลระบบของกระบวนการ คิว OS ที่เป็นไปได้ทั้งหมดและรายการทรัพยากรที่มีลิงก์ไปยังกระบวนการที่ถูกยกเลิกจะได้รับการแก้ไข

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

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

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

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

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

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

อีกวิธีหนึ่งคือการสร้างกระบวนการหลายขั้นตอนสำหรับแอปพลิเคชันเดียวสำหรับแต่ละคู่ขนาน