ทำไม x86 ถึงน่าเกลียด? ทำไมถึงถูกมองว่าด้อยกว่าเมื่อเทียบกับคนอื่น? [ปิด]

เมื่อเร็ว ๆ นี้ฉันได้อ่านไฟล์เก็บถาวร SO และพบข้อความที่ต่อต้านสถาปัตยกรรม x86

• เหตุใดเราจึงต้องการสถาปัตยกรรม CPU ที่แตกต่างกันสำหรับเซิร์ฟเวอร์และมินิ / เมนเฟรมและคอร์ผสม กล่าวว่า
  " สถาปัตยกรรมพีซีเป็นเรื่องยุ่งนักพัฒนาระบบปฏิบัติการทุกคนจะบอกคุณว่า "

• การเรียนภาษา Assembly คุ้มค่ากับความพยายามหรือไม่? (เก็บถาวร ) ระบุว่า
  "ตระหนักว่าสถาปัตยกรรม x86 นั้นน่ากลัวที่สุด "

• วิธีง่ายๆในการเรียนรู้ x86 แอสเซมเบลอร์หรือไม่? กล่าวว่า
  " วิทยาลัยส่วนใหญ่สอนเรื่องการชุมนุมเช่น MIPS เพราะเข้าใจง่ายกว่ามากการประกอบ x86 น่าเกลียดมาก "

และความคิดเห็นอื่น ๆ อีกมากมายเช่น

• "เมื่อเทียบกับสถาปัตยกรรมส่วนใหญ่ X86 ค่อนข้างแย่"

• " เป็นภูมิปัญญาดั้งเดิมที่ X86 ด้อยกว่า MIPS, SPARC และ PowerPC "

• " x86 น่าเกลียด "

ฉันพยายามค้นหา แต่ไม่พบเหตุผลใด ๆ ฉันไม่พบว่า x86 แย่เพราะนี่เป็นสถาปัตยกรรมเดียวที่ฉันคุ้นเคย

ใครช่วยกรุณาให้เหตุผลในการพิจารณา x86 น่าเกลียด / แย่ / ด้อยกว่าเมื่อเทียบกับคนอื่น ๆ

สาเหตุที่เป็นไปได้สองประการ:

