เขียนโค้ดให้สนุกในยุค 64 บิต

ไปหน้าแรก | สารบัญ | Laploy.comระเบียนบทความ | บทความจากลาภลอย

  • วันจันทร์ที่ 15 ตุลาคม พ.ศ. 2550
  • บทความโดย : ลาภลอย วานิชอังกูร (laploy.com)
  • ลงพิมพ์ใน : นิตยสาร WinMag

เขียนโค้ดให้สนุกในยุค 64 บิต
เชิญท่องแดนหฤหรรษ์แห่งการเขียนโปรแกรมในซีพียูแบบ 64 บิต

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

หากท่านต้องการทราบคำตอบว่า อะไรคือสถาปัตยกรรม x86-64, IA32, IA64, EM64, Intel64 และ AMD64 โมเดลเขียนโปรแกรมของซีพียู 64 บิตจาก AMD และอินเทล เหมือนหรือแตกต่างกันหรือไม่ ซอฟต์แวร์เดิมแบบ 16 และ 32 บิตจะยังทำงานกับซีพียู 64 บิตได้หรือไม่ นักเขียนโปรแกรมต้องปรับตัว หรือเปลี่ยนวิธีเขียนโปรแกรมอย่างไรบ้าง จึงจะสามารถสร้างซอฟต์แวร์แบบ 64 บิตได้ ขอเชิญพบคำตอบเหล่านี้ และหัวข้อที่น่าสนใจอื่นๆ อีกมากได้ในบทความนี้

 

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

ระบบปฏิบัติการสำหรับซีพียู 32 บิตอ้างหน่วยความจำได้สูงสุดเพียง 4 GB และคำนวณเลขทศนิยมได้ไม่เร็วนัก งานที่ต้องใช้หน่วยความจำมากๆ และต้องคำนวณเลขทศนิยมอย่างหนัก เช่น เกมและโปรแกรมสร้างภาพสามมิติจึงทำงานได้อย่างจำกัด ส่วนระบบปฏิบัติการซีพียู 64 บิต อ้างหน่วยความจำได้สูงสุด 16 เทราไบต์ เรียกใช้งานรีจิสเตอร์ 64 บิตและรีจิสเตอร์คำนวณเลขทศนิยม 128 บิตได้เต็มที่ ทำให้เกมและโปรแกรมสร้างภาพสามมิติทำงานเร็วขึ้นมาก

 

ที่มาของตัวเลข 64

หน่วยต่ำสุดของข้อมูลที่คอมพิวเตอร์ประมวลผลได้คือหนึ่งบิต แทนค่าได้สองค่าคือศูนย์และหนึ่ง เหมือนสวิทช์หนึ่งตัวที่อาจอยู่ในตำแหน่งปิดหรือปิด เนื่องจากบิตเดียวไม่สามารถแทนข้อมูลอะไรได้มากนัก การประมวลผลจึงใช้หน่วยไบต์ หรือแปดบิต สาเหตุที่เป็นแปดบิต (แทนที่จะเป็นเจ็ดหรือเก้าบิต) เพราะในระบบเลขฐานสองการเพิ่มหลักของตัวเลขจะเพิ่มแบบยกกำลังสอง (คือเพิ่มจาก 2 เป็น  4,8,16,32,64,128 ฯลฯ)

การพิจารณาว่าไมโครโปรเซสเซอร์มีขนาดกี่บิต ให้ดูจากขนาดของหน่วยประมวลผลทางตรรกะและคณิตศาสตร์ หรือ ALU (Arithmetic Logic Unit) ไมโครโปรเซสเซอร์ ตัวแรกของบริษัทอินเทล ชื่อ 4004 มี ALU ขนาดสี่บิต ออกจำหน่ายในปี ค.ศ. 1971 แต่ไมโครโปรเซสเซอร์ที่ได้รับความนิยมนำไปใช้ในไมโครคอมพิวเตอร์คือ 8088 ที่ออกจำหน่ายในปี 1979 ไมโครโปรเซสเซอร์ 8088 เป็นซีพียูแบบกึ่งแปดบิตกึ่งสิบหกบิต เพราะ ALU มีขนาด 16 บิต รีจิสเตอร์ภายในก็เป็นสิบหกบิต แต่บัสข้อมูลมีขนาดแปดบิต

ไมโครโปรเซสเซอร์ 8088

 

นิทานอินเทล

