รวบรวมได้อย่างไรอย่างรวดเร็ว

ฉัน Googled และแหย่ไปที่เว็บไซต์ Go แต่ดูเหมือนว่าฉันจะไม่สามารถหาคำอธิบายสำหรับเวลาสร้างที่ไม่ธรรมดาของ Go พวกเขาเป็นผลิตภัณฑ์ของคุณสมบัติภาษา (หรือขาดมัน), คอมไพเลอร์เพิ่มประสิทธิภาพสูงหรืออย่างอื่น? ฉันไม่พยายามโปรโมตไป; ฉันแค่อยากรู้

การวิเคราะห์การพึ่งพา

ไปคำถามที่พบบ่อยที่ใช้จะมีประโยคต่อไปนี้:

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

ในขณะที่วลีไม่ได้อยู่ในคำถามที่พบบ่อยอีกต่อไปแล้วหัวข้อนี้จะกล่าวถึงใน Talk Go at Googleซึ่งเปรียบเทียบวิธีการวิเคราะห์การพึ่งพาของ C / C ++ และ Go

นั่นคือเหตุผลหลักของการรวบรวมที่รวดเร็ว และนี่คือการออกแบบ

ฉันคิดว่ามันไม่ได้ว่าคอมไพเลอร์ไปเป็นอย่างรวดเร็วก็ว่าคอมไพเลอร์อื่น ๆ จะช้า

คอมไพเลอร์ C และ C ++ ต้องแยกส่วนหัวจำนวนมหาศาล - ตัวอย่างเช่นการคอมไพล์ C ++ "hello world" ต้องมีการคอมไพล์โค้ด 18k บรรทัดซึ่งเกือบครึ่งเมกะไบต์ของแหล่งที่มา!

$ cpp hello.cpp | wc
  18364   40513  433334

คอมไพเลอร์ Java และ C # ทำงานใน VM ซึ่งหมายความว่าก่อนที่พวกเขาจะสามารถรวบรวมสิ่งใดระบบปฏิบัติการจะต้องโหลด VM ทั้งหมดจากนั้นพวกเขาจะต้องรวบรวม JIT จาก bytecode ไปเป็นรหัสเนทีฟซึ่งทั้งหมดใช้เวลาพอสมควร

ความเร็วในการรวบรวมขึ้นอยู่กับหลายปัจจัย

บางภาษาได้รับการออกแบบให้รวบรวมอย่างรวดเร็ว ตัวอย่างเช่น Pascal ได้รับการออกแบบให้คอมไพล์ด้วยคอมไพเลอร์ผ่านครั้งเดียว

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

มีหลายสาเหตุที่ทำให้คอมไพเลอร์ Go เร็วกว่าคอมไพเลอร์ C / C ++ ส่วนใหญ่:

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

• เหตุผลด้านบน : ความเร็วในการรวบรวมที่รวดเร็วเป็นตัวเลือกที่ใส่ใจในคอมไพเลอร์ Go และในภาษา Go

• คอมไพเลอร์ Go มีเครื่องมือเพิ่มประสิทธิภาพที่ง่ายกว่าคอมไพเลอร์ C / C ++

• ต่างจาก C ++, Go ไม่มีเทมเพลตและไม่มีฟังก์ชั่นอินไลน์ ซึ่งหมายความว่า Go ไม่จำเป็นต้องดำเนินการใด ๆ กับอินสแตนซ์ของแม่แบบหรือฟังก์ชัน

• คอมไพเลอร์ Go สร้างรหัสแอสเซมบลีระดับต่ำในไม่ช้าและเครื่องมือเพิ่มประสิทธิภาพทำงานกับแอสเซมบลีโค้ดในขณะที่คอมไพเลอร์ C / C ++ ทั่วไปการเพิ่มประสิทธิภาพผ่านการทำงานในการเป็นตัวแทนภายในของรหัสต้นฉบับดั้งเดิม โอเวอร์เฮดพิเศษในคอมไพเลอร์ C / C ++ มาจากข้อเท็จจริงที่ว่าจำเป็นต้องสร้างการแสดงภายใน

• การลิงก์ขั้นสุดท้าย (5l / 6l / 8l) ของโปรแกรม Go อาจช้ากว่าการลิงก์โปรแกรม C / C ++ เนื่องจากคอมไพเลอร์ Go กำลังดำเนินการผ่านแอสเซมบลีรหัสที่ใช้ทั้งหมดและอาจเป็นการกระทำพิเศษอื่น ๆ ที่ C / C ++ ลิงเกอร์ไม่ทำงาน

• คอมไพเลอร์ C / C ++ บางตัว (GCC) สร้างคำแนะนำในรูปแบบข้อความ (จะถูกส่งผ่านไปยังแอสเซมเบลอร์) ในขณะที่คอมไพเลอร์ Go สร้างคำแนะนำในรูปแบบไบนารี ต้องทำงานพิเศษ (แต่ไม่มาก) เพื่อที่จะแปลงข้อความเป็นไบนารี

• คอมไพเลอร์ Go กำหนดเป้าหมายเฉพาะสถาปัตยกรรมซีพียูจำนวนน้อยในขณะที่คอมไพเลอร์ GCC มีเป้าหมายเป็นซีพียูจำนวนมาก