1. x86 เป็นISA ที่ค่อนข้างเก่า(บรรพบุรุษของมันคือ 8086s หลังจากนั้นทั้งหมด)
2. x86 มีการพัฒนาอย่างมีนัยสำคัญหลายครั้ง แต่ฮาร์ดแวร์จำเป็นเพื่อรักษาความเข้ากันได้แบบย้อนหลังกับไบนารีรุ่นเก่า ตัวอย่างเช่นฮาร์ดแวร์ x86 ที่ทันสมัยยังคงรองรับการเรียกใช้โค้ด 16 บิต นอกจากนี้ยังมีโมเดลการกำหนดแอดเดรสหน่วยความจำหลายรุ่นเพื่อให้โค้ดรุ่นเก่าทำงานระหว่างกันบนโปรเซสเซอร์เดียวกันเช่นโหมดจริงโหมดป้องกันโหมด 8086 เสมือนและโหมดยาว (amd64) สิ่งนี้อาจสร้างความสับสนให้กับบางคน
3. x86 เป็นเครื่อง CISC เป็นเวลานานซึ่งหมายความว่ามันช้ากว่าเครื่อง RISC เช่น MIPS หรือ ARM เนื่องจากคำสั่งมีการพึ่งพาซึ่งกันและกันของข้อมูลและแฟล็กทำให้รูปแบบของการเรียนการสอนส่วนใหญ่ขนานกันยากที่จะนำไปใช้ การใช้งานสมัยใหม่จะแปลคำสั่ง x86 เป็นคำสั่งคล้าย RISC ที่เรียกว่า " micro-ops " ภายใต้ฝาครอบเพื่อให้การเพิ่มประสิทธิภาพประเภทนี้ใช้งานได้จริงในฮาร์ดแวร์
4. ในบางประเด็น x86 ก็ไม่ได้ด้อยไปกว่ากัน แต่แตกต่างกัน ตัวอย่างเช่นอินพุต / เอาต์พุตได้รับการจัดการเป็นการแมปหน่วยความจำบนสถาปัตยกรรมส่วนใหญ่ แต่ไม่ใช่บน x86 (หมายเหตุ: โดยทั่วไปแล้วเครื่อง x86 ที่ทันสมัยจะมีการรองรับDMAบางรูปแบบและสื่อสารกับฮาร์ดแวร์อื่น ๆ ผ่านการแมปหน่วยความจำ แต่ISAยังคงมีคำแนะนำ I / O เช่นINและOUT)
5. x86 ISAมีการลงทะเบียนสถาปัตยกรรมเพียงไม่กี่ตัวซึ่งสามารถบังคับให้โปรแกรมไป - กลับผ่านหน่วยความจำได้บ่อยกว่าที่จำเป็น คำแนะนำพิเศษที่จำเป็นในการทำเช่นนี้จะใช้เวลาดำเนินการทรัพยากรที่สามารถนำมาใช้ในการทำงานที่เป็นประโยชน์แม้จะมีประสิทธิภาพการจัดเก็บส่งต่อช่วยให้เวลาในการตอบสนองต่ำ การใช้งานสมัยใหม่ด้วยการเปลี่ยนชื่อรีจิสเตอร์ลงในไฟล์รีจิสเตอร์ทางกายภาพขนาดใหญ่สามารถให้คำแนะนำมากมายในการบิน แต่การขาดการลงทะเบียนสถาปัตยกรรมยังคงเป็นจุดอ่อนที่สำคัญสำหรับ x86 32 บิต การเพิ่มขึ้นของ x86-64 จาก 8 เป็น 16 จำนวนเต็มและการลงทะเบียนเวกเตอร์เป็นหนึ่งในปัจจัยที่ใหญ่ที่สุดในรหัส 64 บิตที่เร็วกว่า 32 บิต (พร้อมกับการลงทะเบียนเรียก ABI ที่มีประสิทธิภาพมากกว่า) ไม่ใช่ความกว้างที่เพิ่มขึ้นของการลงทะเบียนแต่ละรายการ การเพิ่มจำนวนเต็มจาก 16 เป็น 32 จะช่วยได้บ้าง แต่ไม่มากเท่า (AVX512 เพิ่มขึ้นเป็น 32 เวกเตอร์รีจิสเตอร์เนื่องจากโค้ดทศนิยมมีเวลาแฝงที่สูงกว่าและมักต้องการค่าคงที่มากกว่า) ( ดูความคิดเห็น )

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

   if (DF==0) 
     *(byte*)DI++ = *(byte*)SI++; 
   else 
     *(byte*)DI-- = *(byte*)SI--;
   

   นั่นเป็นคำสั่งเดียวในการโหลดการจัดเก็บและการเพิ่มหรือลบสองรายการ (ควบคุมโดยการป้อนค่าสถานะ) ซึ่งแต่ละคำสั่งจะเป็นคำแนะนำแยกกันในเครื่อง RISC

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

7. x86 ใช้ opcodes ที่มีความยาวผันแปรได้ซึ่งจะเพิ่มความซับซ้อนของฮาร์ดแวร์ที่เกี่ยวกับการแยกวิเคราะห์คำสั่ง ในยุคปัจจุบันค่าใช้จ่ายนี้มีขนาดเล็กลงเรื่อย ๆ เนื่องจากซีพียูถูก จำกัด ด้วยแบนด์วิดท์หน่วยความจำมากขึ้นเรื่อย ๆ มากกว่าการคำนวณแบบดิบ แต่บทความและทัศนคติ "x86 ทุบตี" จำนวนมากมาจากยุคที่ค่าใช้จ่ายนี้มีขนาดใหญ่กว่ามาก
   ปรับปรุง 2016 Anandtech ได้โพสต์การอภิปรายเกี่ยวกับขนาด opcode ภายใต้ x64 และ AArch64