บริษัทอินเทลออกจำหน่ายไมโครโปรเซสเซอร์ 8086 ซึ่งเป็นซีพียูขนาด 16 บิตตัวแรกในปี 1978 และตามด้วย 80386 ซึ่งเป็นซีพียูขนาด 32 บิตในปี 1986 ปัจจุบันอินเทล เรียกสถาปัตยกรรมนี้ว่า IA-32  กลายเป็นรากฐานของโมเดลการเขียนโปรแกรมมาตลอดสิบสองปีไม่เปลี่ยนแปลง ซีพียูรุ่นต่อมาไม่ว่าจะเป็น  486, เพนเทียม, เพนเทียมทู, เพนเทียมทรี, Celeron, แพนเทียมโฟร์, Xenon, แพนเทียมเอ็ม ฯลฯ ล้วนใช้โมเดลเดียวกันนี้

จุดเด่นของสถาปัตยกรรม IA-32 คือบัสข้อมูลภายนอกและภายในเป็น 32 บิตล้วน สามารถอ้างหน่วยความจำได้ต่อเนื่องเป็นผืนเดียวกัน (flat memory space) และมีกลไกที่ช่วยให้ใช้ฮาร์ดดิสก์เป็นหน่วยความจำเสมือนได้ง่าย ถึงสามารถรันโปรแกรมและอ้างถึงข้อมูลที่มีขนาดใหญ่กว่าปริมาณของแรมในเครื่องได้ อินเทลมีซีพียูแบบ IA-32 บิตที่ได้รับความนิยมจำนวนมาก เช่น Celeron, Pentium 4, Dual-Core, Core2Duo และ Xenon

    
สถาปัตยกรรมของซีพียู 386DX จะเห็น ALU บัสข้อมูลภายนอกและภายในเป็น 32 บิตล้วน  (กดเพื่อขยาย)

 


สถาปัตยกรรม อิทาเนียม จะเห็นว่าบัสภายในมีขนาด 64, 128 และ 256 บิต

64 บิตสไตล์อินเทล

อินเทลเริ่มพัฒนาซีพียู 64 บิตมาตั้งแต่ปี 1994 โดยทำงานร่วมกับบริษัท ฮิวเลต เพคการ์ด (HP) เพื่อสร้างโปรเซสเซอร์สำหรับเครื่องแม่ข่าย ช่วงแรกเรียกสถาปัตยกรรมนี้ว่า IA-64 แต่ต่อมาเปลี่ยนเป็น อิทาเนียม สถาปัตยกรรมนี้แตกต่างจากสถาปัตยกรรม IA-32 มาก มีนวัตกรรมโดดเด่นหลายอย่าง มีรีจิสเตอร์เลขจำนวนเต็ม 128 ตัว รีจิสเตอร์เลขทศนิยม 128 ตัว และรีจิสเตอร์คำสั่งกระโดด 64 ตัว อ้างตำแหน่งหน่วยความจำแรมได้ 16 เทราไบต์ โปรเซสเซอร์มีหน่วยทำงานภายในภายในสามสิบหน่วย แต่ละหน่วยทำงานเป็นอิสระจากกันและทำงานพร้อมๆ กันได้ แบ่งออกเป็นกลุ่มต่างๆ ดังนี้

* หน่วยประมวลผลทางคณิตศาสตร์และตรรกะ (ALU) หกหน่วย * หน่วยเลขจำนวนเต็มสองหน่วย * หน่วยสำหรับเลื่อนบิตหนึ่งหน่วย * หน่วยแคชข้อมูลสี่หน่วย * หน่วยมัลติมีเดียหกหน่วย * หน่วยเลื่อนบิตแบบขนาดสองหน่วย * หน่วยคูณแบบขนานหนึ่งหน่วย * หน่วยนับหนึ่งหน่วย * หน่วยประมวลผลเลขทศนิยมแบบสะสมสองหน่วย * หน่วยประมวลผลเลขทศนิยมแบบจิปาถะสองหน่วย * หน่วยจัดการคำสั่งกระโดดสามหน่วย

 

อิทาเนียมรุ่นที่ออกขายก่อนปี 2006 มีฮาร์ดแวร์ที่สนับสนุนสถาปัตยกรรม IA-32 เพื่อให้ใช้งานได้กับแม่ข่ายรุ่นเก่า ในชิพรุ่นหลังปี 2006 เช่น อิทาเนียม II : Montecito อินเทลได้เพิ่มคุณสมบัติใหม่บางอย่างเช่น สนับสนุนการทำงานแบบหลายเทรธ แบบใหม่ที่มีประสิทธิภาพมากขึ้น และคุณสมบัติที่ทำให้วิ่งซอฟต์แวร์ระบบปฏิบัติการมากกว่าหนึ่งระบบได้พร้อมกันได้ ปัจจุบันมีระบบปฏิบัติการที่ใช้กับอิทาเนียมได้หลายตัว เช่น Windows Server 2003, Windows Vista, Linux, HP-UX, และ OpenVMS

