ระบบปฏิบัติการเบื้องต้น
เฮ้ ฮาเบอร์! ฉันอยากจะแจ้งให้คุณทราบถึงชุดบทความ-การแปลวรรณกรรมที่น่าสนใจเรื่องหนึ่งในความคิดของฉัน - OSTEP เนื้อหานี้กล่าวถึงการทำงานของระบบปฏิบัติการที่มีลักษณะคล้ายยูนิกซ์อย่างลึกซึ้ง กล่าวคือ การทำงานกับกระบวนการ ตัวกำหนดเวลาต่างๆ หน่วยความจำ และส่วนประกอบอื่น ๆ ที่คล้ายกันซึ่งประกอบเป็นระบบปฏิบัติการสมัยใหม่ คุณสามารถดูต้นฉบับของวัสดุทั้งหมดได้ที่นี่ . โปรดทราบว่าการแปลจัดทำขึ้นอย่างไม่เป็นมืออาชีพ (ค่อนข้างอิสระ) แต่ฉันหวังว่าฉันจะคงความหมายทั่วไปไว้
งานห้องปฏิบัติการในเรื่องนี้สามารถพบได้ที่นี่:
- ต้นฉบับ:
- ต้นฉบับ:
- การปรับตัวส่วนตัวของฉัน:
คุณสามารถตรวจสอบช่องของฉันได้ที่ =)
การทำงานของโปรแกรม
จะเกิดอะไรขึ้นเมื่อโปรแกรมกำลังทำงานอยู่? โปรแกรมที่รันอยู่ทำสิ่งง่ายๆ อย่างหนึ่ง นั่นคือดำเนินการตามคำสั่ง ทุก ๆ วินาที โปรเซสเซอร์จะดึงคำสั่งหลายล้านหรือหลายพันล้านคำสั่งจาก RAM จากนั้นจะถอดรหัสคำสั่งเหล่านั้น (เช่น จดจำคำสั่งเหล่านี้เป็นของประเภทใด) และดำเนินการคำสั่งเหล่านั้น นี่อาจเป็นการเพิ่มตัวเลขสองตัว การเข้าถึงหน่วยความจำ การตรวจสอบเงื่อนไข การข้ามไปยังฟังก์ชัน และอื่นๆ หลังจากดำเนินการคำสั่งหนึ่งแล้ว ตัวประมวลผลจะดำเนินการดำเนินการคำสั่งอื่นต่อไป ดังนั้นคำสั่งแล้วคำสั่งเล่า พวกมันจะถูกดำเนินการจนกว่าโปรแกรมจะสิ้นสุด
ตัวอย่างนี้ถือว่าง่ายโดยธรรมชาติ - ที่จริงแล้วเพื่อเร่งความเร็วโปรเซสเซอร์ ฮาร์ดแวร์สมัยใหม่ช่วยให้คุณสามารถดำเนินการตามคำสั่งโดยไม่ตั้งใจ คำนวณผลลัพธ์ที่เป็นไปได้ ดำเนินการตามคำสั่งพร้อมกัน และเทคนิคที่คล้ายกัน
แบบจำลองการคำนวณของวอนนอยมันน์
รูปแบบงานที่เรียบง่ายที่เราอธิบายนั้นคล้ายคลึงกับแบบจำลองการคำนวณของฟอนนอยมันน์ Von Neumann เป็นหนึ่งในผู้บุกเบิกระบบคอมพิวเตอร์ เขายังเป็นหนึ่งในผู้เขียนทฤษฎีเกมด้วย. ในขณะที่โปรแกรมกำลังทำงานอยู่ จะมีเหตุการณ์อื่นๆ เกิดขึ้น กระบวนการอื่นๆ มากมายและการทำงานของลอจิกของบุคคลที่สาม จุดประสงค์หลักคือการทำให้การเปิดตัว การทำงาน และการบำรุงรักษาระบบง่ายขึ้น
มีชุดซอฟต์แวร์ที่รับผิดชอบในการทำให้โปรแกรมรันได้ง่าย (หรือแม้แต่อนุญาตให้หลายโปรแกรมทำงานพร้อมกัน) ที่ช่วยให้โปรแกรมใช้หน่วยความจำเดียวกัน และสื่อสารกับอุปกรณ์ต่างๆ ได้ ชุดซอฟต์แวร์ (ซอฟต์แวร์) ดังกล่าวโดยพื้นฐานแล้วเรียกว่าระบบปฏิบัติการและงานต่างๆ ได้แก่ การตรวจสอบว่าระบบทำงานอย่างถูกต้องและมีประสิทธิภาพตลอดจนทำให้มั่นใจว่าง่ายต่อการจัดการระบบนี้
ระบบปฏิบัติการ
ระบบปฏิบัติการหรือเรียกโดยย่อว่า OS คือชุดของโปรแกรมที่เกี่ยวข้องกันซึ่งออกแบบมาเพื่อจัดการทรัพยากรคอมพิวเตอร์และจัดระเบียบการโต้ตอบของผู้ใช้กับคอมพิวเตอร์.
ระบบปฏิบัติการบรรลุประสิทธิผลตั้งแต่แรกโดยใช้เทคนิคที่สำคัญที่สุด นั่นก็คือเทคนิค การจำลองเสมือน. ระบบปฏิบัติการโต้ตอบกับทรัพยากรทางกายภาพ (โปรเซสเซอร์ หน่วยความจำ ดิสก์ ฯลฯ) และแปลงให้เป็นรูปแบบที่กว้างกว่า มีประสิทธิภาพมากกว่า และใช้งานง่ายกว่าของตัวเอง ดังนั้น เพื่อความเข้าใจทั่วไป คุณสามารถเปรียบเทียบระบบปฏิบัติการกับเครื่องเสมือนได้คร่าวๆ
เพื่อให้ผู้ใช้สามารถออกคำสั่งไปยังระบบปฏิบัติการและใช้ความสามารถของเครื่องเสมือนได้ (เช่น การรันโปรแกรม การจัดสรรหน่วยความจำ การเข้าถึงไฟล์ และอื่นๆ) ระบบปฏิบัติการจึงจัดเตรียมอินเทอร์เฟซบางส่วนที่เรียกว่า API (อินเทอร์เฟซการเขียนโปรแกรมแอปพลิเคชัน) และที่คุณสามารถโทรออกได้ (โทร) ระบบปฏิบัติการทั่วไปอนุญาตให้ทำการเรียกระบบได้หลายร้อยครั้ง
ท้ายที่สุด เนื่องจากการจำลองเสมือนอนุญาตให้หลายโปรแกรมทำงาน (เช่น การแชร์ CPU) และเข้าถึงคำสั่งและข้อมูลพร้อมกัน (เช่น การแชร์หน่วยความจำ) และการเข้าถึงดิสก์ (เช่น การแชร์อุปกรณ์ I/O) ) ระบบปฏิบัติการจึงถูกเรียกว่า ผู้จัดการทรัพยากร โปรเซสเซอร์ ดิสก์ และหน่วยความจำแต่ละตัวเป็นทรัพยากรของระบบ ดังนั้นบทบาทหนึ่งของระบบปฏิบัติการจึงกลายเป็นงานในการจัดการทรัพยากรเหล่านี้ โดยดำเนินการอย่างมีประสิทธิภาพ ตรงไปตรงมา หรือในทางกลับกัน ขึ้นอยู่กับงานที่ระบบปฏิบัติการนี้ทำ ถูกออกแบบ.
การจำลองเสมือนของ CPU
พิจารณาโปรแกรมต่อไปนี้:
(https://www.youtube.com/watch?v=zDwT5fUcki4&feature=youtu.be)
มันไม่ได้ดำเนินการพิเศษใด ๆ จริงๆ แล้ว ทำได้เพียงแค่เรียกใช้ฟังก์ชันเท่านั้น ปั่น() ซึ่งมีหน้าที่ตรวจสอบเวลาและกลับมาอีกครั้งหลังจากผ่านไปหนึ่งวินาที ดังนั้นจึงทำซ้ำสตริงที่ผู้ใช้ส่งผ่านเป็นอาร์กิวเมนต์อย่างไม่มีกำหนด
มารันโปรแกรมนี้และส่งผ่านอักขระ "A" เป็นอาร์กิวเมนต์ ผลลัพธ์ไม่น่าสนใจนัก - ระบบเพียงรันโปรแกรมที่แสดงอักขระ "A" เป็นระยะ
ตอนนี้เรามาลองใช้ตัวเลือกนี้เมื่อโปรแกรมเดียวกันหลายอินสแตนซ์กำลังทำงานอยู่ แต่แสดงตัวอักษรต่างกันเพื่อให้ชัดเจนยิ่งขึ้น ในกรณีนี้ผลลัพธ์จะแตกต่างออกไปบ้าง แม้ว่าเราจะมีโปรเซสเซอร์ตัวเดียว แต่โปรแกรมก็ทำงานพร้อมกัน มันเกิดขึ้นได้อย่างไร? แต่ปรากฎว่าระบบปฏิบัติการสร้างภาพลวงตาขึ้นมาโดยไม่ได้รับความช่วยเหลือจากความสามารถของฮาร์ดแวร์ ภาพลวงตาที่ว่าระบบมีโปรเซสเซอร์เสมือนหลายตัว โดยเปลี่ยนโปรเซสเซอร์ทางกายภาพตัวเดียวให้เป็นจำนวนอนันต์ตามทฤษฎี และด้วยเหตุนี้จึงทำให้ดูเหมือนว่าโปรแกรมทำงานพร้อมกันได้ ภาพลวงตานี้เรียกว่า การจำลองเสมือนของ CPU.
ภาพนี้ทำให้เกิดคำถามมากมาย เช่น ถ้าต้องการรันหลายโปรแกรมพร้อมกันจะรันตัวไหน? “นโยบาย” ของระบบปฏิบัติการมีหน้าที่รับผิดชอบต่อคำถามนี้ นโยบายถูกนำมาใช้ในหลายที่ใน OS และตอบคำถามเช่นนี้ และเป็นกลไกพื้นฐานที่ OS นำไปใช้ ดังนั้นบทบาทของระบบปฏิบัติการในฐานะผู้จัดการทรัพยากร
การจำลองเสมือนของหน่วยความจำ
ทีนี้มาดูความทรงจำกัน แบบจำลองทางกายภาพของหน่วยความจำในระบบสมัยใหม่จะแสดงเป็นอาร์เรย์ของไบต์. หากต้องการอ่านจากหน่วยความจำคุณต้องระบุ ที่อยู่ของเซลล์เพื่อเข้าถึงมัน หากต้องการเขียนหรืออัปเดตข้อมูล คุณต้องระบุข้อมูลและที่อยู่ของเซลล์ที่จะเขียนด้วย
มีการเข้าถึงหน่วยความจำอย่างต่อเนื่องระหว่างการทำงานของโปรแกรม โปรแกรมจัดเก็บโครงสร้างข้อมูลทั้งหมดไว้ในหน่วยความจำและเข้าถึงได้โดยดำเนินการตามคำสั่งต่างๆ ในขณะเดียวกัน คำแนะนำก็ถูกจัดเก็บไว้ในหน่วยความจำเช่นกัน ดังนั้นจึงเข้าถึงได้สำหรับคำขอแต่ละรายการสำหรับคำสั่งถัดไป
malloc() โทร
พิจารณาโปรแกรมต่อไปนี้ ซึ่งจัดสรรขอบเขตของหน่วยความจำโดยใช้การโทร มัลลอค () (https://youtu.be/jnlKRnoT1m0):
โปรแกรมทำหน้าที่หลายอย่าง ขั้นแรก จะจัดสรรหน่วยความจำบางส่วน (บรรทัดที่ 7) จากนั้นพิมพ์ที่อยู่ของเซลล์ที่จัดสรร (บรรทัดที่ 9) เขียนศูนย์ลงในช่องแรกของหน่วยความจำที่จัดสรร จากนั้น โปรแกรมจะเข้าสู่ลูปโดยเพิ่มค่าที่จัดเก็บไว้ในหน่วยความจำตามที่อยู่ในตัวแปร “p” นอกจากนี้ยังพิมพ์ ID กระบวนการของตัวเองด้วย รหัสกระบวนการจะไม่ซ้ำกันสำหรับแต่ละกระบวนการที่กำลังทำงานอยู่. หลังจากเปิดตัวหลายชุด เราจะพบกับผลลัพธ์ที่น่าสนใจ: ในกรณีแรก หากคุณไม่ทำอะไรเลยและเรียกใช้หลายชุด ที่อยู่จะแตกต่างออกไป แต่นี่ไม่อยู่ภายใต้ทฤษฎีของเรา! ถูกต้อง เนื่องจากการแจกแจงสมัยใหม่เปิดใช้งานการสุ่มหน่วยความจำตามค่าเริ่มต้น หากปิดใช้งานเราจะได้ผลลัพธ์ที่คาดหวัง - ที่อยู่หน่วยความจำของโปรแกรมที่ทำงานพร้อมกันสองโปรแกรมจะตรงกัน
ผลที่ได้คือปรากฎว่าโปรแกรมอิสระสองโปรแกรมทำงานร่วมกับพื้นที่ที่อยู่ส่วนตัวของตัวเอง ซึ่งจะถูกแมปโดยระบบปฏิบัติการในหน่วยความจำกายภาพ. ดังนั้น การใช้ที่อยู่หน่วยความจำภายในโปรแกรมหนึ่งจะไม่ส่งผลกระทบต่อโปรแกรมอื่น แต่อย่างใด และดูเหมือนว่าแต่ละโปรแกรมจะมีหน่วยความจำกายภาพเป็นของตัวเอง โดยมอบให้ทั้งหมด อย่างไรก็ตาม ความจริงก็คือหน่วยความจำกายภาพเป็นทรัพยากรที่ใช้ร่วมกันซึ่งจัดการโดยระบบปฏิบัติการ
ความสม่ำเสมอ
หัวข้อสำคัญอีกหัวข้อหนึ่งในระบบปฏิบัติการคือ - ความสม่ำเสมอ. คำนี้ใช้เมื่อพูดถึงปัญหาในระบบที่อาจเกิดขึ้นได้เมื่อทำงานกับหลาย ๆ อย่างพร้อมกันภายในโปรแกรมเดียวกัน ปัญหาความสอดคล้องเกิดขึ้นแม้ภายในระบบปฏิบัติการเอง ในตัวอย่างการจำลองเสมือนของหน่วยความจำและโปรเซสเซอร์ก่อนหน้านี้ เราพบว่าระบบปฏิบัติการจัดการหลายสิ่งหลายอย่างในเวลาเดียวกัน โดยจะเริ่มกระบวนการแรก จากนั้นกระบวนการที่สอง และอื่นๆ เมื่อปรากฎว่าพฤติกรรมนี้อาจนำไปสู่ปัญหาบางอย่างได้ ตัวอย่างเช่นโปรแกรมแบบมัลติเธรดสมัยใหม่ประสบปัญหาดังกล่าว
พิจารณาโปรแกรมต่อไปนี้:
โปรแกรมในฟังก์ชั่นหลักจะสร้างสองเธรดโดยใช้การโทร pthread_create(). ในตัวอย่างนี้ เธรดสามารถถือเป็นฟังก์ชันที่ทำงานในพื้นที่หน่วยความจำเดียวกันควบคู่ไปกับฟังก์ชันอื่นๆ โดยมีฟังก์ชันมากกว่าหนึ่งฟังก์ชันที่ทำงานในเวลาเดียวกันอย่างชัดเจน ในตัวอย่างนี้ แต่ละเธรดจะเริ่มต้นและดำเนินการฟังก์ชัน worker() ซึ่งจะเพิ่มตัวแปร,.
มารันโปรแกรมนี้ด้วยอาร์กิวเมนต์ 1000 กันดีกว่า อย่างที่คุณอาจเดาได้ ผลลัพธ์ควรเป็น 2000 เพราะแต่ละเธรดเพิ่มตัวแปร 1000 ครั้ง อย่างไรก็ตามทุกอย่างไม่ง่ายนัก เรามาลองรันโปรแกรมโดยเรียงลำดับตามขนาดการทำซ้ำให้มากขึ้น
โดยการป้อนตัวเลข เช่น 100000 เราคาดว่าจะเห็นผลลัพธ์เป็นตัวเลข 200000 อย่างไรก็ตาม ถ้าเรารันตัวเลข 100000 หลายครั้ง เราไม่เพียงแต่จะไม่เห็นคำตอบที่ถูกต้องเท่านั้น แต่ยังได้รับคำตอบที่ไม่ถูกต้องที่แตกต่างกันอีกด้วย คำตอบอยู่ที่ว่าในการเพิ่มจำนวนนั้น จำเป็นต้องมีการดำเนินการ XNUMX อย่าง คือ แยกตัวเลขออกจากหน่วยความจำ เพิ่มจำนวน แล้วเขียนตัวเลขกลับ เนื่องจากคำสั่งทั้งหมดนี้ไม่ได้ถูกดำเนินการแบบอะตอมมิก (ทั้งหมดในเวลาเดียวกัน) สิ่งแปลก ๆ เช่นนี้จึงสามารถเกิดขึ้นได้ ปัญหานี้เรียกว่าในการเขียนโปรแกรม สภาพการแข่งขัน. เมื่อกองกำลังที่ไม่รู้จักในช่วงเวลาที่ไม่รู้จักอาจส่งผลต่อการปฏิบัติงานของคุณ
ที่มา: will.com