แก้ไข: นี่ไม่ควรจะเป็นการทุบตี x86! ปาร์ตี้. ฉันมีทางเลือกเพียงเล็กน้อย แต่ต้องทุบตีตามวิธีที่คำถามนั้นพูด แต่ยกเว้นข้อ (1) สิ่งเหล่านี้ทำด้วยเหตุผลที่ดี (ดูความคิดเห็น) นักออกแบบของ Intel ไม่ได้โง่ - พวกเขาต้องการบรรลุบางสิ่งด้วยสถาปัตยกรรมของพวกเขาและนี่คือภาษีบางส่วนที่พวกเขาต้องจ่ายเพื่อทำให้สิ่งเหล่านั้นเป็นจริง

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

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

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

ชิป DEC Alpha AXP ซึ่งเป็นการออกแบบ RISC สไตล์ MIPS นั้นมีความเจ็บปวดอย่างมากในคำแนะนำที่มีอยู่ แต่ชุดคำสั่งได้รับการออกแบบมาเพื่อหลีกเลี่ยงการพึ่งพาการลงทะเบียนโดยนัยระหว่างคำสั่ง ไม่มีการลงทะเบียนสแต็กที่กำหนดด้วยฮาร์ดแวร์ ไม่มีการลงทะเบียนแฟล็กที่กำหนดโดยฮาร์ดแวร์ แม้แต่ตัวชี้คำสั่งยังถูกกำหนดระบบปฏิบัติการ - หากคุณต้องการกลับไปที่ผู้โทรคุณต้องพิจารณาว่าผู้โทรจะแจ้งให้คุณทราบว่าที่อยู่ที่จะกลับไปอย่างไร โดยปกติจะกำหนดโดยรูปแบบการเรียกระบบปฏิบัติการ แม้ว่าบน x86 จะถูกกำหนดโดยฮาร์ดแวร์ชิป

อย่างไรก็ตามกว่า 3 หรือ 4 รุ่นของการออกแบบชิป Alpha AXP ฮาร์ดแวร์ได้เปลี่ยนไปจากการใช้งานชุดคำสั่ง spartan ที่มีการลงทะเบียน 32 int และการลงทะเบียน 32 float ไปยังกลไกการดำเนินการตามคำสั่งที่มีการลงทะเบียนภายใน 80 รายการการลงทะเบียนการเปลี่ยนชื่อ การส่งต่อผลลัพธ์ (โดยที่ผลลัพธ์ของคำสั่งก่อนหน้าจะถูกส่งต่อไปยังคำสั่งในภายหลังซึ่งขึ้นอยู่กับค่า) และตัวเร่งประสิทธิภาพที่บ้าคลั่งและบ้าคลั่งทุกประเภท และด้วยเสียงระฆังและเสียงนกหวีดเหล่านั้นการตายของชิป AXP ยังคงมีขนาดเล็กกว่าการตายของชิป Pentium ที่เทียบเคียงกันได้มากในเวลานั้นและ AXP นั้นเร็วกว่ามาก

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

ฉันได้เขียนแอสเซมเบลอร์ x86 จำนวนมากและสามารถชื่นชมความสะดวกสบายของราก CISC ได้อย่างเต็มที่ แต่ฉันไม่เข้าใจว่า x86 ซับซ้อนแค่ไหนจนกระทั่งฉันใช้เวลาเขียน Alpha AXP แอสเซมเบลอร์ ฉันรู้สึกแย่กับความเรียบง่ายและความสม่ำเสมอของ AXP ความแตกต่างมีมากมายและลึกซึ้ง

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

