วิธีรันโปรแกรม 32 บิตบน 64 windows 7

เกมสมัยใหม่ส่วนใหญ่ เช่น Overwatch, Hurtworld หรือ Subnautica สามารถทำงานบนระบบปฏิบัติการ 64 บิตเท่านั้น ผู้สร้างโปรแกรมเหล่านี้สร้างแอปพลิเคชั่นเวอร์ชันต่าง ๆ สำหรับ 32- และ 64- บิตไม่ได้ผลกำไร แม้ว่าทั้งสองเวอร์ชันจะค่อนข้างธรรมดาก็ตาม แน่นอนว่าการเปลี่ยนไปใช้ x64 นั้นค่อนข้างง่าย แต่จะเป็นอย่างไรถ้าคุณไม่เปลี่ยน OS และยังต้องการชมเกมยอดนิยมล่ะ? เรียนรู้วิธีเรียกใช้ Subnautica และโปรแกรม 64 บิตอื่นๆ บนระบบ 32 บิต

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

อะไรคือความแตกต่างระหว่างระบบ 32 บิตและระบบ 64 บิต?

เหตุใดโปรแกรมที่ออกแบบมาสำหรับ 64 บิตจึงไม่สามารถเปิดบน 32 บิตได้ เหตุใดเวอร์ชันเหล่านี้จึงแตกต่างกันมาก เนื่องจากไม่ได้ใช้แอปพลิเคชันเดียวกัน และถ้า Overwatch สามารถเล่นบน x64 ได้ ทำไมไม่สามารถเล่นบนคอมพิวเตอร์เครื่องเดียวกันได้ แต่เล่นด้วย x32 ได้?

ขึ้นอยู่กับระบบว่าสามารถติดตั้ง RAM บนพีซีได้จำนวนเท่าใด และสามารถจัดสรรให้กับแต่ละแอปพลิเคชันได้มากเพียงใด ใน x64 จำนวน RAM สูงสุดคือ 16 GB (ใน Windows 7 Professional - สูงสุด 192 GB) ในกรณีนี้ยูทิลิตี้ใด ๆ จะได้รับมากถึง 4 GB ในเวอร์ชัน x32 ตัวเลขที่ระบุจะน้อยกว่ามาก - สูงสุด 4 GB และ 2 GB สำหรับโปรแกรมแยกต่างหาก

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

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

แม้ว่าระบบเหล่านี้จะคล้ายกันอย่างผิวเผิน แต่ก็แตกต่างกันมากในระดับซอฟต์แวร์ พวกเขามีชุดไดรเวอร์ที่แตกต่างกัน ดังนั้น Subnautica, Overwatch, Hurtworld และอื่นๆ ที่คล้ายกันจะไม่ทำงานบนระบบปฏิบัติการ 32 บิต แม้ว่าพีซีจะมีคุณสมบัติที่จำเป็นก็ตาม

สำหรับเกม แอพพลิเคชั่น กราฟิก หรือโปรแกรมตัดต่อวิดีโอสมัยใหม่ พื้นที่ 2 GB ที่ x32 จัดสรรให้นั้นไม่เพียงพอ ผู้แต่งเกมใหม่สร้างผลิตภัณฑ์ของตนสำหรับ x64 โดยเฉพาะ

จะทราบได้อย่างไรว่าโปรเซสเซอร์รองรับ x64 หรือไม่

คุณสามารถดูระบบปฏิบัติการที่คุณติดตั้งได้ดังนี้:

  1. บนเดสก์ท็อปของคุณ คลิกขวาที่ไอคอน "My Computer"
  2. รายการ “คุณสมบัติ” นอกจากนี้ยังสามารถพบได้ในส่วนแผงควบคุม
  3. บรรทัด "Type" จะระบุจำนวนบิตในเวอร์ชันระบบปฏิบัติการของคุณ

ก่อนอื่นคุณต้องเข้าใจว่าคุณกำลังทำงานอยู่ในระบบใด

ก่อนที่คุณจะรัน Overwatch บนระบบ 32 บิต ให้ตรวจสอบว่าพีซีของคุณสามารถจัดการกับเกมได้หรือไม่ ตรวจสอบว่าโปรเซสเซอร์รองรับคำสั่ง 64 บิตหรือไม่ ซึ่งสามารถทำได้โดยใช้โปรแกรมทดสอบพิเศษ ตัวอย่างเช่นยูทิลิตี้ฟรี "SecurAble" เหมาะสม ไม่จำเป็นต้องติดตั้ง ดังนั้นจึงไม่จำเป็นต้องถอดออกหลังการใช้งาน เพียงแค่เรียกใช้ไฟล์ปฏิบัติการ ข้อมูลเกี่ยวกับโปรเซสเซอร์จะแสดง: ชื่อ ความเร็วสัญญาณนาฬิกา ความลึกบิต ไม่ว่าจะรองรับ D.E.P หรือไม่ (ซึ่งจะช่วยปกป้องอุปกรณ์จากบัฟเฟอร์ล้น) และการแสดงภาพฮาร์ดแวร์ คุณสามารถคลิกที่ผลลัพธ์ใดก็ได้ จากนั้นคำอธิบายจะปรากฏขึ้น

ตรวจสอบการรองรับโปรเซสเซอร์สำหรับคำสั่ง 64 บิต

หากโปรแกรมส่งคืนค่า "สูงสุด 32 บิต" แสดงว่าแอปพลิเคชันที่ออกแบบมาสำหรับ x64 ไม่น่าจะทำงาน หากต้องการเล่น Overwatch หรือ Hurtword คุณจะต้องเปลี่ยนโปรเซสเซอร์หรือกำจัดเซิร์ฟเวอร์ระยะไกล

จะเปลี่ยนระบบ 32 บิตเป็นระบบ 64 บิตได้อย่างไร

มียูทิลิตี้หลายอย่างสำหรับสิ่งที่เรียกว่าการจำลองเสมือน พวกเขาจำลองการทำงานของแพลตฟอร์มด้วยซอฟต์แวร์และฮาร์ดแวร์บางอย่าง หากคุณต้องการทราบวิธีรัน Hurtworld บนระบบ 32 บิต ให้ใช้หนึ่งในยูทิลิตี้เหล่านี้

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

ออราเคิล VirtualBox

โปรแกรมสากลสำหรับงานที่คล้ายกัน

  1. ติดตั้งและรันมัน ทางด้านซ้ายจะมีรายการระบบปฏิบัติการที่ติดตั้งและแถบเครื่องมือ ด้านขวาเป็นข้อมูลเกี่ยวกับระบบที่เลือก
  2. คลิกปุ่ม "สร้าง" หน้าต่างข้อมูลจะปรากฏขึ้น คลิก "ถัดไป"
  3. เลือกประเภทและเวอร์ชันของระบบปฏิบัติการ มีตัวเลือกมากมายให้เลือก: ไม่ใช่แค่ Microsoft windows เท่านั้น แต่ยังรวมถึง Linux ด้วย
  4. จากนั้นคุณจะต้องตัดสินใจว่าจะจัดสรร RAM ให้กับระบบ "แขก" เท่าใด
  5. หลังจากนี้คุณจะต้องสร้างดิสก์เสมือน (ที่จะเขียนไฟล์ OS) คุณสามารถเลือกอันที่มีอยู่หรือสร้างอันใหม่ได้ และทำเครื่องหมายที่ช่องถัดจากตัวเลือก "ดิสก์สำหรับบูต"
  6. ในหน้าต่างถัดไป ให้เลือกว่าความจุของดิสก์จะคงที่หรือไดนามิก (เปลี่ยนแปลง) มีคำอธิบายโดยละเอียดสำหรับแต่ละรายการ เป็นการดีกว่าถ้าทำให้การบูตได้รับการแก้ไข คุณสามารถเพิ่มไดรฟ์เพิ่มเติมได้ในภายหลัง
  7. กำหนดขนาดพื้นที่จัดเก็บข้อมูลเสมือน โดยปกติแล้ว 10 GB ก็เพียงพอแล้ว เป็นการดีกว่าถ้าสร้างไว้ในที่อื่น - ไม่ใช่ในที่เดียวกับที่ติดตั้งระบบหลัก
  8. รอให้กระบวนการเสร็จสิ้น อันใหม่จะปรากฏในรายการอันที่มีอยู่

วิธีหนึ่งคือการใช้ยูทิลิตี้การจำลองเสมือน