• คอมไพเลอร์ที่ออกแบบโดยมีเป้าหมายในการรวบรวมความเร็วสูงเช่น Jikes นั้นรวดเร็ว สำหรับซีพียู 2GHz Jikes สามารถคอมไพล์โค้ด Java ได้ 20,000 บรรทัดต่อวินาที (และโหมดการรวบรวมที่เพิ่มขึ้นนั้นมีประสิทธิภาพมากกว่า)

ประสิทธิภาพการรวบรวมเป็นเป้าหมายการออกแบบที่สำคัญ:

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

คำถามที่พบบ่อยเกี่ยวกับภาษานั้นค่อนข้างน่าสนใจเกี่ยวกับคุณสมบัติภาษาเฉพาะที่เกี่ยวข้องกับการวิเคราะห์คำ:

ประการที่สองภาษาได้รับการออกแบบให้ง่ายต่อการวิเคราะห์และสามารถแยกวิเคราะห์ได้โดยไม่มีตารางสัญลักษณ์

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

ไปจะต้องรวมถึงแพคเกจที่คุณกำลังนำเข้าโดยตรง (เช่นที่นำเข้าแล้วสิ่งที่พวกเขาต้องการ) นี่คือความแตกต่างอย่างสิ้นเชิงกับ C / C ++ ที่ทุกไฟล์เดียวเริ่มรวมถึงส่วนหัว x ซึ่งรวมถึงส่วนหัว y ฯลฯ ด้านล่างบรรทัด: การรวบรวมของ Go ใช้เวลาเชิงเส้น wrt จำนวนแพคเกจที่นำเข้าที่ C / C ++ ใช้เวลาชี้แจง

การทดสอบที่ดีสำหรับประสิทธิภาพการแปลของคอมไพเลอร์คือการรวบรวมตนเอง: ใช้เวลานานแค่ไหนที่คอมไพเลอร์ที่ได้รับจะรวบรวมตัวเอง? สำหรับ C ++ ต้องใช้เวลานาน (ชั่วโมง?) โดยการเปรียบเทียบคอมไพเลอร์ Pascal / Modula-2 / Oberon จะรวบรวมตัวเองในเวลาน้อยกว่าหนึ่งวินาทีในเครื่องจักรที่ทันสมัย ​​[1]

Go ได้รับแรงบันดาลใจจากภาษาเหล่านี้ แต่เหตุผลสำคัญบางประการสำหรับประสิทธิภาพนี้ ได้แก่ :

1. ไวยากรณ์ที่กำหนดไว้อย่างชัดเจนที่มีเสียงทางคณิตศาสตร์สำหรับการสแกนและการแยกวิเคราะห์ที่มีประสิทธิภาพ

2. ภาษาชนิดปลอดภัยและแบบคงที่รวบรวมที่ใช้แยกต่างหากสะสมที่มีการพึ่งพาและประเภทของการตรวจสอบข้ามเขตแดนโมดูลเพื่อหลีกเลี่ยงการที่ไม่จำเป็นอีกครั้งอ่านไฟล์ส่วนหัวและอีกรวบรวมของโมดูลอื่น ๆ - เมื่อเทียบกับอิสระสะสมเหมือนใน C / C ++ ที่ ไม่มีการตรวจสอบข้ามโมดูลดังกล่าวโดยคอมไพเลอร์ (ดังนั้นจึงจำเป็นต้องอ่านไฟล์ส่วนหัวทั้งหมดซ้ำแล้วซ้ำอีกแม้จะเป็นโปรแกรม "Hello world" แบบบรรทัดเดียวอย่างง่าย)

3. การใช้งานคอมไพเลอร์ที่มีประสิทธิภาพ (เช่น single-pass, การแยกวิเคราะห์จากบนลงล่างแบบเรียกซ้ำ) - ซึ่งแน่นอนว่าได้รับการช่วยเหลืออย่างมากจากคะแนน 1 และ 2 ข้างต้น

หลักการเหล่านี้ได้รับการยอมรับและนำมาใช้อย่างเต็มที่ในปี 1970 และ 1980 ในภาษาต่างๆเช่น Mesa, Ada, Modula-2 / Oberon และอีกหลายคนและตอนนี้ (ในปี 2010) หาทางเป็นภาษาสมัยใหม่เช่น Go (Google) , Swift (Apple), C # (Microsoft) และอื่น ๆ อีกมากมาย

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

1. อันดับแรกผู้ให้บริการแพลตฟอร์มซอฟต์แวร์เช่น Google, Microsoft และ Apple ควรเริ่มต้นด้วยการสนับสนุนให้นักพัฒนาแอปพลิเคชันใช้วิธีการรวบรวมใหม่ในขณะที่ทำให้พวกเขาสามารถใช้ฐานรหัสที่มีอยู่อีกครั้งได้ นี่คือสิ่งที่ Apple พยายามทำกับภาษาการเขียนโปรแกรม Swift ซึ่งสามารถอยู่ร่วมกับ Objective-C (เนื่องจากใช้สภาพแวดล้อมรันไทม์เดียวกัน)

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