แม้จะเริ่มออกจำหน่ายตั้งแต่ปี 2001 แต่ซีพียูอิทาเนียมไม่เคยได้รับความนิยมในโลกของเดสก์ทอปเลย ส่วนมากจะถูกบริษัทผู้ผลิตคอมพิวเตอร์นำไปใช้สร้างเครื่องแม่ข่ายระดับสูง (high-end server) ปัจจุบันอินเทลเปลี่ยนชื่อ อิทาเนียมทู โดยตัดคำว่า ทู ออก อิทาเนียมถูกผลิตออกมาแล้วหลายรุ่นดังนี้

•    อิทาเนียม : Merced ออกจำหน่ายปี 2001
•    อิทาเนียม ทู : McKinley ออกจำหน่ายปี 2004
•    อิทาเนียม ทู : Madison 9M ออกจำหน่ายปี 2005
•    อิทาเนียม ทู : Montecito เป็นอิทาเนียม ที่มีจำหน่ายในปัจจุบัน

อิทาเนียมทู McKinley

 

เทพนิยาย  AMD

ยุคก่อนเครื่องเลียนแบบไอบีเอ็มพีซี (IBM PC Compatible หรือเครื่องโคลน) ลูกค้ารายใหญ่ที่ซื้อชิพ 8086 ของอินเทลมีไอบีเอ็มเจ้าเดียว ในปี 1982 ไอบีเอ็มออกนโยบายจัดซื้อให้ซื้อจากผู้ผลิตอย่างน้อยสองราย บีบให้อินเทล ต้องจับมือกับบริษัท AMD ( AMD  Advance Micro Device) และเปิดเผยเทคโนโลยีการผลิตชิพแก่ AMD 

เมื่อเครื่องโคลนครองตลาดคอมพิวเตอร์ส่วนบุคคลในปี 1986 ไอบีเอ็มไม่ใช่ลูกค้าสำคัญอีกต่อไป บริษัทอินเทลจึงยกเลิกสัญญาเปิดเผยเทคโนโลยีผลิตชิพ แต่ AMD ก็สามารถผลิตชิพรุ่นต่อมาที่เข้ากันได้กับชิพของอินเทล ช่วงแรก AMD ตั้งชื่อชิพโดยใช้เลขอนุกรมตรงกับอินเทล (คือ 8088, 8086, 80286 และ 80386) ในปี 1993 อินเทลเปลี่ยนวิธีตั้งชื่อซีพียูจากตัวเลขไปเป็นตัวอักษร (คือ 80586 เป็นอินเทลเพนเทียม)  AMD ไม่สามารถใช้ชื่อนี้ได้จึงเปลี่ยนไปใช้ชื่อที่นำหน้าด้วยตัว K โดยกลุ่ม K6 เทียบได้กับเพนเทียม ถึงเพนเทียมทรี และ K7 เทียบได้กับ เพนเทียม 4

    
    AMD K6-III

 

64 บิต ของดีของ  AMD

ชิพไมโครโปรเซสเซอร์หลักของบริษัท AMD ในปัจจุบันคือสถาปัตยกรรม K8 (หรือ ADM64) เป็นซีพียูแบบ 64 บิต มีผลิตออกจำหน่ายหลายตระกูลดังนี้

•    Athlon 64 : เป็น K8 แบบคอร์เดียว มีทั้งแบบเดกส์ท็อปและโน้ตบุ๊ก  เป็นซีพียูหลักของ AMD
•    Athlon 64×2 : เป็น K8 แบบสองคอร์
•    Opteron :  เป็น K8 รุ่นที่ออกมาก่อนเพื่อน เพื่อให้นำไปสร้างคอมพิวเตอร์แม่ข่าย
•    Sempron 64 : เป็น K8 รุ่นราคาสบายกระเป๋า มีทั้งแบบเดกส์ท็อปและโน้ตบุ๊ก มาแทนที่ซีพียู Duron เพื่อต่อกรกับ Celeron D 64 ของอินเทล
•    Turion 64 : เป็น K8 รุ่นกินพลังงานน้อย เหมาะใช้ทำโน้ตบุ๊ก