หลังจากนั้นคุณสามารถกำหนดค่าฮาร์ดแวร์ได้:

  1. เลือกระบบปฏิบัติการเกสต์แล้วคลิกคุณสมบัติ
  2. ในส่วนทั่วไป - ขั้นสูงให้เปลี่ยนโฟลเดอร์สำหรับบันทึกรูปภาพเป็นโฟลเดอร์ที่สะดวกสำหรับคุณ
  3. ติดตั้งคลิปบอร์ดที่นั่น กำหนดวิธีการถ่ายโอนข้อมูลระหว่างระบบปฏิบัติการต่างๆ
  4. ในแท็บ "ระบบ" คุณสามารถเลือกคุณสมบัติของมาเธอร์บอร์ดและโปรเซสเซอร์เสมือนได้
  5. จำเป็นต้องมีรายการ "เครือข่าย" เพื่อกำหนดค่าการเข้าถึงเวิลด์ไวด์เว็บ คุณสามารถออกจากการตั้งค่าเริ่มต้นได้
  6. ในส่วน "สื่อ" ระบุตำแหน่งที่คุณต้องการรับระบบปฏิบัติการ หากตัวติดตั้งอยู่ในแผ่นซีดี ให้ใส่ลงในไดรฟ์ของคุณ หากต้องการดาวน์โหลดจาก .ISO ให้คลิกที่ปุ่ม "เปิด" ถัดจากรายการ "ไดรฟ์" ดูเหมือนโฟลเดอร์สีเหลือง
  7. คุณยังสามารถเพิ่มรูปภาพอื่น ๆ ที่นั่นเพื่อสลับระหว่างรูปภาพเหล่านั้นได้อย่างรวดเร็ว เช่น ฐานข้อมูล แอปพลิเคชั่น เกม

หลังจากตั้งค่าเสร็จแล้วให้คลิก "ตกลง" หากต้องการเริ่ม guest OS ให้คลิกที่มันและปุ่ม "Start" การติดตั้งจะดำเนินการต่อไป และคุณสามารถสลับระหว่างระบบได้: เล่นแบบ 64 บิตและทำงานในแบบ 32 บิต

เครื่องเสมือนอื่นๆ

นอกจากนี้ยังมียูทิลิตี้สำหรับการทำงานกับเครื่องเสมือน:

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

การประมวลผลแบบคลาวด์ (เซิร์ฟเวอร์ระยะไกล)

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

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

บริการคลาวด์ที่ล้ำสมัยช่วยขยายขีดความสามารถของเรา

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

NastroyVse.ru

windows x64 - เหตุใดจึงมีโปรแกรม 32 บิตมากมาย

คอมพิวเตอร์ของคุณน่าจะใช้ Windows เวอร์ชัน 64 บิต แต่ถ้าคุณเปิด Task Manager คุณจะเห็นว่าโปรแกรมส่วนใหญ่ในระบบของคุณยังคงเป็น 32 บิต นี่เป็นปัญหาจริงๆเหรอ? มีความแตกต่างมากมายระหว่าง Windows รุ่น 64 บิตและ 32 บิต Windows รุ่น 64 บิตสามารถเรียกใช้ซอฟต์แวร์ 32 บิตได้ แต่ Windows รุ่น 32 บิตไม่สามารถเรียกใช้ซอฟต์แวร์ 64 บิตได้

จะทราบความลึกของบิตของโปรแกรมได้อย่างไร?

ลองใช้ตัวจัดการงานเพื่อดูว่าโปรแกรมใดของคุณเป็น 64 บิตและ 32 บิต คลิกขวาที่ทาสก์บาร์แล้วเลือกตัวจัดการงานหรือกด Ctrl + Shift + Esc เพื่อเปิด ดูคอลัมน์ที่มีชื่อกระบวนการ หากคุณใช้ Windows 8.1 หรือ 8 เวอร์ชัน 64 บิต คุณจะเห็นคำว่า "(32-บิต)" หลังชื่อโปรแกรมแต่ละเวอร์ชัน 32 บิต หากคุณใช้ Windows 7 เวอร์ชัน 64 บิต คุณจะเห็น “*32” แทน โดยทั่วไปโปรแกรม 32 บิตจะถูกติดตั้งในโฟลเดอร์ C:\Program Files (x86)\ บน Windows เวอร์ชัน 64 บิต ในขณะที่โดยทั่วไปโปรแกรม 64 บิตจะถูกติดตั้งในโฟลเดอร์ C:\Program Files\ มันเป็นเพียงกฎ แต่ไม่มีใครบอกว่าไม่มีกฎอื่นใดที่ห้ามไม่ให้ติดตั้งโปรแกรม 64 บิตในโฟลเดอร์ C:\Program Files (x86)\ ตัวอย่างเช่น Steam เป็นโปรแกรม 32 บิต ดังนั้นจึงติดตั้งใน "C:\Program Files (x86)\" ตามค่าเริ่มต้น เกมที่คุณติดตั้งบน Steam จะถูกติดตั้งในโฟลเดอร์ C:\Program Files (x86)\Steam ตามค่าเริ่มต้น รวมถึง แม้แต่เกมเวอร์ชัน 64 บิต หากคุณเปรียบเทียบโฟลเดอร์ Program Files สองโฟลเดอร์ที่แตกต่างกัน คุณจะพบว่าโปรแกรมส่วนใหญ่ของคุณมักจะติดตั้งอยู่ในโฟลเดอร์ C:\Program Files (x86) และโปรแกรมเหล่านี้ส่วนใหญ่เป็นแบบ 32 บิต

การใช้งานซอฟต์แวร์ 32 บิตบนระบบปฏิบัติการ 64 บิต

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

โปรแกรม 64 บิตและโปรแกรม 32 บิต: ไหนดีกว่ากัน?

โปรแกรม 32 บิตทำงานโดยไม่มีปัญหาบนระบบปฏิบัติการ Windows เวอร์ชัน 64 บิต แต่จะดีกว่าไหมถ้าโปรแกรมทั้งหมดของคุณเป็นแบบ 64 บิต? มีข้อดีอย่างแน่นอนสำหรับโปรแกรม 64 บิต โปรแกรม 32 บิตสามารถใช้หน่วยความจำได้เพียง 2 GB ในขณะที่โปรแกรม 64 บิตสามารถใช้งานได้มากกว่านั้นมาก หากโปรแกรมมีแนวโน้มที่จะถูกโจมตี คุณลักษณะด้านความปลอดภัยเพิ่มเติมที่ใช้กับโปรแกรม 64 บิตอาจช่วยได้ ขณะนี้ Google Chrome เป็นแอปพลิเคชัน 32 บิตแม้ใน Windows OS เวอร์ชัน 64 บิต แต่โปรแกรมนี้เวอร์ชันเบต้า 64 บิตได้ปรากฏขึ้นแล้ว และ Google สัญญาว่า Chrome เวอร์ชัน 64 บิตจะเร็วขึ้น ปลอดภัยยิ่งขึ้น และเสถียรยิ่งขึ้น บางโปรแกรมมีเวอร์ชัน 64 บิต ตัวอย่างเช่น: Photoshop, iTunes, Microsoft Office และโปรแกรม Windows ยอดนิยมบางโปรแกรม ซึ่งทั้งหมดนี้มีให้บริการในรูปแบบ 64 บิต เกมล่าสุดมักเป็นแบบ 64 บิต ดังนั้นจึงสามารถใช้หน่วยความจำมากกว่า 2GB ได้ หลายโปรแกรมยังไม่ได้เปลี่ยนไปใช้ 64 บิต และส่วนใหญ่ไม่เคยเปลี่ยนเลย ทุกวันนี้ คุณยังคงสามารถเรียกใช้โปรแกรม Windows 32 บิตส่วนใหญ่ได้ แม้กระทั่งโปรแกรมที่เปิดตัวเมื่อ 10 ปีที่แล้ว บน Windows เวอร์ชัน 64 บิต แม้ว่านักพัฒนาซอฟต์แวร์จะอัปเดตโปรแกรมเหล่านั้นแล้วก็ตาม นักพัฒนาซอฟต์แวร์ที่ต้องการจัดเตรียมโปรแกรมเวอร์ชัน 64 บิตจะต้องทำงานพิเศษมากมาย เขาต้องแน่ใจว่าโค้ดที่มีอยู่คอมไพล์และทำงานอย่างถูกต้องเป็นซอฟต์แวร์ 64 บิต จะต้องมีและสนับสนุนโปรแกรมสองเวอร์ชันแยกกัน เนื่องจากผู้ใช้ที่ใช้ Windows รุ่น 32 บิต ไม่สามารถใช้เวอร์ชัน 64 บิตได้ ลองใช้ Evernote สำหรับเดสก์ท็อป Windows เป็นตัวอย่าง แม้ว่าพวกเขาจะออก Evernote เวอร์ชัน 64 บิต ผู้ใช้ก็คงไม่สังเกตเห็นความแตกต่างเลย โปรแกรม 32 บิตสามารถทำงานได้ดีบน Windows เวอร์ชัน 64 บิต และหากไม่มีประโยชน์ที่เห็นได้ชัดเจน การมีเวอร์ชัน 64 บิตก็ไม่มีประโยชน์