โปรเซสเซอร์อื่น ๆ จากยุคเดียวกัน (เช่นตระกูล 6502) ก็มีข้อ จำกัด และนิสัยใจคอที่คล้ายคลึงกัน ที่น่าสนใจคือทั้ง 8008 ซีรีส์และซีรีส์ 6502 มีจุดมุ่งหมายเพื่อเป็นคอนโทรลเลอร์แบบฝังตัว ในตอนนั้นตัวควบคุมแบบฝังถูกคาดว่าจะได้รับการตั้งโปรแกรมไว้ในแอสเซมเบลอร์และในหลาย ๆ วิธีที่รองรับโปรแกรมเมอร์แอสเซมบลีแทนที่จะเป็นตัวเขียนคอมไพเลอร์ (ดูที่ชิป VAX สำหรับสิ่งที่เกิดขึ้นเมื่อคุณให้ความสำคัญกับการเขียนคอมไพเลอร์) นักออกแบบไม่ได้คาดหวังว่าพวกเขาจะกลายเป็นแพลตฟอร์มคอมพิวเตอร์สำหรับวัตถุประสงค์ทั่วไป นั่นคือสิ่งที่เหมือนกับรุ่นก่อน ๆ ของ POWER archicture มีไว้เพื่อ การปฏิวัติคอมพิวเตอร์ที่บ้านเปลี่ยนไปแน่นอน

ฉันมีประเด็นเพิ่มเติมบางประการที่นี่:

พิจารณาการดำเนินการ "a = b / c" x86 จะใช้สิ่งนี้เป็น

  mov eax,b
  xor edx,edx
  div dword ptr c
  mov a,eax

เนื่องจากโบนัสเพิ่มเติมของคำสั่ง div edx จะมีส่วนที่เหลืออยู่

ตัวประมวลผล RISC จะต้องโหลดที่อยู่ของ b และ c ก่อนโดยโหลด b และ c จากหน่วยความจำไปยังรีจิสเตอร์ทำการแบ่งและโหลดที่อยู่ของ a แล้วจึงจัดเก็บผลลัพธ์ ไวยากรณ์ Dst, src:

  mov r5,addr b
  mov r5,[r5]
  mov r6,addr c
  mov r6,[r6]
  div r7,r5,r6
  mov r5,addr a
  mov [r5],r7

ที่นี่มักจะไม่มีเศษเหลือ

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

ข้อดีและข้อเสีย:

คำสั่ง RISC อาจผสมกับโค้ดโดยรอบเพื่อปรับปรุงการตั้งเวลาคำสั่งซึ่งมีความเป็นไปได้น้อยกว่ากับ x86 ซึ่งจะใช้งานได้ดี (มากหรือน้อยขึ้นอยู่กับลำดับ) ภายใน CPU เอง โดยทั่วไปลำดับ RISC ด้านบนจะมีความยาว 28 ไบต์ (7 คำสั่งของความกว้าง 32 บิต / 4 ไบต์แต่ละคำสั่ง) บนสถาปัตยกรรม 32 บิต สิ่งนี้จะทำให้หน่วยความจำนอกชิปทำงานมากขึ้นเมื่อดึงคำแนะนำ (การดึงข้อมูลเจ็ดครั้ง) ลำดับ x86 ที่หนาแน่นขึ้นมีคำแนะนำน้อยลงและแม้ว่าความกว้างจะแตกต่างกันไปคุณอาจกำลังดูค่าเฉลี่ย 4 ไบต์ / คำสั่งที่นั่นด้วย แม้ว่าคุณจะมีแคชคำสั่งเพื่อเร่งความเร็วในการดึงข้อมูลเจ็ดครั้งหมายความว่าคุณจะมีการขาดดุลสามส่วนที่เหลือเพื่อชดเชยเมื่อเทียบกับ x86

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

ในบันทึกส่วนตัวฉันพบว่ายากที่จะเขียน RISC assembly มากกว่า x86 ฉันแก้ปัญหานี้โดยการเขียนรูทีน RISC ใน C รวบรวมและแก้ไขโค้ดที่สร้างขึ้น สิ่งนี้มีประสิทธิภาพมากกว่าจากมุมมองการผลิตโค้ดและอาจมีประสิทธิภาพน้อยกว่าจากมุมมองการดำเนินการ การลงทะเบียนทั้งหมด 32 รายการเพื่อติดตาม ด้วย x86 เป็นวิธีอื่น ๆ : การลงทะเบียน 6-8 รายการที่มีชื่อ "จริง" ทำให้ปัญหาสามารถจัดการได้มากขึ้นและสร้างความมั่นใจมากขึ้นว่าโค้ดที่สร้างจะทำงานได้ตามที่คาดไว้

