ทำไมไม่มีระบบปฏิบัติการภาษาระดับสูง? ภาษาระดับต่ำมีประสิทธิภาพมากขึ้นหรือไม่

โดยไม่ต้องเกรงใจฉันอยากให้คุณพิจารณาความเป็นไปได้ของสิ่งนี้ ระบบปฏิบัติการส่วนใหญ่ในปัจจุบันนี้ใช้ภาษาระดับต่ำ (ส่วนใหญ่ C / C ++) แม้แต่ภาษาใหม่เช่น Android ใช้ JNI และการใช้งานพื้นฐานอยู่ใน C

ในความเป็นจริง (นี่เป็นการสังเกตการณ์ส่วนตัว) หลายโปรแกรมที่เขียนใน C ทำงานเร็วกว่าโปรแกรมระดับสูง (เช่น: การส่ง (ไคลเอนต์ bittorrent บน Ubuntu) เป็นจำนวนมากเร็วกว่า Vuze (Java) หรือ Deluge (Python) ) แม้แต่คอมไพเลอร์ไพ ธ อนก็เขียนด้วยภาษา C ถึงแม้ว่า PyPy จะเป็นข้อยกเว้น

ดังนั้นมีเหตุผลพิเศษสำหรับเรื่องนี้หรือไม่? ทำไมมันจึงเรียกว่า "ภาษาระดับสูง" ของเราที่มีแนวคิด "OOP" ที่ยอดเยี่ยมไม่สามารถใช้ในการสร้างระบบปฏิบัติการที่มั่นคง?

ดังนั้นฉันมี 2 คำถามโดยทั่วไป

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

Microsoft ได้ทำการวิจัยที่น่าสนใจมากในทิศทางนี้หากคุณพิจารณาภาวะเอกฐาน:

http://research.microsoft.com/en-us/projects/singularity/

นอกจากนี้ Mothy Roscoe et al ยังทำงานกับ Barrelfish ซึ่งใช้ภาษาการเขียนโปรแกรมข้อ จำกัด Eclipse เป็นบริการ OS เพื่อแยกแยะปัญหาการจัดการ OS และปัญหาการจัดสรรทรัพยากรทุกประเภท:

http://www.barrelfish.org/

มากขึ้นอยู่กับที่คุณวางการแบ่งระหว่างภาษาระดับต่ำและระดับสูง ตัวอย่างเช่นคนที่แตกต่างกันมักจะใส่ภาษาเช่น C ++ ลงไปในด้านที่แตกต่างกันของการแบ่งนั้น

เกี่ยวกับคำถามของคุณ:

1. ฉันไม่เชื่อว่ามีความแตกต่างระหว่างภาษาระดับต่ำและระดับสูง แต่มีความแตกต่างระหว่างภาษาที่ตีความและภาษาที่รวบรวมคำสั่งดั้งเดิม

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

2. หากคุณคิดว่า C ++ เป็นระดับสูงแสดงว่ามีระบบปฏิบัติการอย่างน้อยหนึ่งระบบที่เขียนด้วยภาษาระดับสูงทั้งหมด (Symbian OS เขียนด้วยภาษา C ++) สิ่งที่ทำให้คุณไม่สามารถเขียนระบบปฏิบัติการในภาษาระดับสูงส่วนใหญ่มีสองสิ่ง:

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

มีหลายเหตุผลที่ดีสำหรับสิ่งนี้

ภาษาระดับต่ำของวันนี้เป็นภาษาระดับสูงของเมื่อวาน

ใช่เชื่อหรือไม่กาลครั้งหนึ่งแม้กระทั่ง C ถูกมองว่าเป็นภาษาระดับสูง แม้กระทั่งเมื่อ 20 ปีก่อนมันเป็นเรื่องธรรมดาพอที่จะเห็นมันอธิบายว่าเป็นภาษา "ระดับกลาง" นี่เป็นช่วงเวลาก่อนที่ OO จะได้รับความนิยมอย่างที่ทุกวันนี้ Java ไม่มีอยู่จริง C # ไม่มีอยู่แม้แต่ C ++ ก็ยังไม่ได้มาตรฐานอย่างถูกต้อง

ความเฉื่อยทางประวัติศาสตร์

ระบบปฏิบัติการที่คุณใช้ในปัจจุบันมีรากฐานที่ลึกล้ำในประวัติศาสตร์ Windows กลับไปที่ต้น / กลาง 80s, Unix กลับไปที่ต้น / กลางยุค 70 มีโค้ดเก่าจำนวนมากที่ใช้งานได้ในระบบปฏิบัติการและโดยทั่วไปคุณไม่ต้องการเขียนโค้ดเก่าที่ใช้งานได้