ไม่ว่าในกรณีใดมันเป็นแพลตฟอร์มที่ขับเคลื่อนการยอมรับภาษาไม่ใช่วิธีอื่น

อ้างอิง:

[1] http://www.inf.ethz.ch/personal/wirth/ProjectOberon/PO.System.pdfหน้า 6: "คอมไพเลอร์รวบรวมตัวเองในเวลาประมาณ 3 วินาที" คำพูดนี้ใช้สำหรับบอร์ดพัฒนา FPGA Xilinx Spartan-3 ต้นทุนต่ำที่ทำงานที่ความถี่สัญญาณนาฬิกา 25 MHz และมีหน่วยความจำหลัก 1 MByte จากสิ่งนี้สามารถคาดการณ์ได้ง่ายถึง "น้อยกว่า 1 วินาที" สำหรับโปรเซสเซอร์ที่ทันสมัยที่ทำงานที่ความถี่สัญญาณนาฬิกาที่สูงกว่า 1 GHz และหน่วยความจำหลักหลาย GBytes (เช่นคำสั่งขนาดใหญ่หลายอันทรงพลัง แม้ว่าจะคำนึงถึงความเร็ว I / O แล้วก็ตาม ย้อนกลับไปในปี 1990 เมื่อ Oberon ทำงานบนโปรเซสเซอร์ 25MHz NS32X32 พร้อมหน่วยความจำหลัก 2-4 เมกะไบต์คอมไพเลอร์รวบรวมตัวเองในเวลาเพียงไม่กี่วินาที แนวคิดของการรอคอยจริงสำหรับคอมไพเลอร์ที่จะเสร็จสิ้นรอบการรวบรวมนั้นโปรแกรมเมอร์ของ Oberon ไม่รู้จักเลยแม้แต่ตอนนั้น สำหรับโปรแกรมทั่วไปก็มักจะใช้เวลามากขึ้นในการลบนิ้วออกจากปุ่มเมาส์ที่เรียกใช้คำสั่งการคอมไพล์กว่ารอให้คอมไพเลอร์ทำการคอมไพล์ให้เสร็จสมบูรณ์ มันเป็นเรื่องน่ายินดีอย่างแท้จริงด้วยเวลารอเกือบเป็นศูนย์ และคุณภาพของรหัสที่ผลิตแม้ว่าจะไม่เสมอไปอย่างสมบูรณ์กับคอมไพเลอร์ที่ดีที่สุดที่มีอยู่ในตอนนั้นก็ดีมากสำหรับงานส่วนใหญ่และเป็นที่ยอมรับโดยทั่วไป

ไปถูกออกแบบมาให้รวดเร็วและมันแสดงให้เห็น

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

โปรดทราบว่า GO ไม่ใช่ภาษาเดียวที่มีคุณสมบัติดังกล่าว (โมดูลเป็นบรรทัดฐานในภาษาสมัยใหม่) แต่ทำได้ดี

ข้อความจากหนังสือ " The Go Programming Language " โดย Alan Donovan และ Brian Kernighan:

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

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

อย่างไรก็ตามมันไม่ได้ยากที่จะชะลอตัวแปล

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

ในแง่ของการปรับรหัสที่สร้างให้เหมาะสมไม่มีการ จำกัด จำนวนการประมวลผลที่สามารถเพิ่มลงในเฟสนั้นได้

เพียงแค่ (ในคำพูดของฉันเอง) เพราะไวยากรณ์เป็นเรื่องง่ายมาก (ในการวิเคราะห์และแยกวิเคราะห์)

ตัวอย่างเช่นไม่มีการสืบทอดประเภทหมายความว่าไม่ใช่การวิเคราะห์ที่มีปัญหาเพื่อดูว่าประเภทใหม่เป็นไปตามกฎที่กำหนดโดยประเภทฐานหรือไม่

ตัวอย่างเช่นในตัวอย่างรหัสนี้: "interfaces"คอมไพเลอร์จะไม่ไปและตรวจสอบว่าประเภทที่ต้องการใช้อินเตอร์เฟสที่กำหนดในขณะที่วิเคราะห์ประเภทนั้นหรือไม่ จนกว่าจะมีการใช้ (และหากมีการใช้) จะมีการตรวจสอบ

ตัวอย่างอื่น ๆ คอมไพเลอร์จะบอกคุณว่าคุณกำลังประกาศตัวแปรและไม่ได้ใช้มันหรือไม่ (หรือถ้าคุณควรจะเก็บค่าตอบแทนไว้และคุณไม่ได้ใช้)

ต่อไปนี้ไม่ได้รวบรวม:

package main
func main() {
    var a int 
    a = 0
}
notused.go:3: a declared and not used

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

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

อีกครั้งในคำพูดของฉัน

ฉันคิดว่าโกได้รับการออกแบบควบคู่ไปกับการสร้างคอมไพเลอร์ดังนั้นพวกเขาจึงเป็นเพื่อนที่ดีที่สุดตั้งแต่แรกเกิด (IMO)

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

มีอะไรอีกบ้าง?