นอกจาก K8 แล้ว AMD ยังซุ่มพัฒนาสถาปัตยกรรม K9 มาตั้งแต่ปี 2001 โดยตั้งใจจะให้เป็นสถาปัตยกรรมซึ่งจะมาแทนที่ K8 แต่โครงการนี้ถูกล้มเลิกไปในปี 2006 เพราะ AMD ต้องการผลักดันโครงการที่ใหม่กว่า นั่นคือ K10 (ข้ามจาก K8 ไปเป็น K10 เลย)  AMD แถลงว่าจะนำ Phenom ซีพียู 64 บิตแบบสี่คอร์ (ซึ่งจะเป็นซีพียูที่ใช้สถาปัตยกรรม K10 ตัวแรก) ออกวางตลาดได้ช่วงปลายปีนี้ (พ.ศ. 2550)

 

ไฟล์ภาพ 003.png : สถาปัตยกรรม K8

 

อินเทล 64 ตัวทำเงิน

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

•    Core 2 Duo : ซีพียู 64 บิตสองคอร์สำหรับเดสก์ทอป เป็นซีพียูหลักของอินเทล
•    Celeron D 64 : ซีพียู 64 บิตราคาย่อมเยา มีทั้งแบบเดสก์ทอปและโน้ตบุ๊ก
•    Centrino Duo และ Pro : ซีพียู 64 บิตสองคอร์เพื่อใช้สร้างโน้ตบุ๊ก
•    Core 2 Quad : ซีพียู 64 บิตสี่คอร์สำหรับแม่ข่ายหรือเดสก์ทอปที่ต้องการซีพียูพลังสูงเป็นพิเศษ
•    Xeon : ซีพียู 64 บิตมีทั้งแบบสองและสี่คอร์สำหรับแม่ข่ายระดับสูงสุด

 Xeon แบบสี่คอร์

 

เรื่องไส้ๆ ของ K8

ดูในตารางจะเห็นว่าเมื่อเราเขียนโปรแกรมในโหมดเดิม เราจะมีรีจิสเตอร์อเนกประสงค์ขนาด 32 บิต อยู่แปดตัว แต่ถ้าเขียนในโหมด 64 บิต เราจะมีรีจิสเตอร์ 64 บิตถึง 16 ตัว โปรแกรมเมอร์ภาษาแอสเซมบลีจะสนุกกว่าเพื่อน เพราะชื่อรีจิสเตอร์เปลี่ยนหมด แถมมี R8 ถึง 15 เพิ่มมาให้ใช้อย่างจุใจ ส่วน ST และ MM ไม่มีอะไรเปลี่ยน เพราะเดิมก็เป็น 64 บิตอยู่แล้ว

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


 

 

เทียบเท่าถึงปู่ทวด

ลองมาดูรีจิสเตอร์ A หรือแอคคิวมูเลเตอร์ซึ่งเป็นรีจิสเตอร์หลักของซีพียูกันหน่อย จากรูปจะเห็นว่าหากเขียนโปรแกรมแบบ 64 บิต รีจิสเตอร์นี้จะมีชื่อว่า RAX มีขนาด 64 บิต หากเขียนโปรแกรมแบบ 32 บิต รีจิสเตอร์นี้จะมีชื่อว่า EAX มีขนาด 32 บิต หากเขียนโปรแกรมแบบ 16 บิต รีจิสเตอร์นี้จะมีชื่อว่า AX มีขนาด 16 บิต และหากเขียนโปรแกรมแบบ 8 บิต รีจิสเตอร์นี้จะกลายเป็นรีจิสเตอร์ขนาด 8 บิตสองตัว คือ AH และ AL

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

ขนาดของแอคคิวมูเลเตอร์ในสถาปัตยกรรม K8

 

ตัวอย่างโปรแกรม K8

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

ก่อนการบวก A และ B มีค่าดังนี้ RAX = 0002_0001_8000_2201 RBX = 0002_0002_0123_3301

•    บวกแบบ 64 บิต : ADD RBX,RAX      ผลลัพธ์: RBX = 0004_0003_8123_5502
•    บวกแบบ 32 บิต : ADD EBX,EAX      ผลลัพธ์: RBX = 0000_0000_8123_5502
•    บวกแบบ 16 บิต : ADD BX,AX           ผลลัพธ์: RBX = 0002_0002_0123_5502
•    บวกแบบ 8 บิต :   ADD BL,AL           ผลลัพธ์: RBX = 0002_0002_0123_3302

