ทำไมโปรแกรมไม่ได้เขียนในแอสเซมบลีบ่อยขึ้น [ปิด]

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

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

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

ถ้าการพกพาไม่ใช่ปัญหาจริงๆแล้ว C จะมีอะไรบ้างในแอสเซมเบลอร์ที่ดีเช่น NASM

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

ASM มีความชัดเจนอ่านง่ายและไม่สามารถบำรุงรักษาได้ดีเมื่อเทียบกับภาษาระดับสูงกว่า

นอกจากนี้ยังมีผู้พัฒนา ASM น้อยกว่าภาษาที่เป็นที่นิยมอื่น ๆ เช่น C

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

จะเกิดอะไรขึ้นถ้า CPU ตัวต่อไปมีการลงทะเบียนมากเป็นสองเท่า?

การสนทนาของคำถามนี้จะเป็นอย่างไร : คอมไพเลอร์มีฟังก์ชั่นอะไรบ้าง?

ฉันสงสัยว่าคุณสามารถ / ต้องการ / ควรเพิ่มประสิทธิภาพ ASM ของคุณดีกว่าที่gcc -O3จะทำได้

เฮ้ฉันเป็นคอมไพเลอร์

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

PS โอ้ด้วยวิธีที่คุณไม่ได้ใช้รหัสครึ่งหนึ่งที่คุณเขียน ฉันชอบคุณและโยนมันทิ้งไป

ฉันได้เขียน shedloads ของ assembler สำหรับชิป 6502, Z80, 6809 และ 8086 ฉันหยุดทำทันทีที่คอมไพเลอร์ C พร้อมใช้งานสำหรับแพลตฟอร์มที่ฉันจัดการและทันทีก็มีประสิทธิผลเพิ่มขึ้นอย่างน้อย 10 เท่า โปรแกรมเมอร์ที่ดีส่วนใหญ่ใช้เครื่องมือที่ใช้ด้วยเหตุผลที่มีเหตุผล

ฉันรักการเขียนโปรแกรมในภาษาแอสเซมบลี แต่ใช้รหัสเพิ่มเติมในการทำสิ่งเดียวกันใน languge ระดับสูงและมีความสัมพันธ์โดยตรงระหว่างบรรทัดของรหัสและข้อบกพร่อง (นี่คือคำอธิบายหลายสิบปีที่ผ่านมา The Mythical Man-Month )

เป็นไปได้ที่จะคิดว่า C เป็น 'การชุมนุมระดับสูง' แต่ได้รับขั้นตอนข้างบนนั้นและคุณอยู่ในโลกที่แตกต่าง ใน C # คุณไม่คิดสองครั้งเกี่ยวกับการเขียนนี้:

foreach (string s in listOfStrings) { /* do stuff */ }

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

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

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

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

ความเร็วของโปรแกรม

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

หากโปรแกรมการผลิตโดยเฉลี่ยบอกว่าโค้ดขนาด 100k และแต่ละบรรทัดมีคำสั่งแอสเซมเบลอร์ประมาณ 8-12 นั่นจะเป็นคำสั่งแอสเซมเบลอร์ 1 ล้านคำสั่ง

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

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

ตอนนี้ฉันเขียนสมัชชาจำนวนมาก "ในสมัยก่อน" และฉันรับรองได้ว่าฉันจะมีประสิทธิผลมากขึ้นเมื่อฉันเขียนโปรแกรมด้วยภาษาระดับสูง

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

อย่างไรก็ตามสำหรับการเขียนโค้ดจำนวนมากในแอสเซมเบลอร์มีหลายสาเหตุที่ไม่ได้ทำมากนัก

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

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

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

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

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

