ผู้สอน: ในบทเรียนนี้
เราจะพูดถึงหน่วยความจำ ECC หรือที่เรียกว่ารหัสการแก้ไขข้อผิดพลาด
แต่ก่อนอื่น เราต้องครอบคลุมแนวคิดของความไม่เท่าเทียมกันและความเท่าเทียมกันในแง่ของหน่วยความจำ
เมื่อเราพูดถึง non-parity นี่คือหน่วยความจำที่เป็นหน่วยความจำมาตรฐาน
มันไม่ตรวจสอบข้อผิดพลาดและอนุญาตให้ใส่หรือนำข้อมูลออกจากหน่วยความจำได้ตามต้องการ
และนี่คือสิ่งที่หน่วยความจำส่วนใหญ่จะเป็น
การผลิตแบบไม่พาริตีมีราคาถูกมาก
และมีความเร็วสูงกว่าหน่วยความจำพาริตี
ในทางกลับกัน หน่วยความจำพาริตีจะถูกใช้เพื่อตรวจสอบข้อผิดพลาดพื้นฐานและเพื่อให้แน่ใจว่าเนื้อหาหน่วยความจำมีความน่าเชื่อถือและมีความสมบูรณ์
ด้วยเหตุนี้ หน่วยความจำนี้จะช้ากว่าหน่วยความจำที่ไม่ใช่พาริตี
แต่มีความน่าเชื่อถือที่จำเป็นสำหรับเซิร์ฟเวอร์และเวิร์กสเตชันเดสก์ท็อประดับไฮเอนด์บางรุ่น
ตอนนี้หน่วยความจำที่มีการตรวจสอบพาริตีจะสามารถทำการคำนวณพื้นฐานตามสิ่งที่เห็นเพื่อตรวจสอบว่าข้อมูลนั้นดีหรือไม่
และถ้าข้อมูลนั้นดีก็จะใช้มัน
และถ้าไม่ใช่ก็จะเกิด Error แต่ไม่สามารถแก้ไขได้
มันสามารถบอกได้ว่ามีข้อผิดพลาดที่นี่ แต่ฉันไม่รู้ว่าจะแก้ไขอย่างไร
โดยพื้นฐานแล้ว มันใช้งานได้โดยให้ทุกไบต์มีแพริตีบิตเชื่อมโยงอยู่
แทนที่จะมี 8 บิต ตอนนี้คุณมี 9 บิต
เพราะข้อมูล 8 บิตบวก 1 บิตสำหรับแพริตี
ตอนนี้พาริตีบิตนั้นจะถูกตั้งค่าในเวลาที่เหมาะสม
จากนั้น มันจะถูกคำนวณและเปรียบเทียบเมื่อคุณอ่านจากหน่วยความจำ
เพื่อพิจารณาว่าบิตใดมีการเปลี่ยนแปลงตั้งแต่ข้อมูลนั้นถูกเขียนลงในหน่วยความจำนั้นครั้งล่าสุดหรือไม่
การตรวจสอบประเภทนี้จำกัดเฉพาะการตรวจหาข้อผิดพลาดบิตเดียวเหล่านั้น
และถ้ามีสองบิตที่ถูกแก้ไข
การตรวจสอบพาริตี้นั้นอาจผ่าน
เพราะจำไว้ บิตสามารถเป็น 0 หรือ 1 เท่านั้น
ตัวอย่างเช่น สมมติว่าฉันเก็บเลข
0 ซึ่งเขียนเป็น 00000000 ในเลขฐานสอง
ตอนนี้ถ้าฉันรวมบิตเหล่านั้นเข้าด้วยกัน ฉันได้
0 แปดตัว ซึ่งให้ 0 สำหรับพาริตีบิตของฉัน
ตอนนี้ถ้าฉันไปอ่านตัวเลขนั้นจากหน่วยความจำแล้วเห็นว่ามี
0 อยู่แปดตัว ฉันบวกมันเข้าด้วยกันแล้วได้ 0 0 จับคู่แพริตีบิตของฉันเป็น
0 ดังนั้นนี่จึงเป็นข้อมูลที่ดี
ในทางกลับกัน
สมมุติว่าผมกำลังเขียนเลข
1 ซึ่งเขียนว่า 00000001
ทีนี้ถ้าผมบวกเลขทั้งหมดเข้าด้วยกัน ผมจะได้ 1
และฉันจะใส่มันในพาริตีบิตของบิตที่เก้า
เมื่อทำสิ่งนี้ ตอนนี้ฉันอ่านจากสิ่งนั้นและฉันได้
00000001
และเนื่องจากทั้งหมดรวมกันเป็น
1 และตรงกับพาริตีบิตของฉัน
ฉันรู้ว่าข้อมูลนั้นดี แต่ถ้าฉันใส่ข้อมูลนั้นลงในหน่วยความจำและมันอยู่ที่นั่นสองสามชั่วโมง
และ 1 นั้นเปลี่ยนเป็น 0 โดยบังเอิญ ถ้าฉันอ่าน ตอนนี้และฉันได้ 00000000
และฉันรวมเข้าด้วยกัน ฉันได้ 0 และเปรียบเทียบมันกับพาริตีบิตซึ่งมี 1 อยู่ในนั้น ซึ่งตอนนี้บอกฉันว่ามีข้อผิดพลาดและมีบางอย่างผิดพลาด
ฉันไม่รู้ว่าแปดบิตใดที่เปลี่ยนไป แต่อย่างน้อยหนึ่งในนั้นมีการเปลี่ยนแปลง
ในทางกลับกัน
ถ้าตัวเลขนั้นจาก
00000001 เปลี่ยนเป็น 01010001 ตอนนี้ฉันมีบิตสองบิตที่เปลี่ยนจาก 0 เป็น 1 โดยไม่ได้ตั้งใจจากหน่วยความจำ
เมื่อฉันดูที่พาริตีของฉัน มันจะยังคงเป็น
1 เพราะเมื่อฉันบวกมัน ถ้ามันเป็นเลขคี่ มันจะเป็น
1 สำหรับพาริตีบิตของฉัน
และถ้าผมบวกมันแล้วมันเป็นเลขคู่
มันจะเป็น 0
อย่างที่คุณเห็น คุณจะไม่สามารถตรวจจับข้อผิดพลาดได้หากมีการเปลี่ยนแปลงสองบิตภายในสิ่งนี้
หากคุณใช้การคำนวณประเภทพาริตี
ข่าวดีก็คือประมาณ 90% ของข้อผิดพลาดส่วนใหญ่จะเป็นข้อผิดพลาดประเภทบิตเดียว
ดังนั้นการตรวจสอบพาริตีจึงเพียงพอสำหรับสถานการณ์ส่วนใหญ่ของเรา
แต่ถ้าคุณต้องรับมือกับบางอย่าง
เช่น การรันเซิร์ฟเวอร์สำหรับธนาคาร การมีข้อผิดพลาดใดๆ
ก็ตามอาจเป็นสิ่งที่ไม่ดี
ดังนั้นเราจึงต้องการสิ่งที่ดีกว่าความเท่าเทียมกัน
และนั่นคือสิ่งที่ ECC เข้ามามีบทบาท
ตอนนี้ ECC ย่อมาจาก Error Correcting Code
รหัสแก้ไขข้อผิดพลาดคือประเภทของหน่วยความจำที่นำพาริตีขึ้นไปอีกระดับ
ตอนนี้ไม่เพียงแต่ตรวจจับว่ามีข้อผิดพลาดได้
เช่นเดียวกับที่พาริตีทำได้
แต่ยังสามารถแก้ไขข้อผิดพลาดนั้นให้คุณได้ด้วย
ตอนนี้ ECC ช้ากว่า parity เล็กน้อยซึ่งช้ากว่า
non-parity ด้วย
ดังนั้นคุณจึงสูญเสียประสิทธิภาพบางอย่างสำหรับความสามารถพิเศษนี้
แต่คุณได้รับความสมบูรณ์และความน่าเชื่อถือที่สูงขึ้นจากหน่วยความจำของคุณเมื่อคุณใช้
ECC เนื่องจากจะสามารถตรวจจับข้อผิดพลาดเหล่านั้นและแก้ไขข้อผิดพลาดเหล่านั้นได้
โดยทั่วไป คุณจะเห็นเฉพาะ ECC หรือรหัสแก้ไขข้อผิดพลาดที่ใช้ในเวิร์กสเตชันหรือเซิร์ฟเวอร์ระดับไฮเอนด์จริงๆ
เนื่องจากมีค่าใช้จ่ายเพิ่มเติมและความสมบูรณ์ระดับสูงเป็นพิเศษนั้นจำเป็นเฉพาะในสภาพแวดล้อมประเภทเหล่านั้นเท่านั้น
ตอนนี้คุณอาจสงสัยว่า
ECC ระบุได้อย่างไรว่ามีอะไรผิดปกติและจะแก้ไขได้อย่างไร
ในการทำเช่นนั้น มันจะใช้สิ่งที่เรียกว่าหน่วยความจำบัฟเฟอร์หรือการลงทะเบียน
ตอนนี้หน่วยความจำบัฟเฟอร์หรือหน่วยความจำที่ลงทะเบียนมีฮาร์ดแวร์เพิ่มเติมที่จะนั่งระหว่างหน่วยความจำกับ
CPU หรือโปรเซสเซอร์ของคุณ
ฮาร์ดแวร์นี้เรียกว่ารีจิสเตอร์และเก็บข้อมูลไปยังบัฟเฟอร์ก่อนที่จะถูกส่งไปยังซีพียู
คุณสมบัตินี้ใช้เป็นมาตรวัดความน่าเชื่อถือในระบบจำนวนมาก
โดยเฉพาะระบบเช่นเซิร์ฟเวอร์ที่มีโมดูลหน่วยความจำที่แตกต่างกันจำนวนมากซึ่งอาจเกิดข้อผิดพลาดได้
ระบบเหล่านี้ต้องการบัฟเฟอร์หรือลงทะเบียนข้อมูลเพื่อลดภาระทางไฟฟ้าที่ใช้โดยระบบเหล่านี้ที่มีโมดูลหน่วยความจำจำนวนมาก
และสิ่งนี้สามารถจับคู่กับพาริตีหรือหน่วยความจำรหัสแก้ไขข้อผิดพลาดเพื่อให้สามารถให้ความน่าเชื่อถือเพิ่มเติมแก่คุณได้ คุณกำลังมองหาและตรวจพบข้อผิดพลาดเหล่านั้น
ตอนนี้ เพื่อใช้โมดูลรหัสแก้ไขข้อผิดพลาด
เมนบอร์ดของคุณต้องรองรับเช่นเดียวกับ CPU ของคุณ
หากส่วนประกอบเหล่านั้นไม่รองรับ ECC แม้ว่าคุณจะซื้อโมดูล
ECC ซึ่งมีราคาสูงกว่า คุณจะไม่ได้รับสิทธิประโยชน์เพิ่มเติมของ
ECC นั้น
ดังนั้นโปรดระลึกไว้เสมอว่า
เมนบอร์ดส่วนใหญ่รองรับ ECC หรือไม่รองรับ
มันไม่ใช่ตัวเลือกโดยทั่วไป
ดังนั้น หากคุณซื้อเมนบอร์ดที่รองรับ
ECC คุณจะต้องซื้อโมดูล ECC ซึ่งเป็นโมดูลหน่วยความจำที่ลงทะเบียนไว้
ตอนนี้หากคุณพบเมนบอร์ดที่รองรับโมดูล
ECC หรือที่ไม่ใช่ ECC โดยทั่วไปแล้วจะไม่รองรับทั้งสองอย่างพร้อมกัน
ดังนั้นโมดูลทั้งหมดของคุณจะต้องเป็น ECC หรือไม่มีโมดูลใดเลยที่สามารถเป็น
ECC ได้
การมีส่วนผสมเหล่านี้อาจทำให้เกิดข้อผิดพลาดในระบบและเมนบอร์ดจะไม่ทราบวิธีจัดการ
สิ่งสุดท้ายที่ฉันอยากจะพูดถึงก็คือ
หากคุณใช้ DDR5 อยู่ DDR5 จะมีข้อผิดพลาดบางอย่างในการตรวจสอบภายในตัวโมดูลเอง
ไม่ถือว่าเป็น ECC หรือโมดูล ECC
ดังนั้นการแก้ไขข้อผิดพลาดนี้ภายในโมดูล
DDR5 รุ่นใหม่จึงสามารถใช้กับเมนบอร์ดที่ไม่สนับสนุน
ECC และคุณจะยังมีความสามารถในการตรวจสอบข้อผิดพลาดอยู่บ้าง
นี่คือการตรวจสอบข้อผิดพลาดรูปแบบอื่น
และไม่ถือว่าเป็นรหัสแก้ไขข้อผิดพลาด
ดังนั้นจำไว้และอย่าให้สิ่งนั้นทำให้คุณสับสนเมื่อคุณอยู่ในสนาม
นี่เป็นรูปแบบการตรวจสอบข้อผิดพลาดที่แตกต่างกัน
และโมดูล DDR5 ยังคงสามารถขายเป็นโมดูล ECC
หรือไม่ใช่ ECC ได้ เนื่องจากนอกเหนือจากการตรวจสอบข้อผิดพลาดภายในแล้ว โมดูลเหล่านี้ยังสามารถทำงานร่วมกับ
CPU และเมนบอร์ดได้หากสนับสนุน ECC ตอนนี้รหัสแก้ไขข้อผิดพลาดเช่นกัน
ฉันรู้ว่ามันทำให้สับสนเล็กน้อย
ดังนั้นจงตระหนักไว้เสมอเมื่อคุณออกไปภาคสนาม