โปรดสังเกตว่าการบวกแบบ 64 บิตให้ผลลัพธ์ครบสมบูรณ์ ส่วนการบวกแบบ 32 บิตๆ ที่63 ถึง 32 ถูกถมด้วยศูนย์และไม่ถือเป็นส่วนหนึ่งของผลลัพธ์ การบวกแบบ 16 บิตๆ ที่ 63 ถึง 16 ถูกกันไว้และไม่นับว่าเป็นส่วนหนึ่งของผลลัพธ์ และการบวกแบบ 8 บิตๆ ที่ 63 ถึง 8 ถูกกันไว้และไม่นับว่าเป็นส่วนหนึ่งของผลลัพธ์ จะเห็นว่าคำสั่งบวกแบบ 64 บิตไม่แตกต่างจากการเขียนโปรแกรมแบบ 8, 16, หรือ 32 บิต มากนัก

 

 
ซีพียู Opteron แบบสี่คอร์

 

คำสั่งที่เปลี่ยนไปใน AMD64

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

 

  • เพิ่ม REX : REX คือเป็นโค้ดชุดใหม่เอี่ยม ใช้เติมด้านหน้าคำสั่งเดิมเพื่อการระบุรีจิสเตอร์และโอเปอเรนด์ขนาด 64 บิต
  • เปลี่ยนแปลง Segment-Override Prefixes (SOP) : เมื่อเขียนโปรแกรมแบบ 64 บิต SOP  จะไม่มีผลกับ DS, ES, SS และ CS แต่มีผลกับ FS และ GS
  • การบังคับขนาดโอเปอเรนด์ : ขนาดโดยปริยายของโอเปอเรนด์ในการเขียนโปรแกรมแบบ 64 บิต คือ 32 บิต แต่สามารถใช้ REX เปลี่ยนเป็น 64 บิตได้
  • การเติมศูนย์นำหน้าผลลัพธ์ : อย่างที่เห็นในหัวข้อที่แล้ว เมื่อเราดำเนินการแบบ 32 บิต เลขศูนย์จะถูกเติมไว้ด้านหน้าของผลลัพธ์จนครบ 64 บิต
  • การบังคับขนาดตำแหน่งหน่วยความจำ : เมื่อเขียนโปรแกรมแบบ 64 บิตขนาดของตำแหน่งหน่วยความจำจะเป็น 64 บิต แต่เราสามารถใช้โค้ด 67h เพื่อเปลี่ยนเป็น 32 บิตได้
  • ค่าป้อนสด (Displacement และ Immediate) : ยังคงเป็น 32 บิตเท่าเดิม ยกเว้นคำสั่ง MOV ที่มีเพิ่มให้ใส่เป็น 64 บิตได้ด้วย
  • การเติมศูนย์นำหน้าตำแหน่งหน่วยความจำ : เมื่อทำการคำนวณตำแหน่งหน่วยความจำแบบ 16 และ 32 บิต เลขศูนย์จะถูกเติมด้านหน้าจนครบ 64 บิต
  • การอ้างตำแหน่งหน่วยความจำแบบใหม่ : วิธีอ้างตำแหน่งหน่วยความจำแบบสัมพันธ์โดยใช้ค่าในรีจิสเตอร์ชี้คำสั่งบวกกับดีสเพลสเมนท์ ได้ผลลัพธ์เป็นตำแหน่งหน่วยความจำขนาด 64 บิต
  • สแต็กขนาด 64 บิต : เพิ่มคำสั่งที่เกี่ยวข้องกับรีจิสเตอร์ชี้สแต็กขนาด 64 บิต (RSP)
  • คำสั่งกระโดด (branch) : คือคำสั่งในกลุ่มที่เปลี่ยนแปลงค่าของรีจิสเตอร์ RIP เช่น CALL, JMP และ RET ถูกนิยามการทำงานใหม่แตกต่างจากเดิมเล็กน้อย (ทั้งแบบกระโดดใกล้และกระโดดไกล)
  • การสลับสแต็ก : การสลับสแต็กแบบอัตโนมัติถูกเปลี่ยนแปลงให้สนับสนุน 64 บิต
  • คำสั่ง NOP : ออพโค้ด 90h ในเลกาซีคือคำสั่ง XCHG EAX, EAX ถูกเปลี่ยนเป็นไม่ทำอะไรเลยจริงๆ (เหมือนในสมัยแปดบิต)
  • เปลี่ยนโค้ด INC และ DEC : สองคำสั่งนี้เดิมใช้เพิ่มค่ารีจิสเตอร์ แต่ใน K8 โค้ดกลุ่มนี้ถูกนำไปใช้ทำอย่างอื่น ออพโค้ดของสองคำสั่งนี้จึงถูกเปลี่ยนใหม่
  • คำสั่ง MOVSXD : เป็นคำสั่งใหม่ ทำหน้าที่คล้ายคำสั่ง MOVSX เดิม
  • ยกเลิกคำสั่ง : มีคำสั่งหลายคำสั่งถูกยกเลิกไป เช่น AAA, INTO, LES ฯลฯ หากนำไปใช้จะเกิดเออเรอร์ตอนแปลโปรแกรม สาเหตุที่ยกเลิกเพราะบางคำสั่งออพโค้ดถูกนำไปใช้ทำอย่างอื่น (เช่นนำไปใช้ร่วมกับ REX) ขณะที่บางคำสั่งถูกยกเลิกเพราะเข้ากันไม่ได้กับสถาปัตยกรรม 64 บิต
  • เก็บไม่ให้เหลือ : คำสั่ง FXSAVE คำหน้าที่นำข้อมูลในรีจิสเตอร์ทั้งหมดไปเก็บในหน่วยความจำ และคำสั่ง FXRSTOR ทำหน้าที่นำข้อมูลกลับคืนมาใส่ในรีจิสเตอร์

 