น่าเกลียด? นั่นอยู่ในสายตาของคนดู ฉันชอบ "แตกต่าง"

ฉันคิดว่าคำถามนี้มีข้อสันนิษฐานที่ผิด ส่วนใหญ่เป็นเพียงนักวิชาการที่หมกมุ่นอยู่กับ RISC ที่เรียก x86 ว่าน่าเกลียด ในความเป็นจริง x86 ISA สามารถทำได้ในการดำเนินการคำสั่งเดียวซึ่งจะใช้คำสั่ง 5-6 คำสั่งเกี่ยวกับ RISC ISAs แฟน ๆ ของ RISC อาจตอบโต้ว่าซีพียู x86 ที่ทันสมัยทำลายคำสั่งที่ "ซับซ้อน" เหล่านี้ลงใน microops; อย่างไรก็ตาม:

1. ในหลาย ๆ กรณีนั่นเป็นความจริงเพียงบางส่วนหรือไม่จริงเลย คำแนะนำที่ "ซับซ้อน" ที่มีประโยชน์ที่สุดใน x86 คือสิ่งต่างๆเช่นmov %eax, 0x1c(%esp,%edi,4)โหมดการกำหนดแอดเดรสซึ่งจะไม่แยกย่อย
2. สิ่งที่สำคัญกว่าในเครื่องสมัยใหม่มักไม่ใช่จำนวนรอบที่ใช้ไป (เนื่องจากงานส่วนใหญ่ไม่ได้ผูกกับ cpu) แต่แคชคำสั่งมีผลต่อโค้ด คำสั่งขนาดคงที่ 5-6 คำสั่ง (โดยปกติคือ 32 บิต) จะส่งผลกระทบต่อแคชมากกว่าหนึ่งคำสั่งที่ซับซ้อนซึ่งแทบจะไม่เกิน 5 ไบต์

x86 จริงๆดูดซึมทุกด้านที่ดีของริสก์ประมาณ 10-15 ปีที่ผ่านมาและมีคุณภาพที่เหลืออยู่ของ RISC (จริงกำหนดหนึ่ง - น้อยที่สุดชุดคำสั่ง) เป็นอันตรายและไม่พึงประสงค์

นอกเหนือจากค่าใช้จ่ายและความซับซ้อนของการผลิตซีพียูและความต้องการพลังงานของพวกเขา x86 เป็นของ ISA ใครก็ตามที่บอกคุณเป็นอย่างอื่นก็ปล่อยให้อุดมการณ์หรือวาระการประชุมมาขัดขวางการใช้เหตุผลของพวกเขา

ในทางกลับกันหากคุณกำหนดเป้าหมายอุปกรณ์ฝังตัวที่ต้นทุนของ CPU นับหรืออุปกรณ์ฝังตัว / มือถือที่การใช้พลังงานเป็นปัญหาอันดับต้น ๆ ARM หรือ MIPS อาจเหมาะสมกว่า โปรดทราบว่าคุณยังคงต้องจัดการกับหน่วยความจำเพิ่มเติมและขนาดไบนารีที่จำเป็นในการจัดการโค้ดที่มีขนาดใหญ่กว่า 3-4 เท่าและคุณจะไม่สามารถเข้าใกล้ประสิทธิภาพได้ เรื่องนี้ขึ้นอยู่กับสิ่งที่คุณกำลังดำเนินการอยู่มากหรือไม่

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