จะค้นหาแอปพลิเคชัน 64 บิตได้ที่ไหน

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

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

itchief.ru

7 ขั้นตอนในการถ่ายโอนโปรแกรมไปยังระบบ 64 บิต

บทความนี้กล่าวถึงขั้นตอนหลักเพื่อให้แน่ใจว่าการถ่ายโอนแอปพลิเคชัน Windows 32 บิตไปยังระบบ Windows 64 บิตถูกต้อง แม้ว่าบทความนี้จะมุ่งเป้าไปที่นักพัฒนาที่ใช้ภาษา C/C++ ใน Visual Studio 2005/2008 แต่ก็มีประโยชน์สำหรับนักพัฒนารายอื่นๆ ที่วางแผนจะย้ายแอปพลิเคชันของตนไปยังระบบ 64 บิตด้วย บทความนี้จะอธิบายประเด็นหลักที่นักพัฒนาวางแผนที่จะย้ายโปรแกรม 32 บิตไปเป็นระบบ 64 บิต แน่นอนว่ารายการปัญหาที่พิจารณายังไม่สมบูรณ์ แต่ฉันหวังว่าจะมีการเสนอบทความนี้ในเวอร์ชันขยายเมื่อเวลาผ่านไป ผู้เขียนจะขอบคุณสำหรับข้อเสนอแนะ ความคิดเห็น และคำถามที่จะปรับปรุงเนื้อหาข้อมูลของบทความนี้ ในสถาปัตยกรรมคอมพิวเตอร์ คำว่า "64 บิต" หมายถึงจำนวนเต็ม 64 บิตและชนิดข้อมูลอื่นๆ ที่มีขนาด 64 บิต ระบบ "64 บิต" อาจหมายถึงสถาปัตยกรรมไมโครโปรเซสเซอร์ 64 บิต (เช่น EM64T, IA-64) หรือระบบปฏิบัติการ 64 บิต (เช่น Windows XP Professional x64 Edition) AMD64 (aka x86-64, Intel 64, EM64T, x64) เป็นสถาปัตยกรรมไมโครโปรเซสเซอร์ 64 บิตและชุดคำสั่งที่เกี่ยวข้องซึ่งพัฒนาโดย AMD ชุดคำสั่งนี้ได้รับอนุญาตจาก Intel ภายใต้ชื่อ EM64T (Intel64) สถาปัตยกรรม AMD64 เป็นส่วนเสริมของสถาปัตยกรรม x86 ที่มีความเข้ากันได้แบบย้อนหลังเต็มรูปแบบ สถาปัตยกรรมนี้แพร่หลายอย่างกว้างขวางเพื่อเป็นฐานสำหรับคอมพิวเตอร์ส่วนบุคคลและเวิร์กสเตชัน IA-64 เป็นสถาปัตยกรรมไมโครโปรเซสเซอร์ 64 บิตที่พัฒนาร่วมกันโดย Intel และ Hewlett Packard ใช้งานในไมโครโปรเซสเซอร์ Itanium และ Itanium 2 สถาปัตยกรรมส่วนใหญ่จะใช้ในเซิร์ฟเวอร์มัลติโปรเซสเซอร์และระบบคลัสเตอร์ AMD64 และ IA-64 เป็นสถาปัตยกรรม 64 บิตที่แตกต่างกันสองตัวซึ่งเข้ากันไม่ได้ ดังนั้นนักพัฒนาควรตัดสินใจทันทีว่าจำเป็นต้องรองรับสถาปัตยกรรมทั้งสองนี้หรือเพียงสถาปัตยกรรมเดียว ในกรณีส่วนใหญ่ เว้นแต่ว่าคุณกำลังพัฒนาซอฟต์แวร์ที่มีความเชี่ยวชาญสูงสำหรับระบบคลัสเตอร์หรือใช้ DBMS ประสิทธิภาพสูงของคุณเอง เป็นไปได้มากว่าคุณจะต้องใช้การรองรับสถาปัตยกรรม AMD64 เท่านั้น ซึ่งแพร่หลายมากกว่า IA-64 มาก นี่เป็นเรื่องจริงโดยเฉพาะอย่างยิ่งสำหรับซอฟต์แวร์สำหรับตลาดคอมพิวเตอร์ส่วนบุคคลซึ่งเกือบ 100 เปอร์เซ็นต์ครอบครองโดยสถาปัตยกรรม AMD64 นอกจากนี้ในบทความเราจะพูดถึงเฉพาะสถาปัตยกรรม AMD64 (EM64T, x64) เนื่องจากการใช้งานนี้มีความเกี่ยวข้องมากที่สุดสำหรับนักพัฒนาซอฟต์แวร์แอปพลิเคชัน

เมื่อพูดถึงสถาปัตยกรรมต่างๆ เราควรพูดถึงแนวคิดของ Data Model ควรเข้าใจแบบจำลองข้อมูลว่าเป็นความสัมพันธ์ระหว่างมิติของประเภทที่ยอมรับภายในสภาพแวดล้อมการพัฒนา สำหรับระบบปฏิบัติการเดียว อาจมีเครื่องมือการพัฒนาหลายอย่างที่ยึดตามโมเดลข้อมูลที่ต่างกัน แต่โดยปกติแล้วจะมีเพียงรุ่นเดียวเท่านั้นที่ชนะ ซึ่งเป็นรุ่นที่เหมาะกับสภาพแวดล้อมของฮาร์ดแวร์และซอฟต์แวร์มากที่สุด ตัวอย่างคือระบบปฏิบัติการ Windows 64 บิต ซึ่งโมเดลข้อมูลดั้งเดิมคือ LLP64 แต่เพื่อความเข้ากันได้ ระบบ Windows 64 บิตรองรับการทำงานของโปรแกรม 32 บิตที่ทำงานในโหมดแบบจำลองข้อมูล ILP32LL ตาราง N1 ให้ข้อมูลเกี่ยวกับแบบจำลองข้อมูลหลัก


ตารางที่ N1 โมเดลข้อมูล

โมเดลข้อมูลที่ใช้ส่งผลต่อกระบวนการพัฒนาแอปพลิเคชัน 64 บิต เนื่องจากโค้ดโปรแกรมจะต้องคำนึงถึงความลึกของบิตของข้อมูลที่ใช้