ที่ถูกกล่าวว่ารหัสการชุมนุมนี้ถูกห่อจนสามารถเรียกได้จากรหัส C และถือว่าเป็นห้องสมุด เราไม่ได้เขียนโปรแกรมทั้งหมดไว้ในชุดประกอบด้วยเหตุผลหลายประการ ก่อนอื่นคือพกพา; รหัสฐานของเราใช้กับผลิตภัณฑ์หลายอย่างที่ใช้สถาปัตยกรรมที่แตกต่างกันและเราต้องการเพิ่มจำนวนรหัสที่สามารถใช้ร่วมกันได้สูงสุด ประการที่สองคือความคุ้นเคยของนักพัฒนา โรงเรียนไม่ได้สอนการประกอบเหมือนที่เคยเป็นมาและผู้พัฒนาของเรามีประสิทธิผลใน C มากกว่าการประกอบ นอกจากนี้เรายังมี "ความพิเศษ" ที่หลากหลาย (เช่นไลบรารี, เครื่องมือดีบั๊ก, เครื่องมือวิเคราะห์แบบคงที่และอื่น ๆ ) สำหรับรหัส C ของเราที่ไม่สามารถใช้ได้กับรหัสภาษาแอสเซมบลี แม้ว่าเราต้องการที่จะเขียนโปรแกรมการประกอบบริสุทธิ์ เราจะไม่สามารถทำได้เพราะห้องสมุดฮาร์ดแวร์ที่สำคัญหลายแห่งมีให้บริการในรูปแบบ C libs เท่านั้น ในแง่หนึ่งมันเป็นปัญหาไก่ / ไข่ ผู้คนถูกผลักดันให้ห่างจากแอสเซมบลีเนื่องจากมีไลบรารีและเครื่องมือพัฒนา / ดีบักไม่มากพอสำหรับมัน แต่ libs / tools ไม่มีอยู่เพราะมีคนไม่เพียงพอที่จะใช้แอสเซมบลีเพื่อรับประกันความพยายามในการสร้าง

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

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

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

นั่นตอบคำถามของคุณหรือไม่ ;-)

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

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

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

โดยสรุป: คุณอาจไม่ชอบ C แต่ก็ไม่ได้หมายความว่าความพยายามในการใช้ C นั้นยิ่งใหญ่กว่าความพยายามในการหาสิ่งที่ดีกว่า

การประกอบไม่สามารถเคลื่อนย้ายได้ระหว่างไมโครโปรเซสเซอร์ที่แตกต่างกัน

เหตุผลเดียวกันที่เราไม่ไปห้องน้ำข้างนอกอีกต่อไปหรือทำไมเราไม่พูดภาษาละตินหรืออราเมอิก

เทคโนโลยีเข้ามาทำให้สิ่งต่างๆง่ายขึ้นและเข้าถึงได้มากขึ้น

แก้ไข - เพื่อหยุดการโจมตีผู้อื่นฉันได้ลบคำบางคำ

ทำไม? ง่าย

เปรียบเทียบสิ่งนี้:

        for (var i = 1; i <= 100; i++)
        {
            if (i % 3 == 0)
                Console.Write("Fizz");
            if (i % 5 == 0)
                Console.Write("Buzz");
            if (i % 3 != 0 && i % 5 != 0)
                Console.Write(i);
            Console.WriteLine();
        }

กับ

.locals init (
    [0] int32 i)
L_0000: ldc.i4.1 
L_0001: stloc.0 
L_0002: br.s L_003b
L_0004: ldloc.0 
L_0005: ldc.i4.3 
L_0006: rem 
L_0007: brtrue.s L_0013
L_0009: ldstr "Fizz"
L_000e: call void [mscorlib]System.Console::Write(string)
L_0013: ldloc.0 
L_0014: ldc.i4.5 
L_0015: rem 
L_0016: brtrue.s L_0022
L_0018: ldstr "Buzz"
L_001d: call void [mscorlib]System.Console::Write(string)
L_0022: ldloc.0 
L_0023: ldc.i4.3 
L_0024: rem 
L_0025: brfalse.s L_0032
L_0027: ldloc.0 
L_0028: ldc.i4.5 
L_0029: rem 
L_002a: brfalse.s L_0032
L_002c: ldloc.0 
L_002d: call void [mscorlib]System.Console::Write(int32)
L_0032: call void [mscorlib]System.Console::WriteLine()
L_0037: ldloc.0 
L_0038: ldc.i4.1 
L_0039: add 
L_003a: stloc.0 
L_003b: ldloc.0 
L_003c: ldc.i4.s 100
L_003e: ble.s L_0004
L_0040: ret 

