อะไรเป็นตัวกำหนด“ ความเร็ว” ของภาษาการเขียนโปรแกรม


38

สมมติว่าโปรแกรมเขียนในสองภาษาที่แตกต่างกันปล่อยให้พวกเขาเป็นภาษา X และภาษา Y หากคอมไพเลอร์ของพวกเขาสร้างรหัสไบต์เดียวกันทำไมฉันควรใช้ภาษา X แทนภาษา Y? อะไรคือสิ่งที่กำหนดว่าภาษาใดภาษาหนึ่งเร็วกว่าภาษาอื่น?

ฉันถามสิ่งนี้เพราะบ่อยครั้งที่คุณเห็นผู้คนพูดว่า: "C เป็นภาษาที่เร็วที่สุด ATS เป็นภาษาที่รวดเร็วเหมือน C" ฉันพยายามเข้าใจความหมายของคำว่า "เร็ว" สำหรับการเขียนโปรแกรมภาษา


21
หากโปรแกรมหนึ่งเร็วกว่าอีกโปรแกรมหนึ่งแสดงว่าโปรแกรมนั้นไม่มีรหัสไบต์เดียวกัน
svick

5
ภาษาเป็นเพียงแนวคิดที่ใช้ในการเขียนโปรแกรมดังนั้นคุณจึงไม่สามารถพูดเกี่ยวกับความเร็วของภาษาได้
Juho

1
@ ราฟาเอลฉันรู้สึกว่ามันเป็นหัวข้อที่ไม่ชัดเจนและกว้างเกินไป ในขณะที่หัวข้อนั้นเหมาะกับวิศวกรรมซอฟต์แวร์มากขึ้นฉันสงสัยว่ามันจะถูกปิดเพราะ "กว้างเกินไป" ที่นั่น
David Richerby

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

ดังกล่าวข้างต้น ภาษาไม่ได้สร้างรหัสไบต์เดียวกัน บางภาษาง่ายต่อการแยกวิเคราะห์เป็นรหัสไบต์ บางคนมีความเป็นนามธรรมในระดับที่สูงขึ้น
superluminary

คำตอบ:


23

มีหลายเหตุผลที่อาจถูกพิจารณาให้เลือกภาษา X แทนภาษา Y การอ่านโปรแกรม, ความง่ายในการโปรแกรม, ความสะดวกในการพกพาไปยังหลาย ๆ แพลตฟอร์ม, การมีอยู่ของสภาพแวดล้อมการเขียนโปรแกรมที่ดี อย่างไรก็ตามฉันจะพิจารณาเฉพาะความเร็วของการดำเนินการตามที่ร้องขอในคำถาม คำถามดูเหมือนจะไม่ได้พิจารณาตัวอย่างเช่นความเร็วของการพัฒนา

สองภาษาสามารถคอมไพล์ด้วยรหัสไบต์เดียวกัน แต่ไม่ได้หมายความว่าจะสร้างรหัสเดียวกัน

bytecode จริง ๆ แล้วเป็นรหัสสำหรับเครื่องเสมือนเฉพาะเท่านั้น มันมีข้อได้เปรียบทางวิศวกรรม แต่ไม่ได้แนะนำความแตกต่างพื้นฐานด้วยการรวบรวมโดยตรงสำหรับฮาร์ดแวร์ที่เฉพาะเจาะจง ดังนั้นคุณอาจพิจารณาเปรียบเทียบสองภาษาที่คอมไพล์เพื่อประมวลผลโดยตรงบนเครื่องเดียวกัน

สิ่งนี้กล่าวว่าปัญหาความเร็วของภาษาค่อนข้างเก่าโดยย้อนหลังไปถึงคอมไพเลอร์ตัวแรก

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

ดังนั้นภาษาเครื่องจึงเร็วกว่าคำว่า Fortran

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

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

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

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

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

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