คุณควรเริ่มเชี่ยวชาญระบบ 64 บิตด้วยคำถาม “เราจำเป็นต้องสร้างโปรเจ็กต์ของเราใหม่สำหรับระบบ 64 บิตหรือไม่” คำถามนี้ต้องตอบแต่อย่ารีบร้อนหลังจากคิดแล้ว ประการหนึ่ง คุณสามารถตามหลังคู่แข่งได้โดยไม่นำเสนอโซลูชัน 64 บิตได้ทันเวลา ในทางกลับกัน คุณสามารถเสียเวลากับแอปพลิเคชัน 64 บิตที่ไม่มีข้อได้เปรียบทางการแข่งขันใดๆ เราแสดงรายการปัจจัยหลักที่จะช่วยคุณในการตัดสินใจ คุณไม่ควรสร้างแอปพลิเคชันเวอร์ชัน 64 บิตที่มีวงจรชีวิตสั้น ต้องขอบคุณระบบย่อย WOW64 แอปพลิเคชัน 32 บิตรุ่นเก่าจึงทำงานได้ดีบนระบบ Windows 64 บิต ดังนั้นจึงไม่มีเหตุผลที่จะสร้างโปรแกรม 64 บิตที่จะไม่ได้รับการสนับสนุนอีกต่อไปใน 2 ปี ยิ่งไปกว่านั้น จากการปฏิบัติแสดงให้เห็นว่าการเปลี่ยนไปใช้ Windows เวอร์ชัน 64 บิตมีความล่าช้า และบางทีผู้ใช้ส่วนใหญ่ของคุณในระยะสั้นอาจใช้โซลูชันซอฟต์แวร์เวอร์ชัน 32 บิตเท่านั้น หากคุณวางแผนสำหรับการพัฒนาในระยะยาวและการสนับสนุนผลิตภัณฑ์ซอฟต์แวร์ในระยะยาว คุณควรเริ่มทำงานกับโซลูชันเวอร์ชัน 64 บิต ซึ่งสามารถทำได้อย่างช้าๆ แต่โปรดจำไว้ว่ายิ่งคุณไม่มีเวอร์ชัน 64 บิตที่เต็มเปี่ยมนานเท่าใด ปัญหาในการรองรับแอปพลิเคชันดังกล่าวที่ติดตั้งบน Windows เวอร์ชัน 64 บิตก็จะยิ่งยุ่งยากมากขึ้นเท่านั้น การคอมไพล์โปรแกรมใหม่สำหรับระบบ 64 บิตจะทำให้สามารถใช้ RAM จำนวนมากได้ และยังจะทำให้การทำงานเร็วขึ้น 5-15% การเร่งความเร็ว 5-10% จะเกิดขึ้นเนื่องจากการใช้ความสามารถทางสถาปัตยกรรมของโปรเซสเซอร์ 64 บิต เช่น การลงทะเบียนจำนวนมากขึ้น ความเร็วที่เพิ่มขึ้นอีก 1%-5% เกิดจากการไม่มีเลเยอร์ WOW64 ซึ่งแปลการเรียก API ระหว่างแอปพลิเคชัน 32 บิตและระบบปฏิบัติการ 64 บิต หากโปรแกรมของคุณใช้งานไม่ได้กับข้อมูลจำนวนมาก (มากกว่า 2GB) และความเร็วไม่สำคัญการเปลี่ยนไปใช้ระบบ 64 บิตในอนาคตอันใกล้นี้จะไม่เกี่ยวข้องกัน อย่างไรก็ตาม แม้แต่แอปพลิเคชัน 32 บิตธรรมดาก็สามารถได้รับประโยชน์จากการรันในสภาพแวดล้อม 64 บิต คุณคงทราบว่าโปรแกรมที่คอมไพล์ด้วยคีย์ /LARGEADDRESSAWARE:YES สามารถจัดสรรหน่วยความจำได้สูงสุด 3 กิกะไบต์ หากระบบปฏิบัติการ Windows 32 บิตเปิดตัวด้วยคีย์ /3gb โปรแกรม 32 บิตเดียวกันที่ทำงานบนระบบ 64 บิตสามารถจัดสรรหน่วยความจำได้เกือบ 4 GB (ในทางปฏิบัติประมาณ 3.5 GB) หากคุณพัฒนาไลบรารี ส่วนประกอบ หรือองค์ประกอบอื่นๆ ที่นักพัฒนาจากภายนอกใช้เพื่อสร้างซอฟต์แวร์ คุณจะต้องดำเนินการเชิงรุกในการสร้างผลิตภัณฑ์เวอร์ชัน 64 บิต มิฉะนั้น ลูกค้าของคุณที่สนใจออกเวอร์ชัน 64 บิตจะถูกบังคับให้มองหาโซลูชันอื่น ตัวอย่างเช่น นักพัฒนาซอฟต์แวร์และฮาร์ดแวร์บางรายตอบสนองด้วยความล่าช้าอันยาวนานต่อการเกิดขึ้นของโปรแกรม 64 บิต ซึ่งบังคับให้ไคลเอ็นต์จำนวนหนึ่งต้องมองหาเครื่องมืออื่นๆ เพื่อปกป้องโปรแกรมของตน ประโยชน์เพิ่มเติมของการเปิดตัวไลบรารีเวอร์ชัน 64 บิตคือคุณสามารถขายเป็นผลิตภัณฑ์แยกต่างหากได้ ดังนั้น ลูกค้าของคุณที่ต้องการสร้างแอปพลิเคชันทั้งแบบ 32 บิตและ 64 บิตจะถูกบังคับให้ซื้อใบอนุญาตที่แตกต่างกัน 2 ใบ ตัวอย่างเช่น Spatial Corporation ใช้นโยบายนี้เมื่อขายห้องสมุด Spatial ACIS ก่อนที่คุณจะวางแผนสร้างผลิตภัณฑ์เวอร์ชัน 64 บิต ให้ตรวจสอบว่ามีไลบรารีและส่วนประกอบเวอร์ชัน 64 บิตที่ใช้หรือไม่ นอกจากนี้ ค้นหาว่านโยบายการกำหนดราคาสำหรับไลบรารีเวอร์ชัน 64 บิตเป็นอย่างไร ทั้งหมดนี้สามารถพบได้โดยไปที่เว็บไซต์ของผู้พัฒนาห้องสมุด หากไม่มีการสนับสนุน ให้ค้นหาโซลูชันอื่นที่รองรับระบบ 64 บิตล่วงหน้า หากโซลูชันของคุณยังมีโมดูล 16 บิต แสดงว่าถึงเวลาที่ต้องกำจัดโมดูลเหล่านั้น ไม่รองรับการใช้งานแอปพลิเคชัน 16 บิตบน Windows เวอร์ชัน 64 บิต ที่นี่เราควรชี้แจงประเด็นหนึ่งที่เกี่ยวข้องกับการใช้ตัวติดตั้ง 16 บิต ยังคงใช้เพื่อติดตั้งแอปพลิเคชัน 32 บิตบางตัว มีการสร้างกลไกพิเศษที่จะแทนที่ตัวติดตั้ง 16 บิตยอดนิยมจำนวนหนึ่งด้วยเวอร์ชันที่ใหม่กว่าทันที นี่อาจทำให้เกิดความเข้าใจผิดว่าโปรแกรม 16 บิตยังคงทำงานในสภาพแวดล้อม 64 บิต จำไว้ว่านี่ไม่เป็นความจริง อย่าลืมว่าการใช้โค้ดแอสเซมบลีจำนวนมากสามารถเพิ่มต้นทุนในการสร้างแอปพลิเคชันเวอร์ชัน 64 บิตได้อย่างมาก หลังจากชั่งน้ำหนักข้อเท็จจริงที่ระบุไว้ทั้งหมดแล้ว ข้อดีและข้อเสียทั้งหมด ให้ตัดสินใจว่าคุณควรย้ายโปรเจ็กต์ของคุณไปยังระบบ 64 บิตหรือไม่ และถ้าเป็นเช่นนั้นก็มาเริ่มกันเลย เพียงเพราะคุณได้ตัดสินใจที่จะพัฒนาผลิตภัณฑ์เวอร์ชัน 64 บิตและเต็มใจที่จะใช้เวลากับผลิตภัณฑ์นั้นไม่ได้รับประกันความสำเร็จ ความจริงก็คือคุณต้องมีเครื่องมือที่จำเป็นทั้งหมดและอาจมีเหตุการณ์ไม่พึงประสงค์เกิดขึ้นที่นี่

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

แน่นอนว่าเป็นไปไม่ได้ที่จะแสดงรายการทุกอย่างที่อาจจำเป็นสำหรับโครงการที่นี่ แต่ฉันจะยังคงเสนอรายการที่จะช่วยให้คุณเข้าใจทิศทางและอาจจำประเด็นอื่นๆ ที่จำเป็นสำหรับการดำเนินการตามโครงการ 64 บิตของคุณ: เป็นการยากที่จะพูดอะไรเกี่ยวกับความสำคัญของการมีคอมไพเลอร์ 64 บิต มันก็ต้องเป็นเช่นนั้น หากคุณวางแผนที่จะพัฒนาแอปพลิเคชัน 64 บิตโดยใช้ Visual Studio 2008 เวอร์ชันล่าสุด (ณ เวลาที่เขียน) ตารางต่อไปนี้ N2 จะช่วยพิจารณาว่าคุณต้องการ Visual Studio รุ่นใด