มันเป็นคุณสมบัติที่ชาญฉลาดเหมือนกัน อันที่สองไม่ได้เป็นแอสเซมเบลอร์ แต่เป็น NET IL (ภาษาที่เป็นสื่อกลางคล้ายกับ bytecode ของ Java) การคอมไพล์ครั้งที่สองเปลี่ยน IL ให้เป็นโค้ดเนทีฟ (เช่นแอสเซมเบลอร์เกือบ) ทำให้มันเป็นความลับยิ่ง

ฉันเดาว่า ASM บน x86 (_64) นั้นสมเหตุสมผลในกรณีที่คุณได้รับมากโดยใช้คำสั่งที่ยากสำหรับคอมไพเลอร์ในการปรับให้เหมาะสม ตัวอย่างเช่น x264 ใช้ asm จำนวนมากในการเข้ารหัสและความเร็วที่เพิ่มขึ้นมีขนาดใหญ่มาก

ฉันแน่ใจว่ามีหลายเหตุผล แต่เหตุผลสองอย่างที่ฉันคิดได้คือ

1. รหัสแอสเซมบลีอ่านยากขึ้นแน่นอน (ฉันแน่ใจว่าต้องใช้เวลานานในการเขียนเช่นกัน)
2. เมื่อคุณมีทีมนักพัฒนาซอฟต์แวร์จำนวนมากที่ทำงานกับผลิตภัณฑ์จะมีประโยชน์มากที่จะให้โค้ดของคุณแบ่งออกเป็นบล็อกตรรกะและปกป้องโดยส่วนต่อประสาน