ตัวอย่างเช่นในโหมด 16 บิตการกำหนดแอดเดรสอาจดูแปลกประหลาดมาก มีโหมดที่อยู่สำหรับแต่ไม่หนึ่งสำหรับ[BX+SI] [AX+BX]สิ่งต่างๆเช่นนี้มักจะทำให้การใช้งาน register มีความซับซ้อนเนื่องจากคุณต้องตรวจสอบให้แน่ใจว่าค่าของคุณอยู่ในทะเบียนที่คุณสามารถใช้ได้ตามต้องการ

(โชคดีที่โหมด 32 บิตนั้นปลอดภัยกว่ามาก (แม้ว่าจะยังแปลกอยู่บ้างในบางครั้งเช่นการแบ่งส่วน) และรหัส x86 16 บิตนั้นส่วนใหญ่ไม่เกี่ยวข้องอีกต่อไปนอกตัวโหลดบูตและสภาพแวดล้อมแบบฝังบางส่วน)

นอกจากนี้ยังมีของเหลือจากสมัยก่อนเมื่อ Intel พยายามทำให้ x86 เป็นสุดยอดโปรเซสเซอร์ คำแนะนำสองสามไบต์ที่มีความยาวซึ่งดำเนินงานที่ไม่มีใครทำอีกต่อไปแล้วทำให้พวกเขารู้สึกประหลาดใจช้าหรือซับซ้อนเกินไป คำแนะนำ ENTER และLOOPสำหรับสองตัวอย่างโปรดทราบว่ารหัสเฟรมสแต็กของ C จะเหมือนกับ "push ebp; mov ebp, esp" และไม่ใช่ "enter" สำหรับคอมไพเลอร์ส่วนใหญ่

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

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

ฉันเคยได้ยินจาก nVidia ว่าข้อผิดพลาดประการหนึ่งของ Intel คือพวกเขาเก็บรูปแบบไบนารีไว้ใกล้กับฮาร์ดแวร์ PTX ของ CUDA ทำการลงทะเบียนอย่างรวดเร็วโดยใช้การคำนวณ (การระบายสีกราฟ) ดังนั้น nVidia จึงสามารถใช้เครื่องลงทะเบียนแทนเครื่องสแต็กได้ แต่ยังคงมีเส้นทางการอัปเกรดที่ไม่ทำลายซอฟต์แวร์เก่าทั้งหมด

นอกจากเหตุผลที่ผู้คนกล่าวถึงแล้ว:

• x86-16 มีรูปแบบการกำหนดหน่วยความจำที่ค่อนข้างแปลกซึ่งทำให้สามารถระบุตำแหน่งหน่วยความจำเดียวได้ถึง 4096 วิธีที่แตกต่างกัน RAM จำกัด ไว้ที่ 1 MB และบังคับให้โปรแกรมเมอร์จัดการกับตัวชี้สองขนาดที่แตกต่างกัน โชคดีที่การย้ายไปเป็น 32 บิตทำให้คุณสมบัตินี้ไม่จำเป็น แต่ชิป x86 ยังคงมีส่วนสำคัญในการลงทะเบียนส่วน
• ในขณะที่ไม่ได้เป็นความผิดของ x86 ต่อ se , x86 ประชุมเรียกร้องไม่ได้มาตรฐานเช่น MIPS เป็น (ส่วนใหญ่เป็นเพราะ MS-DOS ไม่ได้มาพร้อมกับคอมไพเลอร์มี) ออกจากเรากับระเบียบของ__cdecl, __stdcall, __fastcallฯลฯ

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

แม้ว่าฉันจะเข้าใจว่า "x86 น่าเกลียด!" ข้อโต้แย้งฉันยังคิดว่ามันสนุกกว่าการเขียนแอสเซมบลี x86 มากกว่า MIPS (เช่น) - อันหลังนั้นน่าเบื่อ การคอมไพเลอร์ควรเป็นเรื่องดีเสมอไปมากกว่าที่จะเป็นมนุษย์ ฉันไม่แน่ใจว่าชิปอาจเป็นศัตรูกับนักเขียนคอมไพเลอร์ได้มากกว่านี้ถ้ามันพยายาม ...

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

1. x86 มีชุดการลงทะเบียนสำหรับวัตถุประสงค์ทั่วไปที่ จำกัด มาก