ตาราง N2 ความสามารถของ Visual Studio 2008 รุ่นต่างๆ แน่นอนว่าคุณสามารถใช้เครื่องเสมือนเพื่อรันแอปพลิเคชัน 64 บิตบนฮาร์ดแวร์ 32 บิตได้ แต่นี่ไม่สะดวกอย่างยิ่งและจะไม่ให้การทดสอบในระดับที่ต้องการ ขอแนะนำให้เครื่องติดตั้ง RAM อย่างน้อย 4-8 กิกะไบต์ หากมีการระบุไลบรารีไว้ในซอร์สโค้ด จะต้องมีการกำหนดค่าโปรเจ็กต์ 64 บิต การอัพเกรดไลบรารี่ด้วยตัวคุณเองเพื่อสร้างมันสำหรับระบบ 64 บิตอาจเป็นงานที่ไร้คุณค่าและยาก และผลลัพธ์ที่ได้ก็อาจไม่น่าเชื่อถือและเกิดข้อผิดพลาดได้ง่าย คุณอาจละเมิดข้อตกลงใบอนุญาตด้วยการทำเช่นนั้น หากคุณใช้ไลบรารีเป็นโมดูลไบนารี คุณควรตรวจสอบด้วยว่ามีโมดูล 64 บิตอยู่หรือไม่ คุณจะไม่สามารถใช้ DLL 32 บิตภายในแอปพลิเคชัน 64 บิตได้ คุณสามารถสร้างสายรัดพิเศษผ่านทาง COM ได้ แต่นี่จะเป็นงานขนาดใหญ่และซับซ้อนแยกต่างหาก โปรดทราบว่าการซื้อไลบรารีเวอร์ชัน 64 บิตอาจทำให้ต้องเสียเงินเพิ่มเติม Visual C++ ไม่รองรับแอสเซมเบลอร์แบบอินไลน์ 64 บิต คุณต้องใช้แอสเซมเบลอร์ 64 บิตภายนอก (เช่น MASM) หรือมีการใช้งาน C/C++ ของฟังก์ชันเดียวกัน การปรับปรุงวิธีการทดสอบอย่างมีนัยสำคัญ การปรับปรุงการทดสอบหน่วยให้ทันสมัย ​​การใช้เครื่องมือใหม่ เราจะกล่าวถึงรายละเอียดเพิ่มเติมด้านล่าง แต่อย่าลืมคำนึงถึงสิ่งนี้เมื่อประมาณเวลาที่ใช้ในการโยกย้ายแอปพลิเคชันไปยังระบบใหม่ หากคุณกำลังพัฒนาแอปพลิเคชันที่ใช้ทรัพยากรจำนวนมากซึ่งใช้ RAM จำนวนมาก คุณจะต้องดูแลการเติมฐานข้อมูลของข้อมูลอินพุตทดสอบ เมื่อโหลดทดสอบแอปพลิเคชัน 64 บิต ขอแนะนำให้ใช้หน่วยความจำเกิน 4 กิกะไบต์ ข้อผิดพลาดจำนวนมากสามารถปรากฏได้ภายใต้เงื่อนไขดังกล่าวเท่านั้น ระบบป้องกันที่ใช้ต้องรองรับระบบ 64 บิตเต็มขอบเขตที่คุณต้องการ ตัวอย่างเช่น Aladdin เปิดตัวไดรเวอร์ 64 บิตอย่างรวดเร็วเพื่อรองรับคีย์ฮาร์ดแวร์ Hasp แต่เป็นเวลานานมากแล้วที่ไม่มีระบบสำหรับการป้องกันไฟล์ไบนารี 64 บิตโดยอัตโนมัติ (โปรแกรม Hasp Envelop) ดังนั้น กลไกการป้องกันจึงต้องดำเนินการอย่างอิสระภายในโค้ดโปรแกรม ซึ่งเป็นงานที่ซับซ้อนเพิ่มเติมซึ่งต้องใช้คุณสมบัติและเวลา อย่าลืมเกี่ยวกับปัญหาที่คล้ายกันที่เกี่ยวข้องกับความปลอดภัย ระบบการอัพเดต และอื่นๆ คุณต้องมีตัวติดตั้งใหม่ที่สามารถติดตั้งแอปพลิเคชัน 64 บิตได้อย่างสมบูรณ์ ฉันอยากจะเตือนคุณทันทีเกี่ยวกับข้อผิดพลาดแบบดั้งเดิมอย่างหนึ่ง นี่คือการสร้างตัวติดตั้ง 64 บิตสำหรับการติดตั้งผลิตภัณฑ์ซอฟต์แวร์ 32/64 บิต เมื่อเตรียมแอปพลิเคชันเวอร์ชัน 64 บิต นักพัฒนามักต้องการทำให้แอปพลิเคชันเป็นเวอร์ชัน 64 บิตโดยสมบูรณ์ และพวกเขาสร้างตัวติดตั้ง 64 บิตโดยลืมไปว่าผู้ใช้ระบบปฏิบัติการ 32 บิตจะไม่เรียกใช้แพ็คเกจการติดตั้งดังกล่าว โปรดทราบว่าไม่ใช่แอปพลิเคชัน 32 บิตที่รวมอยู่ในการแจกจ่ายพร้อมกับ 64 บิตที่จะไม่เริ่มทำงาน แต่เป็นตัวติดตั้งเอง ท้ายที่สุดหากการแจกจ่ายเป็นแอปพลิเคชัน 64 บิต แน่นอนว่ามันจะไม่ทำงานบนระบบปฏิบัติการ 32 บิต สิ่งที่น่ารำคาญที่สุดเกี่ยวกับเรื่องนี้ก็คือผู้ใช้จะไม่สามารถเดาได้ว่าเกิดอะไรขึ้น เขาจะเห็นแพ็คเกจการติดตั้งที่ไม่สามารถเปิดใช้งานได้ การสร้างการกำหนดค่าโปรเจ็กต์ 64 บิตใน Visual Studio 2005/2008 ดูค่อนข้างง่าย ความยากลำบากจะรอคุณอยู่ในขั้นตอนของการประกอบการกำหนดค่าใหม่และค้นหาข้อผิดพลาดในนั้น หากต้องการสร้างการกำหนดค่า 64 บิต เพียงดำเนินการ 4 ขั้นตอนต่อไปนี้: เปิดตัวจัดการการกำหนดค่า ดังแสดงในรูปที่ N1:

รูปที่ 1. การเปิดตัวจัดการการกำหนดค่า ในตัวจัดการการกำหนดค่า ให้เลือกการสนับสนุนสำหรับแพลตฟอร์มใหม่ (รูปที่ N2): รูปที่ 2 การสร้างการกำหนดค่าใหม่ เลือกแพลตฟอร์ม 64 บิต (x64) และเลือกการตั้งค่าจากเวอร์ชัน 32 บิต เป็นพื้นฐาน (รูปที่ N3) สภาพแวดล้อม Visual Studio จะปรับการตั้งค่าที่ส่งผลต่อโหมดการสร้างเอง

รูปที่ 3 เลือก x64 เป็นแพลตฟอร์มและใช้การกำหนดค่า Win32 เป็นพื้นฐาน การเพิ่มการกำหนดค่าใหม่เสร็จสิ้น และเราสามารถเลือกตัวเลือกการกำหนดค่า 64 บิต และเริ่มรวบรวมแอปพลิเคชัน 64 บิต ตัวเลือกการกำหนดค่า 64 บิตสำหรับการประกอบจะแสดงในรูปที่ N4 รูปที่ 4. การกำหนดค่าแบบ 32 บิตและ 64 บิตพร้อมใช้งานแล้ว หากคุณโชคดี ไม่จำเป็นต้องกำหนดค่าโปรเจ็กต์ 64 บิตเพิ่มเติม แต่สิ่งนี้ขึ้นอยู่กับโปรเจ็กต์ ความซับซ้อน และจำนวนไลบรารีที่ใช้เป็นอย่างมาก สิ่งเดียวที่ต้องเปลี่ยนทันทีคือขนาดสแต็ก หากโปรเจ็กต์ของคุณใช้ขนาดสแต็กเริ่มต้น ซึ่งก็คือ 1 เมกะไบต์ ก็สมเหตุสมผลแล้วที่จะตั้งค่าเป็น 2 เมกะไบต์สำหรับเวอร์ชัน 64 บิต สิ่งนี้ไม่จำเป็น แต่ควรอยู่ในด้านความปลอดภัยล่วงหน้าจะดีกว่า หากคุณใช้ขนาดสแต็กที่แตกต่างจากขนาดเริ่มต้น ก็สมเหตุสมผลแล้วที่จะทำให้มันใหญ่ขึ้น 2 เท่าสำหรับเวอร์ชัน 64 บิต เมื่อต้องการทำเช่นนี้ ในการตั้งค่าโปรเจ็กต์ ให้ค้นหาและเปลี่ยนพารามิเตอร์ Stack Reserve Size และ Stack Commit Size เป็นการดีที่จะพูดคุยเกี่ยวกับปัญหาทั่วไปที่เกิดขึ้นระหว่างขั้นตอนการคอมไพล์ของการกำหนดค่า 64 บิต พิจารณาว่าปัญหาใดเกิดขึ้นกับไลบรารีบุคคลที่สาม แจ้งว่าคอมไพเลอร์ในโค้ดที่เกี่ยวข้องกับฟังก์ชัน WInAPI จะไม่อนุญาตให้วางตัวชี้เป็นประเภท LONG อีกต่อไป และคุณจะต้องปรับปรุงโค้ดของคุณให้ทันสมัยและใช้ประเภท LONG_PTG และอื่นๆอีกมากมาย. น่าเสียดายที่มีสิ่งนี้อยู่มากมายและข้อผิดพลาดก็หลากหลายมากจนไม่สามารถนำเสนอเป็นบทความเดียวหรืออาจเป็นหนังสือก็ได้ คุณจะต้องตรวจสอบข้อผิดพลาดทั้งหมดที่คอมไพลเลอร์สร้างขึ้นและคำเตือนใหม่ที่ไม่เคยมีมาก่อน และในแต่ละกรณี ให้หาวิธีปรับปรุงโค้ดให้ทันสมัย