บางปัญหาอื่น ๆ จะถูกโปรแกรมได้อย่างง่ายดายมากขึ้นด้วยการดำเนินการได้เร็วขึ้นโดยใช้โปรแกรมตรรกะและภาษามติ จำกัด

ระบบรีแอคทีฟที่ซับซ้อนสามารถตั้งโปรแกรมได้อย่างมีประสิทธิภาพด้วยภาษาการเขียนโปรแกรมแบบซิงโครนัสพิเศษเช่นEsterelซึ่งรวบรวมความรู้พิเศษเกี่ยวกับระบบดังกล่าวและสร้างโค้ดที่รวดเร็วมาก

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

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

อีกประเด็นที่สำคัญคือการมีห้องสมุดที่มีประสิทธิภาพสำหรับหัวข้อที่กำลังตั้งโปรแกรม

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

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


ขอบคุณ มันเป็นอย่างนั้น ฉันกำลังมองหา. มันยากที่จะหาวัสดุสำหรับเรื่อง เรื่องนี้ชัดเจนพอสมควร
Rodrigo Valente

@ RodrigoAraújoValenteขอบคุณคุณอาจต้องการดูคำถามนี้ มุมมองสุดโต่งคือคอมไพเลอร์สำหรับภาษา L สามารถรวมล่ามสำหรับ L กับซอร์สโค้ดของโปรแกรมโดยไม่ต้องทำอะไรเลย จากนั้นคุณสามารถทำได้ดีขึ้นโดยพยายามปรับการคำนวณของบันเดิลให้เหมาะสม (การประเมินบางส่วน) ยิ่งคุณเพิ่มประสิทธิภาพและภาษาของคุณก็จะเร็วขึ้นเท่านั้น คำถามคือสิ่งที่สามารถช่วยคุณเพิ่มประสิทธิภาพได้อย่างไร คำตอบอาจรวมถึงความรู้ที่ดีของสาขาวิชาเฉพาะความช่วยเหลือจากโปรแกรมเมอร์, การวิเคราะห์ที่มีความซับซ้อน ฯลฯ ...
Babou

โดย "bytecode เดียวกัน" ฉันเดาว่าคุณหมายถึง "เดียวกันชนิดของการแสดง" ปฏิบัติการ เห็นได้ชัดว่า executables ที่เหมือนกันจะทำงานที่ความเร็วเดียวกัน (สมมติว่าระบบปฏิบัติการเดียวกัน) (ฉันอาจจะดูที่นี้จากมุมมองข้อมูล / การสื่อสารในทางทฤษฎีโปรแกรมเมอร์สามารถรู้ทุกอย่างเกี่ยวกับโปรแกรมและฮาร์ดแวร์ในขณะที่ภาษามักจะ จำกัด การสื่อสาร (จำกัด สิ่งที่ได้รับอนุญาตหรือมีประโยชน์ tranformations) และคอมไพเลอร์อาจไม่ทราบ รายละเอียดทางสถาปัตยกรรมขนาดเล็กการรวบรวมและการพัฒนาคอมไพเลอร์เป็นการวิเคราะห์เพื่อการพัฒนาและการฝึกอบรม ...
Paul A. Clayton

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

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

16

ในขณะที่ทุกอย่างทำงานบน CPU *ในที่สุดก็มีความแตกต่างหลากหลายระหว่างภาษาที่แตกต่างกัน นี่คือตัวอย่างบางส่วน.

ตีความภาษาบางภาษามีการตีความมากกว่ารวบรวมตัวอย่างเช่นงูหลาม, ทับทิมและ Matlab นั่นหมายความว่ารหัส Python และ Ruby ไม่ได้คอมไพล์กับรหัสเครื่อง แต่ถูกตีความแบบ on-the-fly เป็นไปได้ที่จะรวบรวม Python และ Ruby ไปยังเครื่องเสมือน (ดูจุดต่อไป) ดูคำถามนี้ด้วย โดยทั่วไปแล้วการตีความจะช้ากว่าโค้ดที่คอมไพล์ด้วยเหตุผลต่างๆ ไม่เพียง แต่สามารถตีความตัวเองช้าเท่านั้น แต่ยังเป็นการยากที่จะปรับให้เหมาะสม อย่างไรก็ตามหากโค้ดของคุณใช้เวลาส่วนใหญ่ในฟังก์ชั่นห้องสมุด (กรณีของ Matlab) ประสิทธิภาพจะไม่ลดลง

เครื่องเสมือนบางภาษาถูกคอมไพล์เป็นbytecodeซึ่งเป็น "รหัสเครื่อง" ที่ประดิษฐ์ขึ้นมาซึ่งจะถูกตีความ ตัวอย่างที่เป็นแก่นสารคือ Java และ C # ในขณะที่ bytecode สามารถแปลงเป็นรหัสเครื่องได้ทันทีรหัสอาจจะยังทำงานช้าลง ในกรณีของ Java เครื่องเสมือนจะใช้เพื่อการพกพา ในกรณีของ C # อาจมีข้อกังวลอื่น ๆ เช่นความปลอดภัย

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

*ในความเป็นจริงแล้วทุกวันนี้ระบบที่มีประสิทธิภาพสูงยังใช้งานโค้ดบน GPU และแม้แต่ใน FPGA


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

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

@ RodrigoAraújoValenteขึ้นอยู่กับ รหัสเส็งเคร็งมักจะรวบรวมรหัสเส็งเคร็ง บางทีรหัสที่คุณเขียนใน Python นั้นอาจเร็วกว่ารหัสที่คุณเขียนใน C
Raphael

nit: ตามที่อธิบายโดยคำถามที่คุณเชื่อมโยงไป, python ไม่ได้แปลว่า "on-the-fly" จริง ๆ :)
Eevee