2. มันส่งเสริมรูปแบบการพัฒนาที่ไม่มีประสิทธิภาพมากในระดับต่ำสุด (นรก CISC) แทนที่จะเป็นวิธีการโหลด / จัดเก็บที่มีประสิทธิภาพ

3. Intel ได้ทำการตัดสินใจที่น่าสยดสยองในการนำเสนอเซ็กเมนต์ / ออฟเซ็ตที่ดูโง่เขลาอย่างชัดเจน - โมเดลการยึดหน่วยความจำเพื่อให้เข้ากันได้กับเทคโนโลยีที่ล้าสมัย (ในเวลานี้แล้ว!)

4. ในช่วงเวลาที่ทุกคนใช้ 32 บิต x86 ได้รั้งโลกพีซีกระแสหลักไว้ด้วยการเป็นเพียง 16 บิต (ส่วนใหญ่ - 8088 - แม้จะมีเส้นทางข้อมูลภายนอก 8 บิตเท่านั้นซึ่งก็น่ากลัวกว่า!)

สำหรับฉัน (และฉันเป็นทหารผ่านศึก DOS ที่ได้เห็นพีซีทุกรุ่นจากมุมมองของนักพัฒนา!) จุดที่ 3 นั้นแย่ที่สุด

ลองนึกภาพสถานการณ์ต่อไปนี้ในช่วงต้นทศวรรษที่ 90 (กระแสหลัก!):

a) ระบบปฏิบัติการที่มีข้อ จำกัด ที่บ้าคลั่งเนื่องจากเหตุผลเดิม (640kB ของ RAM ที่เข้าถึงได้ง่าย) - DOS

b) ส่วนขยายระบบปฏิบัติการ (Windows) ที่สามารถทำได้มากกว่าในแง่ของ RAM แต่มีข้อ จำกัด เมื่อพูดถึงสิ่งต่างๆเช่นเกม ฯลฯ ... และไม่ใช่สิ่งที่เสถียรที่สุดในโลก (โชคดีที่สิ่งนี้เปลี่ยนแปลงในภายหลัง แต่ฉัน ฉันพูดถึงต้นยุค 90 ที่นี่)

c) ซอฟต์แวร์ส่วนใหญ่ยังคงเป็น DOS และเราต้องสร้างดิสก์สำหรับบูตบ่อยๆสำหรับซอฟต์แวร์พิเศษเนื่องจากมี EMM386.exe นี้ที่บางโปรแกรมชอบคนอื่นเกลียด (โดยเฉพาะนักเล่นเกม - และฉันเป็นนักเล่นเกม AVID ในเวลานี้ - รู้ว่าฉันทำอะไร ฉันพูดถึงที่นี่)

d) เราถูก จำกัด ไว้ที่ MCGA 320x200x8 บิต (โอเคมีเทคนิคพิเศษอีกเล็กน้อย 360x480x8 เป็นไปได้ แต่ไม่มีการรองรับไลบรารีรันไทม์เท่านั้น) อย่างอื่นยุ่งและน่ากลัว ("VESA" - lol)

e) แต่ในแง่ของฮาร์ดแวร์เรามีเครื่อง 32 บิตพร้อม RAM และการ์ด VGA ไม่กี่เมกะไบต์พร้อมรองรับสูงสุด 1024x768

เหตุผลสำหรับสถานการณ์เลวร้ายนี้?

การตัดสินใจในการออกแบบที่เรียบง่ายโดย Intel ระดับคำสั่งเครื่องจักร (ไม่ใช่ระดับไบนารี!) เข้ากันได้กับบางสิ่งที่กำลังจะตายฉันคิดว่ามันคือ 8085 ปัญหาอื่น ๆ ที่ดูเหมือนจะไม่เกี่ยวข้องกัน (โหมดกราฟิก ฯลฯ ... สถาปัตยกรรมที่ใส่ใจแพลตฟอร์ม x86 ที่นำมาด้วยตัวเอง

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