ชุดลิงก์ไปยังแหล่งข้อมูลสำหรับการพัฒนาแอปพลิเคชัน 64 บิตโดยเฉพาะสามารถทำให้ชีวิตง่ายขึ้นบางส่วน: http://www.viva64.com/links/64-bit-development/ คอลเลกชันได้รับการอัปเดตอยู่ตลอดเวลาและผู้เขียนจะรู้สึกขอบคุณผู้อ่านหากพวกเขาส่งลิงก์ไปยังแหล่งข้อมูลที่สมควรได้รับความสนใจตามความเห็นของพวกเขา

เราจะเน้นเฉพาะประเภทที่นักพัฒนาอาจสนใจเมื่อทำการย้ายแอปพลิเคชันเท่านั้น ประเภทเหล่านี้แสดงอยู่ในตารางที่ N3 ข้อผิดพลาดในการคอมไพล์ส่วนใหญ่จะเกี่ยวข้องกับการใช้ประเภทเหล่านี้

พิมพ์ ประเภทขนาดบนแพลตฟอร์ม x32 / x64 บันทึก
ภายใน 32 / 32 ประเภทพื้นฐาน บนระบบ 64 บิต ยังคงเป็น 32 บิต
ยาว 32 / 32 ประเภทพื้นฐาน บนระบบ Windows 64 บิต ยังคงเป็น 32 บิต โปรดทราบว่าบนระบบ Linux 64 บิตประเภทนี้ได้ขยายเป็น 64 บิต อย่าลืมเรื่องนี้หากคุณกำลังพัฒนาโค้ดที่ควรใช้งานได้และคอมไพล์สำหรับระบบ Windows และ Linux
ขนาด_t 32 / 64 ประเภทพื้นฐานที่ไม่ได้ลงนาม ขนาดของประเภทถูกเลือกเพื่อให้สามารถรองรับขนาดสูงสุดของอาร์เรย์ที่เป็นไปได้ในทางทฤษฎี ตัวชี้สามารถวางลงในประเภท size_t ได้อย่างปลอดภัย (ข้อยกเว้นคือตัวชี้ไปยังฟังก์ชันคลาส แต่นี่เป็นกรณีพิเศษ)
ptrdiff_t 32 / 64 คล้ายกับประเภท size_t แต่มีลายเซ็น ผลลัพธ์ของนิพจน์ที่ตัวชี้หนึ่งถูกลบออกจากอีกตัวหนึ่ง (ptr1-ptr2) จะเป็นประเภท ptrdiff_t
ตัวชี้ 32 / 64 ขนาดของตัวชี้ขึ้นอยู่กับความจุบิตของแพลตฟอร์มโดยตรง โปรดใช้ความระมัดระวังในการแคสต์พอยน์เตอร์ไปยังประเภทอื่น
__int64 64 / 64 ประเภท 64 บิตที่เซ็นชื่อ
DWORD 32 / 32 ประเภท 32 บิตที่ไม่ได้ลงนาม ประกาศใน WinDef.h เป็น: typedef DWORD แบบยาวที่ไม่ได้ลงชื่อ;
DWORDLONG 64 / 64 ประเภทที่ไม่ได้ลงนาม 64 บิต ประกาศใน WinNT.h เป็น: typedef ULONGLONG DWORDLONG;
DWORD_PTR 32 / 64 ชนิดที่ไม่ได้ลงนามที่สามารถเก็บตัวชี้ได้ ประกาศใน BaseTsd.h เป็น: typedef ULONG_PTR DWORD_PTR;
DWORD32 32 / 32 ประเภท 32 บิตที่ไม่ได้ลงนาม ประกาศใน BaseTsd.h เป็น: typedef unsigned int DWORD32;
DWORD64 64 / 64 ประเภทที่ไม่ได้ลงนาม 64 บิต ประกาศใน BaseTsd.h เป็น: typedef unsigned __int64 DWORD64;
HALF_PTR 16 / 32 พอยน์เตอร์ครึ่งตัว ประกาศใน Basetd.h เป็น:#ifdef _WIN64 typedef int HALF_PTR;#else typedef short HALF_PTR;#endif
INT_PTR 32 / 64 ชนิดที่เซ็นชื่อซึ่งสามารถวางตัวชี้ได้ ประกาศใน BaseTsd.h เป็น:#if กำหนด(_WIN64) typedef __int64 INT_PTR; #else typedef int INT_PTR;#endif
ยาว 32 / 32 ประเภทที่เซ็นชื่อซึ่งยังคงเป็น 32 บิต ดังนั้น ในหลายกรณี ตอนนี้ควรใช้ LONG_PTR ประกาศใน WinNT.h เป็น: typedef long LONG;
LONG_PTR 32 / 64 ชนิดที่เซ็นชื่อซึ่งสามารถวางตัวชี้ได้ ประกาศใน BaseTsd.h เป็น:#if กำหนด(_WIN64) typedef __int64 LONG_PTR; #else พิมพ์def long LONG_PTR;#endif
ลพาราม 32 / 64 ตัวเลือกสำหรับการส่งข้อความ ประกาศใน WinNT.h เป็น: typedef LONG_PTR LPARAM;
ขนาด_T 32 / 64 คล้ายกับประเภท size_t ประกาศใน BaseTsd.h เป็น: typedef ULONG_PTR SIZE_T;
SSIZE_T 32 / 64 คล้ายคลึงกับประเภท ptrdiff_t ประกาศใน BaseTsd.h เป็น: typedef LONG_PTR SSIZE_T;
ULONG_PTR 32 / 64 ชนิดที่ไม่ได้ลงนามที่สามารถเก็บตัวชี้ได้ ประกาศใน BaseTsd.h เป็น:#if Defined(_WIN64) typedef unsigned __int64 ULONG_PTR;#else typedef unsigned long ULONG_PTR;#endif
คำ 16 / 16 ประเภท 16 บิตที่ไม่ได้ลงนาม ประกาศใน WinDef.h เป็น: typedef WORD สั้นที่ไม่ได้ลงนาม;
WPARAM 32 / 64 ตัวเลือกสำหรับการส่งข้อความ ประกาศใน WinDef.h เป็น: typedef UINT_PTR WPARAM;
ตาราง N3 ประเภทที่สนใจเมื่อย้ายโปรแกรม 32 บิตไปยังระบบ Windows 64 บิต หากคุณคิดว่าหลังจากแก้ไขข้อผิดพลาดในการคอมไพล์ทั้งหมดแล้วจะได้รับแอปพลิเคชัน 64 บิตที่รอคอยมานาน คุณจะต้องผิดหวัง ส่วนที่ยากที่สุดยังมาไม่ถึง ในขั้นตอนการคอมไพล์ คุณจะแก้ไขข้อผิดพลาดที่ชัดเจนที่สุดที่คอมไพเลอร์สามารถตรวจพบได้ ซึ่งส่วนใหญ่เกี่ยวข้องกับความเป็นไปไม่ได้ของการคัดเลือกประเภทโดยนัย แต่นี่คือส่วนปลายของภูเขาน้ำแข็ง ข้อผิดพลาดส่วนใหญ่ถูกซ่อนไว้ จากมุมมองของภาษา C++ แบบนามธรรม ข้อผิดพลาดเหล่านี้ดูปลอดภัยหรือถูกปกปิดด้วยการเลือกประเภทที่ชัดเจน มีข้อผิดพลาดดังกล่าวมากกว่าจำนวนข้อผิดพลาดที่ระบุในขั้นตอนการคอมไพล์หลายเท่า

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

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

MyObj* pObj = ... ::SendMessage(hwnd, msg, (WORD)x, (DWORD)pObj);
ในที่นี้มีการใช้ประเภทที่ชัดเจนในการแปลงตัวชี้เป็นประเภทตัวเลข สำหรับสถาปัตยกรรม 32 บิต ตัวอย่างข้างต้นถูกต้อง เนื่องจากพารามิเตอร์สุดท้ายของฟังก์ชัน SendMessage เป็นประเภท LPARAM ซึ่งเหมือนกับ DWORD บนสถาปัตยกรรม 32 บิต สำหรับสถาปัตยกรรม 64 บิต การใช้ DWORD มีข้อผิดพลาด และควรแทนที่ด้วย LPARAM ประเภท LPARAM มีขนาด 32 หรือ 64 บิต ขึ้นอยู่กับสถาปัตยกรรม

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

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