ในบางจุดคุณต้องลงไปที่ฮาร์ดแวร์

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

ความเบา

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

ความชอบส่วนบุคคล

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

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

เหตุผลหลักสำหรับการครอบงำของ C สำหรับระบบปฏิบัติการอยู่ในประวัติศาสตร์ - ระบบปฏิบัติการกระแสหลักในปัจจุบันเช่น Windows และ Unix ทุกรูปแบบ (BSD, Solaris, HP-UX, MacOS X, ... และโคลนเช่น Linux) กลับไป เป็นเวลานานก่อนที่ OO และสิ่งก่อสร้าง "ระดับสูง" อื่น ๆ จะกลายเป็นกระแสหลัก

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

สำหรับระบบฝังตัวบางครั้งมีระบบปฏิบัติการที่ใช้ภาษาระดับสูงกว่าสำหรับส่วนต่าง ๆ ของระบบ ตัวอย่างหนึ่งที่น่าสังเกตคือJavaOSโดย Sun

สำหรับระบบปฏิบัติการที่แพร่หลายตัวอย่างที่เด่นชัดที่ไม่ได้ใช้ C ก็คือ MacOS แบบคลาสสิกก่อน MacOS X - ซึ่งส่วนใหญ่เขียนด้วยภาษา Pascalซึ่งอนุญาตให้วางแนววัตถุบางรูปแบบ

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

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

กล่าวอีกนัยหนึ่งเมื่อคุณคำนึงถึงข้อ จำกัด และการดัดแปลงทั้งหมดที่คุณต้องยอมรับ C และ C ++ เริ่มมองหาง่ายขึ้นมาก

ก่อนอื่น bootstrapping ต้องการอย่างน้อยส่วนเล็ก ๆ ที่จะเขียนในการประกอบหรือเทียบเท่า

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

ประการที่สาม C ++ ค่อนข้างเชิงวัตถุและอยู่ในระดับสูงดังนั้นอย่างที่คนอื่น ๆ ชี้ให้เห็นSymbian OSเป็นอีกตัวอย่างหนึ่ง

สี่มีความต้องการน้อยสำหรับระบบปฏิบัติการใหม่ในเวลานี้ เรามีลินุกซ์และ bsd ไม่กี่รสชาติที่ทำงานบนฮาร์ดแวร์เกือบทุกชนิดและการสร้างระบบปฏิบัติการใหม่ล่าสุดนั้นค่อนข้างแพง

เพื่อดีกว่าขั้นตอนที่ฉันเขียนไว้ก่อนหน้านี้

เครื่อง Burroughs 5xxx - 6xxx ไม่มีภาษาแอสเซมบลี ภาษาต่ำสุดที่มีคือส่วนขยายของ Algol Algol ถูกนำมาใช้ในฮาร์ดแวร์ ระบบปฏิบัติการและภาษาทั้งหมดเขียนเป็นภาษาอัลกอล มันมีประสิทธิภาพสูงกว่าเครื่องจักรของคู่แข่งทั้งหมดในเวลานั้น นอกจากนี้ยังต้องใช้รหัสน้อยลงซึ่งทำให้ง่ายต่อการบำรุงรักษา มันมีฮาร์ดแวร์สแต็คที่รองรับภาษาแบบเรียกซ้ำเช่น Algol

ระบบปฏิบัติการ Burroughs พัฒนาเป็นรุ่นที่เรียกว่า MCP ปัจจุบัน MCP ทำงานบนระบบ Unisys

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

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

ตอนนี้คุณอาจยืนยันว่า C ++ เป็นตัวเลือกที่ดีเนื่องจากมีการจัดการหน่วยความจำด้วยตนเอง C ++ ได้ถูกใช้ไปแล้วในระบบปฏิบัติการบางระบบเช่น Symbian (ที่กล่าวถึงโดยBart ) และ BeOS แต่ IMHO C ยังคงเป็นภาษาที่เร็วที่สุดที่สามารถจัดวางในสถาปัตยกรรมจำนวนมากได้โดยไม่ต้องใช้ความพยายามมาก (ตรงกันข้ามกับการประกอบสถาปัตยกรรมเฉพาะ)

_{[i]: ระบบปฏิบัติการสมัยใหม่รุ่นที่ 3, หน้า 73}

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

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

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

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

มีระบบปฏิบัติการต่างๆที่เขียนในภาษาระดับสูงมีจุดประสงค์หลักของการวิจัยเช่นOberonและเป็นเอกเทศ