หนึ่งในการค้นพบในช่วงต้น (คุณจะพบใน Brooks ' Mythical Man-Monthซึ่งมาจากประสบการณ์ในช่วงปี 1960) คือผู้คนมีความสามารถในการใช้ภาษามากขึ้นหรือน้อยลงในภาษาอื่น ๆ ในรหัสที่ดีบั๊กต่อวัน สิ่งนี้เห็นได้ชัดว่าไม่เป็นความจริงในระดับสากลและสามารถหยุดพักเมื่อถูกผลักไปไกลเกินไป

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

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

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

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

ปัญหาของเราก็แตกต่างกันมาก ในปีพ. ศ. 2529 ฉันพยายามคิดหาวิธีเพิ่มความเร็วของโปรแกรมเล็ก ๆ ที่เกี่ยวข้องกับการวางพิกเซลสองสามร้อยพิกเซลบนหน้าจอ ฉันต้องการให้อนิเมชั่นกระตุกน้อยลง กรณีที่เป็นธรรมสำหรับภาษาแอสเซมบลี ตอนนี้ฉันกำลังพยายามหาวิธีนำเสนอบทคัดย่อเกี่ยวกับภาษาสัญญาและนโยบายผู้ให้บริการสำหรับการจำนองและฉันอยากอ่านสิ่งที่ใกล้เคียงกับภาษาที่คนในธุรกิจพูด ซึ่งแตกต่างจากมาโคร LISP แมโครแอสเซมบลีไม่ได้บังคับใช้ตามกฎมากนักแม้ว่าคุณจะสามารถเข้าใกล้ DSL ในแอสเซมเบลอร์ได้ดีพอสมควร แต่ก็มีแนวโน้มที่จะมีนิสัยแปลก ๆ ที่ชนะ ' ไม่ทำให้ฉันมีปัญหาถ้าฉันเขียนรหัสเดียวกันใน Ruby, Boo, Lisp, C # หรือแม้แต่ F #

หากปัญหาของคุณง่ายต่อการแสดงในภาษาแอสเซมบลีที่มีประสิทธิภาพ แต่พลังมากขึ้นสำหรับคุณ

ส่วนใหญ่ของสิ่งที่คนอื่นพูด

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

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

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

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

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

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

ฉันกำลังเรียนรู้การชุมนุมใน comp org ตอนนี้และในขณะที่มันน่าสนใจก็ยังไม่มีประสิทธิภาพในการเขียนคุณต้องเก็บรายละเอียดมากในหัวของคุณเพื่อให้สิ่งต่าง ๆ ทำงานและมันก็ช้าลงในการเขียนสิ่งเดียวกัน . ตัวอย่างเช่น 6 บรรทัดอย่างง่ายสำหรับลูปใน C ++ สามารถเท่ากับ 18 บรรทัดหรือมากกว่าของแอสเซมบลี

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

สิ่งที่ C มีมากกว่าแอสเซมเบลอร์แมโครที่ดีคือภาษา C การตรวจสอบชนิด โครงสร้างวนรอบ การจัดการสแต็คอัตโนมัติ (เกือบ) การจัดการตัวแปรอัตโนมัติ เทคนิคหน่วยความจำแบบไดนามิกในแอสเซมเบลอร์เป็นความเจ็บปวดครั้งใหญ่ในก้น การทำรายการที่เชื่อมโยงอย่างถูกต้องนั้นน่ากลัวมากเมื่อเทียบกับ C หรือดีกว่า แต่รายการ foo.insert () และการดีบั๊ก - ไม่มีการแข่งขันว่าจะดีบั๊กอย่างไร HLL ชนะมือข้างล่างนั่น

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

ไม่ฉันจะติดกับ C และจัดการกับการชะลอตัวเล็กน้อยเป็นครั้งคราวในการปฏิบัติงานกับเวลาในการผลิตที่ฉันได้รับด้วย HLL

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

ที่กล่าวว่าฉันคิดว่ายังคงมีการใช้งานที่ถูกต้องสำหรับการชุมนุม ตัวอย่างเช่นฉันมีจำนวนชุดคำสั่งแอสเซมบลีที่สวยที่สุดสำหรับการประมวลผลข้อมูลจำนวนมากโดยใช้ SIMD และทำตาม paranoid "ทุกบิตเป็นสิ่งศักดิ์สิทธิ์" วิธีการอ้างอิง [V. V.Stob] (แต่โปรดทราบว่าการใช้งานแอสเซมบลีไร้เดียงสามักจะเลวร้ายยิ่งกว่าสิ่งที่คอมไพเลอร์จะสร้างให้คุณ)

C เป็นแอสเซมเบลอร์แมโคร! และมันก็เป็นหนึ่งที่ดีที่สุด!

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

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

ผู้คนดูเหมือนจะลืมไปแล้วว่ายังมีทิศทางอื่น

ทำไมคุณถึงเขียนใน Assembler ตั้งแต่แรก? ทำไมไม่เขียนโปรแกรมด้วยภาษาระดับต่ำอย่างแท้จริง?

แทน

mov eax, 0x123
add eax, 0x456
push eax
call printInt

คุณสามารถเขียนได้เช่นกัน

B823010000
0556040000
50 
FF15.....

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

และเหตุผลที่คุณยังชอบ Assembler เกี่ยวกับเรื่องนี้คือเหตุผลที่คนอื่นชอบ C ...

เพราะมันเป็นอย่างนั้นเสมอ: เวลาผ่านไปและสิ่งดีๆก็ผ่านไปเช่นกัน :(

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

$$$

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

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

ข้อดีของ HLL นั้นยิ่งใหญ่กว่าเมื่อคุณเปรียบเทียบชุดประกอบกับภาษาระดับสูงกว่า C เช่น Java หรือ Python หรือ Ruby ตัวอย่างเช่นภาษาเหล่านี้มีการรวบรวมขยะ: ไม่จำเป็นต้องกังวลเกี่ยวกับเวลาที่จะเพิ่มหน่วยความจำและเมื่อไม่มีการรั่วไหลหรือข้อบกพร่องเนื่องจากหน่วยความจำเร็วเกินไป

ดังที่คนอื่น ๆ กล่าวถึงก่อนเหตุผลสำหรับเครื่องมือใด ๆ ที่มีอยู่คือประสิทธิภาพในการทำงาน ในฐานะที่เป็น HLL สามารถทำงานเดียวกันกับรหัส asm ได้หลายบรรทัดฉันคิดว่ามันเป็นเรื่องธรรมดาที่แอสเซมบลีจะถูกแทนที่ด้วยภาษาอื่น และสำหรับการเล่นซอใกล้กับฮาร์ดแวร์ - มีการประกอบแบบอินไลน์ใน C และตัวแปรอื่น ๆ ตามภาษา ดร. พอลคาร์เตอร์กล่าวในภาษาแอสเซมบลีพีซี

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

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

การพลิกคำตอบเหล่านี้ฉันจะพนันได้ว่าผู้ตอบคำถาม 9/10 คนไม่เคยทำงานด้วย

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