Athlon 64 บิตแบบสองคอร์

 

 

เขียนโปรแกรม 64 บิตใน อิทาเนียม

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

•    โปรเทคโหมด : เป็นการทำงานแบบโปรเทคโหมดภายใต้ซีพียูอิทาเนียม
•    เรียลโหมด : เป็นการทำงานแบบเรียลโหมดภายใต้ซีพียูอิทาเนียม
•    เวอร์ช่วลโหมด : เป็นการทำงานแบบเวอร์ช่วลโหมดภายใต้ซีพียูอิทาเนียม
•    โหมดอิทาเนียม : เป็นการทำงานแบบอิทาเนียมเต็มรูปแบบ

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

 

อิทาเนียมทู

 

รีจิสเตอร์ของอิทาเนียม

รีจิสเตอร์ของอิทาเนียมที่เกี่ยวข้องกับนักเขียนโค้ดซึ่งเขียนโค้ดระดับต่ำ อย่างภาษาแอสเซมบลีหรือภาษาซี (รวมถึง C++) มีดังนี้

•    รีจิสเตอร์ใช้งานทั่วไป (GR): จำนวน 128 ตัวขนาด 64 บิต ใช้งานอเนกประสงค์
•    รีจิสเตอร์เลขทศนิยม (FR): จำนวน 128 ตัวขนาด 82 บิต ใช้คำนวณเลขมีทศนิยม
•    รีจิสเตอร์พยากรณ์ (PR): จำนวน 64 ตัวขนาด 1 บิต ใช้พยากรณ์การกระโดด
•    รีจิสเตอร์กระโดด (BR): จำนวน 8 ตัวขนาด 64 บิต ใช้ในการกระโดด
•    รีจิสเตอร์ตัวชี้คำสั่ง (IP): จำนวน 1 ตัวขนาด 64 บิต ใช้ชี้คำสั่ง
•    รีจิสเตอร์สร้างเฟรม (CFM): จำนวน 1 ตัวขนาด 38 บิต ใช้บอกสภาพสแต็กเฟรม
•    รีจิสเตอร์ประยุกต์ (AR): จำนวน 128 ตัวขนาด 64 บิต กลุ่มรีจิสเตอร์ใช้งานเฉพาะกิจ
•    รีจิสเตอร์เฝ้าระวัง (PMD): ขนาด 64 บิต ใช้ตรวจสอบประสิทธิภาพของฮาร์ดแวร์
•    รีจิสเตอร์มาสก์ (UM): ขนาด 6 บิต ทำหน้าที่เหมือนแฟลก
•    รีจิสเตอร์ระบุโปรเซสเซอร์ (CPUID): ขนาด 64 บิต ใช้บอกข้อมูลจำเพาะของชิพ

ในการเขียนโค้ดแบบอิทาเนียม 64 บิตเต็มยศรีจิสเตอร์เหล่านี้จะถูกใช้ทั้งหมด และเพื่อให้เข้ากันได้กับการเขียนโค้ดในสถาปัตยกรรม IA-32 เดิม รีจิสเตอร์เหล่านี้จะถูกจำลอง (register mapping) เป็นรีจิสเตอร์ของแพนเทียม 32 บิต

 

 

 

 

ตัวอย่างโปรแกรมอิทาเนียม

ไม่ใช่แค่ใน C# และจาวาเท่านั้นที่มีเนมสเปส แต่ในภาษาแอสเซมบลีของอิทาเนียมก็มีเนมสเปสกับเขาด้วยเหมือนกัน แต่ความหมายคนละเรื่องกันเลย เนมสเปสในอิทาเนียมมีสามตัวคือ ซิมโบล (Symbols สัญลักษณ์) รีจิสเตอร์ และนีโมนิก ลองดูตัวอย่างโค้ดต่อไปนี้