size_t __fread (โมฆะ * __ จำกัด buf, ขนาด size_t, จำนวน size_t, FILE * __ จำกัด fp); size_t fread (โมฆะ * __ จำกัด buf, ขนาด size_t, นับ size_t, FILE * __ จำกัด fp) ( int ret; FLOCKFILE (fp); ret = __fread (buf, ขนาด, นับ, fp); FUNLOCKFILE (fp); return (ret) ; )
ฟังก์ชัน __fread ส่งคืนชนิด size_t แต่ชนิด int ใช้เพื่อจัดเก็บจำนวนไบต์ที่อ่าน ด้วยเหตุนี้ เมื่อมีการอ่านข้อมูลจำนวนมาก ฟังก์ชันจึงอาจส่งคืนจำนวนไบต์ที่แตกต่างจากที่จะอ่านจริง คุณสามารถพูดได้ว่านี่เป็นโค้ดที่ไม่รู้หนังสือสำหรับผู้เริ่มต้น คอมไพลเลอร์จะรายงานประเภทการส่ง และโดยทั่วไปโค้ดดังกล่าวนั้นง่ายต่อการค้นหาและแก้ไข นี่เป็นเรื่องทางทฤษฎี แต่ในชีวิตจริงที่มีโปรเจ็กต์ใหญ่ๆ ทุกอย่างอาจแตกต่างกันได้ ตัวอย่างนี้นำมาจากซอร์สโค้ด FreeBSD ข้อผิดพลาดได้รับการแก้ไขในเดือนธันวาคม 2551 เท่านั้น! แม้ว่า FreeBSD เวอร์ชัน 64 บิตแรก (ทดลอง) จะเปิดตัวในเดือนมิถุนายน พ.ศ. 2546 ก็ตาม นี่คือซอร์สโค้ดก่อนการแก้ไข:

http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/stdio/fread.c?rev=1.14

และนี่คือเวอร์ชันที่แก้ไข (ธันวาคม 2551):

http://www.freebsd.org/cgi/cvsweb.cgi/src/lib/libc/stdio/fread.c?rev=1.15

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