ไม่มีภาษาใดที่คุณพูดถึงในส่วนที่ตีความถูกตีความในทันที Python ถูกคอมไพล์ไปเป็น bytecode, Ruby ถูกคอมไพล์เป็น AST, แต่ตอนนี้ฉันเชื่อว่าถูกคอมไพล์เป็น bytecode Matlab ฉันเชื่อว่าตอนนี้เป็นจริง JIT รวบรวม ที่จริงแล้วฉันไม่ทราบว่าการใช้ภาษาที่ไม่เจาะจงใด ๆ ที่ตีความสิ่งต่าง ๆ ได้อย่างรวดเร็ว แต่อย่างน้อยก็คอมไพล์เป็นตัวแทนของเครื่องเสมือนบางชนิด
Winston Ewert

5

มีปัจจัยที่แตกต่างกันสำหรับการเลือก X แทน Y เช่น

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

บางภาษาเหมาะสำหรับการพัฒนาโครงการธุรกิจเช่น C # หรือ Python แต่ในทางกลับกันบางภาษานั้นเหมาะสำหรับการเขียนโปรแกรมระบบเช่น C ++

คุณต้องพิจารณาว่าคุณกำลังจะใช้แพลตฟอร์มใดและแอปพลิเคชันที่คุณกำลังจะสร้าง


1
ดังนั้นฉันจะกำหนดประสิทธิภาพของโค้ดที่คอมไพล์ได้อย่างไร นั่นเป็นสิ่งที่ทำให้ฉันทำคำถามนี้
Rodrigo Valente

6
คำตอบนี้มีคำแนะนำที่ดี แต่ฉันไม่เห็นว่าจะตอบคำถามได้อย่างไรซึ่งเกี่ยวกับความเร็วเป็นปัจจัยทางเลือกสำหรับภาษา
babou

@ RodrigoAraújoValenteพวกเขาอาจไม่ได้รวบรวมรหัส (ถ้าแปลภาษาของคุณ)
Raphael

1
คุณอาจต้องการเพิ่ม "ห้องสมุดที่ดี" และ "เครื่องมือที่ดี"
Raphael

@ RodrigoAraújoValenteคุณเรียกใช้และโปรไฟล์
Kyle

2

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

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

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

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

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

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

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


ในอดีต C ถูกออกแบบมาเพื่อให้ง่ายต่อการแปลเป็นรหัสเครื่อง อย่างไรก็ตามในระดับที่เพิ่มขึ้นการเปลี่ยน C เป็นรหัส C ที่มีประสิทธิภาพต้องการให้คอมไพเลอร์เข้าใจว่าโปรแกรมเมอร์กำลังพยายามทำอะไรแล้วแปลความตั้งใจนั้นเป็นรหัสเครื่อง ยกตัวอย่างเช่นในอดีตรหัสเครื่องเทียบเท่า*p++=*q++;กับในหลาย ๆ เครื่องได้เร็วกว่าarray1[i]=array2[i];แต่ในหลาย ๆ ตัวประมวลผลที่ตรงกันข้ามมักจะเป็นความจริงและคอมไพเลอร์อาจจบลงด้วยการแปลงรูปแบบของรหัสก่อนหลัง - แทบจะเป็นการแปลง "ตื้น"
supercat

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

2

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

ตัวอย่างเช่นหากไม่มี "ใช้เข้มงวด" ชิ้นส่วนของรหัสเช่น:

function f() { return x; }

อาจจะกลับมาตัวแปร X ในบริบทโทรทันทีหากมีหนึ่งหรือตัวแปร X Undefinedจากบริบทโทรนอกหรือมันอาจจะกลับมา เลวลงในวงเช่น:

for (i=0; i<40; i+=1) { g(i); }

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


2

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

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

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

ดำเนินการต่อในทิศทางนี้คำสั่งที่ไม่จำเป็นเหล่านั้นจะเพิ่มจำนวนขึ้น (โดยปกติ) เนื่องจากภาษามีระดับสูงขึ้น (นี่ไม่จริง 100% สำหรับภาษาระดับสูงทั้งหมด)

สำหรับฉันแล้วภาษา X เร็วกว่าภาษา Y (ในขณะรันไทม์) หากสำหรับรหัสบางส่วนรหัสเครื่องของ X จะสั้นกว่าของ Y


ประกอบหินทั้งหมด มันต้องใช้ศิลปินที่แท้จริงในการเอาชนะผู้แต่งที่ดีที่สุด
Johan

1

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

  • RQ1 ภาษาโปรแกรมใดที่สร้างรหัสที่กระชับมากขึ้น?

  • RQ2 ภาษาการเขียนโปรแกรมใดที่คอมไพล์เป็นเอ็กซีคิ้วท์ขนาดเล็ก?

  • RQ3 ภาษาการเขียนโปรแกรมใดที่มีประสิทธิภาพดีกว่าเวลาทำงาน?

  • RQ4 ภาษาโปรแกรมใดใช้หน่วยความจำได้อย่างมีประสิทธิภาพมากขึ้น

  • RQ5 ภาษาการเขียนโปรแกรมใดที่มีความล้มเหลวน้อยลง