1    r5:
2    movl r4=r5#
3    ld4 r28=[r8]
4    add r9=2,r1

จากโค้ดข้างบน คำสั่งบรรทัดที่หนึ่งเรากำหนดลาเบลชื่อ r5 นี่คือตัวอย่างการใช้ซิมโบล บรรทัดต่อมาคำสั่ง movl ทำหน้าที่นำข้อมูลในหน่วยความจำตำแหน่งที่ระบุโดย r5 มาใส่ไว้ในรีจิสเตอร์ r4 คำสั่งบรรทัดที่ 3 โหลดข้อมูลสี่ไบต์มาใส่ใน r28 นี่คือตัวอย่างของการอ้างถึงรีจิสเตอร์ บรรทัดที่ 4 นำ 2 มาบวกกับ r1 แล้วนำไปใส่ใน r9 คำสั่ง add คือนีโมนิก ซึ่งอาจะเป็นคำสั่งของอิทาเนียมจริงๆ หรืออาจเป็นพซิวโดออพ (Pseudo-op หมายถึงคำสั่งเทียมที่จะถูกนำไปแปลเป็นภาษาเครื่องอีกที) ก็ได้

 

ภาษาแอสเซมบลี 64 บิต

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

 

C++ 64 บิต

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

char buf[9];
sprintf(buf, "%p", pointer);

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

size_t ArraySize = N * 4;
intptr_t *Array = (intptr_t *)malloc(ArraySize);

อย่างนี้ก็จะเออเรอร์เช่นกันเพราะจองเนื้อที่อาร์เรย์ไว้ไม่พอ วิธีแก้คือใช้ฟังก์ชัน sizeof() ดังนี้

size_t ArraySize = N * sizeof(intptr_t);
intptr_t *Array = (intptr_t *)malloc(ArraySize);

ถ้าเขียนแบบนี้โปรแกรมจะทำงานได้ถูกต้องทั้งใน 32 และ 64 บิต ต่อไปลองดูปัญหาที่เกิดจากการเลื่อนบิต

ptrdiff_t SetBitN(ptrdiff_t value, unsigned bitNum) {
  ptrdiff_t mask = 1 << bitNum;
  return value | mask;
}

ฟังก์ชันนี้หาก bitNum เท่ากับ 32 เมื่อทำงานแบบ 32 บิต mask จะเป็นศูนย์ แต่ถ้าทำงานแบบ 64 บิต mask จะไม่ใช่ศูนย์ปัญหาเกิดจากเลข 1 ที่ใช้ทำ mask มีจำนวนไบต์ต่างจาก ptrdiff_t  วิธีแก้ง่ายๆ คือทำแปลงไทป์ให้ตรงกันแบบนี้ จะทำงานได้ถูกต้องทั้งใน 32 และ 64 บิต

ptrdiff_t mask = ptrdiff_t(1) << bitNum;

 

จาวา 64 บิต

นักเขียนโค้ดภาษาจาวาสบายกว่าเพื่อน เพราะไม่ต้องแก้ไขโปรแกรมแม้แต่บรรทัดเดียว (อันที่จริงไม่ต้องแม้แต่คอมไพล์โปรแกรมใหม่เสียด้วยซ้ำ) โปรแกรมเดิมที่เคยเขียนไว้จะสามารถทำงานได้ทั้งในซีพียู 64 บิตของอินเลทและ AMD   ที่เป็นไปได้เช่นนั้นเพราะโปรแกรมที่สร้างด้วยภาษาจาวาจะอยู่ในสภาพของ “จาวาไบต์โค้ด” เมื่อนำไปรันในคอมพิวเตอร์เครื่องใด จาวารันทามน์จะคอมไพล์โปรแกรมให้กลายเป็นภาษาเครื่อง (native code) ซ้ำอีกครั้ง เมื่อเป็นเช่นนี้คลาสที่นิยามไว้จึงทำงานได้ทั้งในสภาพแวดล้อม 32 และ 64 บิต

ตอนนี้มีจาวารันทามน์หลายแพลตฟอร์ม เช่น ในระบบปฏิบัติการโซลาริสสำหรับซีพียู SPARC 64 บิต ใน Windows Server 2003 ที่ใช้ซีพียู Opteron และในลินุกซ์เรดแฮต ที่ใช้ Opteron เช่นกัน ส่วนจาวารันทามน์ที่ทำงานได้ในซีพียูอิทาเนียมตอนนี้ยังไม่เห็นแม้แต่เงา

       

 

ดอตเน็ต 64 บิต

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