ptrdiff_t SetBitN (ค่า ptrdiff_t, bitNum ที่ไม่ได้ลงนาม) ( ptrdiff_t mask = 1
โค้ดด้านบนใช้งานได้กับสถาปัตยกรรม 32 บิต และอนุญาตให้คุณตั้งค่าบิตที่มีหมายเลข 0 ถึง 31 เป็นหนึ่ง หลังจากโอนโปรแกรมไปยังแพลตฟอร์ม 64 บิตแล้ว จะต้องตั้งค่าบิตตั้งแต่ 0 ถึง 63 แต่รหัสนี้จะไม่ตั้งค่าบิตหมายเลข 32-63 โปรดทราบว่า “1” เป็นประเภท int และเมื่อเลื่อนไป 32 ตำแหน่ง จะเกิดโอเวอร์โฟลว์ ดังแสดงในรูปที่ 5 ไม่ว่าผลลัพธ์จะเป็น 0 (รูปที่ 5-B) หรือ 1 (รูปที่ 5-C) ขึ้นอยู่กับคอมไพเลอร์ การดำเนินการ

รูปที่ 5 A - การติดตั้งบิตที่ 31 ที่ถูกต้องในโค้ด 32 บิต B,C - เกิดข้อผิดพลาดในการตั้งค่าบิต 32 บนระบบ 64 บิต (สองตัวเลือกพฤติกรรม) ในการแก้ไขโค้ด คุณต้องสร้างค่าคงที่ "1" ที่เป็นประเภทเดียวกันกับตัวแปรมาสก์:

หน้ากาก ptrdiff_t = ptrdiff_t(1)
โปรดทราบด้วยว่าโค้ดที่ไม่ได้รับการแก้ไขจะนำไปสู่ข้อผิดพลาดที่น่าสนใจอีกประการหนึ่ง เมื่อตั้งค่า 31 บิตบนระบบ 64 บิต ผลลัพธ์ของฟังก์ชันจะเป็นค่า 0xffffffff80000000 (ดูรูปที่ 6) ผลลัพธ์ของนิพจน์ 1 size_t ArraySize = N * 4; size_t *Array = (size_t *)malloc(ArraySize); ตัวเลขหลักที่ควรดำเนินการด้วยความระมัดระวังเมื่อเปลี่ยนไปใช้แพลตฟอร์ม 64 บิตแสดงไว้ในตาราง N4

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

ขนาด const_t = ...; ถ่าน *อาร์เรย์ = ...; ถ่าน *end = อาร์เรย์ + ขนาด; สำหรับ (ไม่ได้ลงนาม i = 0; i != size; ++i) ( const int one = 1; end[-i - one] = 0; )
ข้อผิดพลาดแรกคือหากขนาดของข้อมูลที่ประมวลผลเกิน 4 กิกะไบต์ (0xFFFFFFFF) การวนซ้ำชั่วนิรันดร์อาจเกิดขึ้นได้ เนื่องจากตัวแปร "i" เป็นประเภท "ไม่ได้ลงนาม" และจะไม่มีวันถึงค่า 0xFFFFFFFF ฉันเขียนโดยเฉพาะว่าเหตุการณ์นี้เป็นไปได้ แต่ก็ไม่จำเป็นต้องเกิดขึ้นเสมอไป ขึ้นอยู่กับโค้ดที่คอมไพเลอร์สร้าง ตัวอย่างเช่น ในโหมดแก้ไขจุดบกพร่อง จะมีการวนซ้ำชั่วนิรันดร์ แต่ในโค้ดที่เผยแพร่ การวนซ้ำจะหายไป ดังนั้นคอมไพลเลอร์จะตัดสินใจปรับโค้ดให้เหมาะสมโดยใช้รีจิสเตอร์ 64 บิตสำหรับตัวนับ และการวนซ้ำจะถูกต้อง ทั้งหมดนี้ทำให้เกิดความสับสน และโค้ดที่ทำงานเมื่อวานนี้อาจหยุดทำงานกะทันหันในวันถัดไป ข้อผิดพลาดที่สองเกี่ยวข้องกับการส่งผ่านอาร์เรย์ตั้งแต่ต้นจนจบซึ่งใช้ค่าดัชนีเชิงลบ โค้ดด้านบนทำงานในโหมด 32 บิต แต่เมื่อรันบนเครื่อง 64 บิต ในการวนซ้ำครั้งแรกสุด อาร์เรย์จะถูกเข้าถึงเกินขอบเขต และโปรแกรมจะหยุดทำงาน ลองดูสาเหตุของพฤติกรรมนี้ ตามกฎภาษา C++ บนระบบ 32 บิต นิพจน์ "-i - one" จะถูกประเมินดังนี้ (ที่ขั้นตอนแรก i = 0):
  1. นิพจน์ "-i" เป็นประเภทที่ไม่ได้ลงนามและมีค่า 0x00000000u
  2. ตัวแปร "หนึ่ง" จะถูกขยายจากประเภท "int" เป็นประเภทที่ไม่ได้ลงชื่อ และจะเท่ากับ 0x00000001u หมายเหตุ: ประเภท int จะถูกขยาย (ตามมาตรฐานภาษา C++) เพื่อพิมพ์ "unsigned" หากมีส่วนร่วมในการดำเนินการที่อาร์กิวเมนต์ที่สองเป็นประเภท unsigned
  3. การดำเนินการลบเกิดขึ้นซึ่งเกี่ยวข้องกับค่าสองประเภทที่ไม่ได้ลงนามและผลลัพธ์ของการดำเนินการคือ 0x00000000u - 0x00000001u = 0xFFFFFFFFu โปรดทราบว่าผลลัพธ์เป็นประเภทที่ไม่ได้ลงนาม
  4. บนระบบ 32 บิต การเข้าถึงอาร์เรย์ที่ดัชนี 0xFFFFFFFFu จะเทียบเท่ากับการใช้ดัชนี -1 นั่นคือจุดสิ้นสุดคล้ายคลึงกับจุดสิ้นสุด[-1] เป็นผลให้องค์ประกอบอาร์เรย์ได้รับการประมวลผลอย่างถูกต้อง
ในระบบ 64 บิตในย่อหน้าสุดท้าย รูปภาพจะแตกต่างออกไป ประเภทที่ไม่ได้ลงนามจะถูกขยายเป็น ptrdiff_t ที่ลงนามแล้ว และดัชนีอาร์เรย์จะเท่ากับ 0x00000000FFFFFFFFi64 เป็นผลให้อาร์เรย์อยู่นอกขอบเขต ในการแก้ไขโค้ด คุณต้องใช้ประเภท เช่น ptrdiff_t และ size_t มีข้อผิดพลาดซึ่งโดยทั่วไปไม่มีใครถูกตำหนิ แต่สิ่งนี้ไม่ได้หยุดพวกเขาจากความผิดพลาด ลองนึกภาพว่าเมื่อนานมาแล้วในกาแล็กซีอันห่างไกล (ใน Visual Studio 6.0) โครงการได้รับการพัฒนาซึ่งมีคลาส CSampleApp ซึ่งเป็นลูกหลานของ CWinApp คลาสพื้นฐานมีฟังก์ชันเสมือนที่เรียกว่า WinHelp ทายาทจะแทนที่ฟังก์ชันนี้และดำเนินการที่จำเป็น นี่คือการนำเสนอด้วยสายตาในรูปที่ 7

รูปที่ 7 การทำงานรหัสที่ถูกต้องที่สร้างขึ้นใน Visual Studio 6.0 จากนั้นโปรเจ็กต์จะถูกโอนไปยัง Visual Studio 2005 ซึ่งต้นแบบของฟังก์ชัน WinHelp เปลี่ยนไป แต่ไม่มีใครสังเกตเห็นสิ่งนี้เนื่องจากในโหมด 32 บิตประเภท DWORD และ DWORD_PTR เหมือนเดิมและโปรแกรมยังทำงานได้อย่างถูกต้อง (รูปที่ 8)

รูปที่ 8 รหัส 32 บิตไม่ถูกต้อง แต่ใช้งานได้ ข้อผิดพลาดกำลังรอปรากฏบนระบบ 64 บิต ซึ่งขนาดของประเภท DWORD และ DWORD_PTR แตกต่างกัน (รูปที่ 9) ปรากฎว่าในโหมด 64 บิต คลาสมีฟังก์ชัน WinHelp ที่แตกต่างกันสองฟังก์ชัน ซึ่งไม่ถูกต้องตามธรรมชาติ โปรดทราบว่ากับดักดังกล่าวสามารถซ่อนได้ไม่เพียงแต่ใน MFC ซึ่งบางฟังก์ชันได้เปลี่ยนประเภทของอาร์กิวเมนต์ แต่ยังอยู่ในโค้ดของแอปพลิเคชันและไลบรารีบุคคลที่สามด้วย

รูปที่ 9 ข้อผิดพลาดปรากฏในโค้ด 64 บิต ตัวอย่างของข้อผิดพลาด 64 บิตที่คล้ายกันสามารถระบุได้ ผู้ที่สนใจข้อผิดพลาดดังกล่าวและต้องการเรียนรู้เพิ่มเติมเกี่ยวกับข้อผิดพลาดเหล่านี้จะสนใจในบทความ “ข้อผิดพลาด 20 ข้อในการย้ายโค้ด C++ ไปยังแพลตฟอร์ม 64 บิต” อย่างที่คุณเห็น ขั้นตอนการค้นหาข้อผิดพลาดที่ซ่อนอยู่นั้นเป็นงานที่ไม่สำคัญ โดยเฉพาะอย่างยิ่งเนื่องจากข้อผิดพลาดส่วนใหญ่จะปรากฏไม่สม่ำเสมอหรือเฉพาะกับข้อมูลอินพุตจำนวนมากเท่านั้น เครื่องวิเคราะห์โค้ดแบบคงที่เหมาะอย่างยิ่งสำหรับการวินิจฉัยข้อผิดพลาดดังกล่าว เนื่องจากสามารถตรวจสอบโค้ดแอปพลิเคชันทั้งหมดได้ โดยไม่คำนึงถึงข้อมูลอินพุตและความถี่ในการดำเนินการของส่วนต่างๆ ในสภาวะจริง ควรใช้การวิเคราะห์แบบคงที่ทั้งในขั้นตอนของการย้ายแอปพลิเคชันไปยังแพลตฟอร์ม 64 บิตเพื่อค้นหาข้อผิดพลาดส่วนใหญ่ในระยะเริ่มแรกและในการพัฒนาโซลูชัน 64 บิตเพิ่มเติม การวิเคราะห์แบบคงที่จะเตือนและสอนโปรแกรมเมอร์ให้เข้าใจคุณสมบัติของข้อผิดพลาดที่เกี่ยวข้องกับสถาปัตยกรรม 64 บิตได้ดีขึ้น และเขียนโค้ดที่มีประสิทธิภาพมากขึ้น ผู้เขียนบทความนี้เป็นผู้พัฒนาหนึ่งในเครื่องมือวิเคราะห์โค้ดพิเศษที่เรียกว่า Viva64 คุณสามารถทำความคุ้นเคยกับเครื่องมือนี้ได้โดยละเอียดและดาวน์โหลดเวอร์ชันสาธิตได้จากเว็บไซต์ของบริษัท Software Verification Systems LLC พูดตามตรง ควรกล่าวว่าเครื่องมือวิเคราะห์โค้ด เช่น Gimpel PC-Lint และ Parasoft C++Test มีชุดกฎสำหรับการวินิจฉัยข้อผิดพลาด 64 บิต แต่ก่อนอื่นสิ่งเหล่านี้เป็นเครื่องมือวิเคราะห์ทั่วไปและกฎสำหรับการวินิจฉัยข้อผิดพลาด 64 บิตนั้นแสดงได้ไม่ดี ประการที่สอง พวกเขามุ่งเน้นไปที่โมเดลข้อมูล LP64 ที่ใช้ในตระกูลระบบปฏิบัติการ Linux มากขึ้น ซึ่งจะลดประโยชน์สำหรับโปรแกรม Windows ที่ใช้โมเดลข้อมูล LLP64 ขั้นตอนการค้นหาข้อผิดพลาดในโค้ดโปรแกรมที่อธิบายไว้ในส่วนก่อนหน้าเป็นขั้นตอนที่จำเป็น แต่ยังไม่เพียงพอ ไม่มีวิธีการใดรวมถึงการวิเคราะห์โค้ดแบบคงที่ที่จะรับประกันการตรวจจับข้อผิดพลาดทั้งหมดได้อย่างสมบูรณ์ และผลลัพธ์ที่ดีที่สุดจะเกิดขึ้นได้ก็ต่อเมื่อผสมผสานเทคนิคต่างๆ เข้าด้วยกันเท่านั้น

หากโปรแกรม 64 บิตของคุณประมวลผลข้อมูลมากกว่าเวอร์ชัน 32 บิต คุณจะต้องขยายการทดสอบเพื่อรวมการประมวลผลข้อมูลที่มีขนาดใหญ่กว่า 4 กิกะไบต์ นี่คือขอบเขตที่ข้อผิดพลาด 64 บิตจำนวนมากเริ่มแสดงออกมา การทดสอบดังกล่าวอาจใช้เวลานานกว่าปกติ และคุณต้องเตรียมตัวให้พร้อมล่วงหน้า โดยทั่วไปการทดสอบจะถูกเขียนขึ้นในลักษณะที่จะประมวลผลองค์ประกอบจำนวนเล็กน้อยในการทดสอบแต่ละครั้ง และด้วยเหตุนี้จึงสามารถผ่านการทดสอบหน่วยภายในทั้งหมดได้ เป็นต้น ภายในไม่กี่นาที และการทดสอบอัตโนมัติ (เช่น การใช้ AutomatedQA TestComplete) ในเวลาไม่กี่ชั่วโมง ฟังก์ชันการเรียงลำดับบนระบบ 32 บิต หากเรียงลำดับองค์ประกอบ 100 รายการ ก็รับประกันได้ว่าจะทำงานได้อย่างถูกต้องกับองค์ประกอบ 100,000 รายการ แต่ฟังก์ชันเดียวกันบนระบบ 64 บิตอาจล้มเหลวเมื่อพยายามประมวลผลองค์ประกอบ 5 พันล้านรายการ ความเร็วการดำเนินการของการทดสอบหน่วยสามารถลดลงได้หลายล้านครั้ง อย่าลืมคำนึงถึงค่าใช้จ่ายในการปรับใช้การทดสอบเมื่อเชี่ยวชาญระบบ 64 บิต วิธีแก้ปัญหาหนึ่งคือแบ่งการทดสอบหน่วยออกเป็นการทดสอบที่รวดเร็ว (ทำงานโดยใช้หน่วยความจำจำนวนเล็กน้อย) และการทดสอบที่ช้า โดยประมวลผลกิกะไบต์และทำงานอยู่ เช่น ในเวลากลางคืน การทดสอบอัตโนมัติของโปรแกรม 64 บิตที่ใช้ทรัพยากรจำนวนมากสามารถสร้างขึ้นบนพื้นฐานของการประมวลผลแบบกระจาย