บทคัดย่อ - บางครั้งการโต้วาทีในภาษาการเขียนโปรแกรมนั้นมีความเคร่งศาสนามากกว่าทางวิทยาศาสตร์ คำถามเกี่ยวกับภาษาที่กระชับหรือมีประสิทธิภาพมากขึ้นหรือทำให้นักพัฒนามีประสิทธิผลมากขึ้นได้รับการพูดคุยกับความร้อนแรงและคำตอบของพวกเขามักจะมาจากเกร็ดเล็กเกร็ดน้อยและความเชื่อที่ไม่แน่นอน ในการศึกษานี้เราใช้ศักยภาพการวิจัยที่ไม่ได้ใช้เป็นส่วนใหญ่ของ Rosetta Code ซึ่งเป็นที่เก็บรหัสของโซลูชันสำหรับงานการเขียนโปรแกรมทั่วไปในภาษาต่างๆซึ่งมีชุดข้อมูลขนาดใหญ่สำหรับการวิเคราะห์ การศึกษาของเราอยู่บนพื้นฐานของ 7,087 โปรแกรมการแก้ปัญหาที่สอดคล้องกับงาน 745 ใน 8 ภาษาที่ใช้กันอย่างแพร่หลายเป็นตัวแทนกระบวนทัศน์การเขียนโปรแกรมที่สำคัญ (ขั้นตอน: C และ Go; เชิงวัตถุ: C # และ Java; การทำงาน: F # และ Haskell; การวิเคราะห์ทางสถิติของเราแสดงให้เห็นอย่างเด่นชัดที่สุดว่า: ภาษาหน้าที่และสคริปต์มีความกระชับมากกว่าภาษาเชิงปฏิบัติและเชิงวัตถุ C ยากที่จะเอาชนะเมื่อพูดถึงความเร็วดิบของอินพุตขนาดใหญ่ แต่ความแตกต่างด้านประสิทธิภาพของอินพุตที่มีขนาดปานกลางนั้นมีความเด่นชัดน้อยกว่าและทำให้ภาษาที่ตีความได้แข่งขันกันได้ ภาษาที่พิมพ์อย่างรุนแรงที่รวบรวมซึ่งสามารถจับข้อบกพร่องได้มากขึ้นในเวลารวบรวมนั้นมีแนวโน้มที่จะเกิดข้อผิดพลาดรันไทม์น้อยกว่าภาษาที่ถูกตีความหรือพิมพ์อย่างอ่อน เราพูดถึงผลกระทบของผลลัพธ์เหล่านี้สำหรับนักพัฒนานักออกแบบภาษาและนักการศึกษา ซึ่งข้อบกพร่องเพิ่มเติมสามารถตรวจจับได้ในเวลารวบรวมมีแนวโน้มที่จะเกิดความล้มเหลวรันไทม์น้อยกว่าภาษาที่ตีความหรือพิมพ์อย่างอ่อน เราพูดถึงผลกระทบของผลลัพธ์เหล่านี้สำหรับนักพัฒนานักออกแบบภาษาและนักการศึกษา ซึ่งข้อบกพร่องเพิ่มเติมสามารถตรวจจับได้ในเวลารวบรวมมีแนวโน้มที่จะเกิดความล้มเหลวรันไทม์น้อยกว่าภาษาที่ตีความหรือพิมพ์อย่างอ่อน เราพูดถึงผลกระทบของผลลัพธ์เหล่านี้สำหรับนักพัฒนานักออกแบบภาษาและนักการศึกษา


0

ภาษาคอมพิวเตอร์เป็นเพียงส่วนหนึ่งของคำสั่งเพื่ออธิบายคอมพิวเตอร์ว่าจะทำอย่างไร

คุณสามารถเขียนภาษาคอมพิวเตอร์Pythonและคอมไพล์มันด้วยคอมไพเลอร์ C (cython)

โดยคำนึงถึงความเร็วของภาษาคอมพิวเตอร์ที่ไม่สามารถนำมาเปรียบเทียบได้

แต่คุณสามารถเปรียบเทียบคอมไพเลอร์สำหรับภาษาเดียวกันจนถึงบางส่วนได้ ตัวอย่างGNU Cคอมไพเลอร์กับIntel Cคอมไพเลอร์ (ค้นหาเกณฑ์มาตรฐานคอมไพเลอร์)


2
หากคุณต้องการแสดงความคิดเห็นเกี่ยวกับคำถามโปรดใช้ช่องแสดงความคิดเห็นไม่ใช่คำตอบของคุณ ทราบว่านี้เป็นวิทยาศาสตร์คอมพิวเตอร์ Stack แลกเปลี่ยนและวิทยาศาสตร์คอมพิวเตอร์ไม่ได้เขียนโปรแกรมเช่นเดียวกับวรรณกรรมไม่ได้ประมวลผลคำ คำถาม Programming อาศัยอยู่บนวิศวกรรมซอฟต์แวร์หรือกองมากเกิน
David Richerby
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.