มีข้อยกเว้นอยู่บ้างเหมือนกัน เช่นในกรณีที่เรียกใช้ไลบรารี Win32 แบบอินเตอร์ออพ (interop) หากนำโปรแกรมแบบนี้ไปรันในแพลตฟอร์ม 64 บิต รันทามน์ของดอตเน็ตจะแจ้งข้อความเออเรอร์ว่าลบรารี Win32 แต่การแก้ไขทำได้ไม่ยาก เพียงนำซอร์สโค้ดของไลบรารี Win32 มาคอมไพล์ใหม่ให้เป็น Win64 แค่นั้นก็เรียบร้อย (แต่ถ้าท่านไม่มีซอร์สโค้ดของไลบรารี Win32 ก็ถือว่าประสบเภทภัยมากกว่าวาสนา) มีดอตเน็ตเฟรมเวิร์คพร้อมเครื่องเมื่อพัฒนาโปรแกรมรูปแบบในสถาปัตยกรรม K8 และอิทาเนียม

 

ActionScript 64 บิต
ภาษา ActionScript เวอร์ชันสาม (AS3) ที่ใช้ร่วมกับ Flex 2 ถือว่าเป็นภาษาที่มีกลุ่มผู้ใช้มาก เป็นภาษา OOP คล้าย C# และจาวา แต่คอมไพล์ออกมาเป็น .swf จึงทำงานได้กับตัวเล่นแฟลช 9 ได้ ทำให้นักเขียนโค้ดเขียนสคริปต์ฝั่งไคลเอนได้อย่างหวือหวา ผู้เขียนโค้ดภาษา AS3 ก็เช่นเดียวกับนักเขียนโค้ดดอตเน็ตและจาวา คือไม่ต้องกังวลกับการอพยพจาก 32 ไปยัง 64 บิต เพราะรันทามน์ในตัวเล่นแฟลชจะเป็นผู้จัดการทุกอย่างให้ทั้งหมด ปัญหาหลักคือขณะนี้บริษัท Adobe ยังสร้างตัวเล่นแฟลชที่ทำงานในบราวเซอร์ 64 บิตไม่เสร็จ (ตัวปลักอิน) และยังไม่มีกำหนดว่าจะเสร็จเมื่อใด
        

 

อนาคตสดใสในโลก 64 บิต

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

เมื่อมีผู้ใช้ชิพ 64 บิตมากขึ้นอีกไม่นานเราคงได้เห็นซอฟต์แวร์ 64 บิตพันธุ์แท้ มันจะเป็นซอฟต์แวร์ที่ทรงพลังอย่างที่ไม่เคยมีมาก่อน โปรแกรมที่จะได้รับประโยชน์จากการเขียนโค้ดแบบ 64 บิต คือโปรแกรมที่กินแรงซีพียู และต้องการหน่วยความจำมากๆ เช่นโปรแกรมสร้างภาพสามมิติและเกม ลองนึกภาพดูว่า เกมเอนจิน (game engine)อย่าง Half-Life2 หรือ Oblivion หากถูกนำมาสร้างใหม่เป็นแบบ 64 บิตจะดีเด่นเพียงใด แค่คิดก็ตื่นเต้นจนอดใจรอไม่ไหวแล้ว

เกี่ยวกับผู้เขียน
ลาภลอย วานิชอังกูร
  : เป็นผู้เชี่ยวชาญด้าน .Net C# และ OOP ทำงานด้านคอมพิวเตอร์มานานกว่ายี่สิบปี เขียนโปรแกรมคล่องหลายภาษา เคยทำงานด้านคอมพิวเตอร์ที่ประเทศสหรัฐอเมริกา ประเทศเยอรมัน และประเทศสวิส เคยเป็นครูสอนวิชาคอมพิวเตอร์ เคยเป็นบรรณาธิการนิตยสารคอมพิวเตอร์ มีผลงานบทความ และตำราคอมพิวเตอร์จำนวนมาก ปัจจุบันทำหน้าที่เป็นผู้ให้คำปรึกษาด้าน .Net ให้แก่บริษัท Accenture ท่านสามารถติดต่อผู้เขียนได้ที่ กระดานบทความในเว็บไซต์ laploy.com และที่อีเมล laploy@gmail.com

    

Post a comment or leave a trackback: Trackback URL.

ใส่ความเห็น

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / เปลี่ยนแปลง )

Twitter picture

You are commenting using your Twitter account. Log Out / เปลี่ยนแปลง )

Facebook photo

You are commenting using your Facebook account. Log Out / เปลี่ยนแปลง )

Google+ photo

You are commenting using your Google+ account. Log Out / เปลี่ยนแปลง )

Connecting to %s

%d bloggers like this: