ดังนั้นนี่ไม่ใช่ค่าใช้จ่ายหน่วยความจำ?
ใช่ .... ไม่ ... อาจจะ?
นี่เป็นคำถามที่น่าอึดอัดใจเพราะจินตนาการถึงช่วงที่อยู่หน่วยความจำบนเครื่องและซอฟต์แวร์ที่ต้องติดตามสิ่งที่อยู่ในหน่วยความจำอย่างต่อเนื่องซึ่งไม่สามารถผูกกับสแต็กได้
ตัวอย่างเช่นลองจินตนาการถึงเครื่องเล่นเพลงที่มีการโหลดไฟล์เพลงด้วยการกดปุ่มโดยผู้ใช้และยกเลิกการโหลดจากหน่วยความจำที่ระเหยได้เมื่อผู้ใช้พยายามโหลดไฟล์เพลงอื่น
เราจะติดตามตำแหน่งที่จัดเก็บข้อมูลเสียงได้อย่างไร เราต้องการที่อยู่หน่วยความจำ โปรแกรมไม่เพียง แต่ต้องติดตามข้อมูลเสียงในหน่วยความจำ แต่ยังอยู่ในหน่วยความจำ ดังนั้นเราต้องเก็บที่อยู่หน่วยความจำไว้ (เช่นตัวชี้) และขนาดของที่เก็บข้อมูลที่จำเป็นสำหรับที่อยู่หน่วยความจำจะตรงกับช่วงที่อยู่ของเครื่อง (เช่นตัวชี้ 64 บิตสำหรับช่วงที่อยู่ 64 บิต)
ดังนั้นมันจึงเป็น "ใช่" มันต้องการหน่วยเก็บข้อมูลในการติดตามที่อยู่หน่วยความจำ แต่ไม่ใช่ว่าเราสามารถหลีกเลี่ยงได้สำหรับหน่วยความจำที่จัดสรรแบบไดนามิกในประเภทนี้
สิ่งนี้ได้รับการชดเชยอย่างไร?
เมื่อพูดถึงขนาดของตัวชี้คุณสามารถหลีกเลี่ยงค่าใช้จ่ายในบางกรณีโดยการใช้สแต็คเช่นในกรณีนั้นคอมไพเลอร์สามารถสร้างคำสั่งที่มีประสิทธิภาพอย่างหนักรหัสที่อยู่หน่วยความจำแบบสัมพัทธ์หลีกเลี่ยงต้นทุนของตัวชี้ แต่สิ่งนี้ทำให้คุณมีความเสี่ยงที่จะสแต็คโอเวอร์โฟลว์หากคุณทำเช่นนี้สำหรับการจัดสรรขนาดใหญ่และขนาดตัวแปรและยังมีแนวโน้มที่จะทำไม่ได้ (หากไม่สามารถทำได้) ที่จะทำสำหรับซีรีส์สาขาที่ซับซ้อน ข้างบน).
อีกวิธีหนึ่งคือการใช้โครงสร้างข้อมูลที่ต่อเนื่องกันมากขึ้น ตัวอย่างเช่นลำดับตามอาร์เรย์อาจใช้แทนรายการที่ลิงก์สองเท่าซึ่งต้องใช้สองพอยน์เตอร์ต่อโหนด นอกจากนี้เรายังสามารถใช้ไฮบริดของทั้งสองนี้เป็นรายการที่ไม่ได้ควบคุมซึ่งจะเก็บเฉพาะพอยน์เตอร์ในระหว่างองค์ประกอบ N ที่ต่อเนื่องกันทุกกลุ่ม
พอยน์เตอร์ใช้ในเวลาที่แอปพลิเคชันหน่วยความจำเหลือน้อยหรือไม่?
ใช่โดยทั่วไปแล้วแอปพลิเคชั่นที่มีความสำคัญต่อประสิทธิภาพจะถูกเขียนใน C หรือ C ++ ซึ่งควบคุมโดยการใช้ตัวชี้ (อาจอยู่หลังตัวชี้สมาร์ทหรือคอนเทนเนอร์เช่นstd::vectorหรือstd::stringแต่กลไกพื้นฐานนั้นต้มลงไปถึงตัวชี้ที่ใช้ เพื่อติดตามที่อยู่ไปยังบล็อกหน่วยความจำแบบไดนามิก)
กลับไปที่คำถามนี้:
สิ่งนี้ได้รับการชดเชยอย่างไร? (ตอนที่สอง)
ตัวชี้มักจะสกปรกราคาถูกเว้นแต่ว่าคุณจัดเก็บเหมือนล้านคน (ซึ่งยังคงเป็น * 8 เมกะไบต์บนเครื่อง 64 บิต)
* โปรดสังเกตว่าเบ็นชี้ให้เห็นว่า "ความเลว" 8 เมกกะพิกเซลยังคงเป็นขนาดของแคช L3 ที่นี่ฉันใช้ "เลวร้ายยิ่ง" ในแง่ของการใช้ DRAM ทั้งหมดและขนาดสัมพัทธ์โดยทั่วไปของหน่วยความจำจะมีการใช้งานพอยน์เตอร์ที่มีสุขภาพดี
ในกรณีที่ตัวชี้ราคาแพงไม่ใช่ตัวชี้ แต่:
การจัดสรรหน่วยความจำแบบไดนามิก การจัดสรรหน่วยความจำแบบไดนามิกมีแนวโน้มที่จะมีค่าใช้จ่ายสูงเนื่องจากต้องผ่านโครงสร้างข้อมูลพื้นฐาน (เช่นตัวจัดสรรบัดดี้หรือแผ่นพื้น) แม้ว่าสิ่งเหล่านี้มักจะถูกปรับให้เหมาะกับความตาย แต่ก็มีจุดประสงค์ทั่วไปและออกแบบมาเพื่อจัดการบล็อกขนาดแปรปรวนที่ต้องการให้พวกเขาทำงานอย่างน้อยคล้ายกับ "ค้นหา" (แม้ว่าจะมีน้ำหนักเบาและอาจเป็นเวลาคงที่) ค้นหาชุดของหน้าต่อเนื่องฟรีในหน่วยความจำ
การเข้าถึงหน่วยความจำ นี่เป็นค่าใช้จ่ายที่ใหญ่กว่าที่จะต้องกังวล เมื่อใดก็ตามที่เราเข้าถึงหน่วยความจำที่จัดสรรแบบไดนามิกเป็นครั้งแรกมีข้อผิดพลาดในหน้าบังคับเช่นเดียวกับแคชคิดถึงการย้ายหน่วยความจำลงตามลำดับชั้นของหน่วยความจำและลงทะเบียน
การเข้าถึงหน่วยความจำ
การเข้าถึงหน่วยความจำเป็นหนึ่งในส่วนที่สำคัญที่สุดของประสิทธิภาพนอกเหนือจากอัลกอริทึม เขตข้อมูลที่มีประสิทธิภาพสูงเช่นเอนจิ้นเกม AAA มุ่งเน้นไปที่พลังงานที่มีต่อการปรับแต่งข้อมูลให้เหมาะสมซึ่งจะทำให้รูปแบบและการเข้าถึงหน่วยความจำมีประสิทธิภาพมากขึ้น
หนึ่งในปัญหาประสิทธิภาพที่ใหญ่ที่สุดของภาษาระดับสูงที่ต้องการจัดสรรแต่ละประเภทที่ผู้ใช้กำหนดแยกต่างหากผ่านตัวรวบรวมขยะเช่นพวกเขาสามารถแยกส่วนหน่วยความจำได้ค่อนข้างน้อย นี่อาจเป็นจริงโดยเฉพาะอย่างยิ่งหากไม่จัดสรรวัตถุทั้งหมดในคราวเดียว
ในกรณีดังกล่าวถ้าคุณเก็บรายการของวัตถุที่กำหนดโดยผู้ใช้หลายล้านรายการการเข้าถึงอินสแตนซ์เหล่านั้นเรียงตามลำดับในลูปอาจค่อนข้างช้าเนื่องจากคล้ายกับรายการล้านพอยน์เตอร์ ในกรณีดังกล่าวสถาปัตยกรรมต้องการดึงหน่วยความจำจากส่วนบน, ช้าลงและใหญ่ขึ้นของลำดับชั้นในกลุ่มก้อนขนาดใหญ่ที่เรียงกันด้วยความหวังว่าข้อมูลรอบข้างในกลุ่มเหล่านั้นจะถูกเข้าถึงก่อนที่จะถูกไล่ออก เมื่อแต่ละวัตถุในรายการดังกล่าวได้รับการจัดสรรแยกกันบ่อยครั้งเรามักจะจ่ายเงินให้กับมันด้วยแคชที่หายไปเมื่อแต่ละการทำซ้ำในภายหลังอาจต้องโหลดจากพื้นที่ที่แตกต่างกันอย่างสมบูรณ์ในหน่วยความจำโดยไม่มีวัตถุที่อยู่ติดกัน
คอมไพเลอร์จำนวนมากสำหรับภาษาดังกล่าวกำลังทำงานได้อย่างยอดเยี่ยมในทุกวันนี้ที่การเลือกคำสั่งและการจัดสรรการลงทะเบียน แต่การขาดการควบคุมโดยตรงมากกว่าการจัดการหน่วยความจำที่นี่สามารถเป็นนักฆ่า (แม้ว่ามักจะผิดพลาดน้อยกว่า) C และ C ++ ค่อนข้างเป็นที่นิยม
การเพิ่มประสิทธิภาพการเข้าถึงตัวชี้โดยทางอ้อม
ในสถานการณ์ที่มีประสิทธิภาพมากที่สุดแอปพลิเคชันมักจะใช้พูลหน่วยความจำซึ่งพูลหน่วยความจำจากกลุ่มที่ต่อเนื่องกันเพื่อปรับปรุงตำแหน่งอ้างอิง ในกรณีเช่นนี้แม้โครงสร้างที่เชื่อมโยงเช่นต้นไม้หรือรายการที่เชื่อมโยงสามารถทำแคชได้โดยง่ายหากรูปแบบหน่วยความจำของโหนดนั้นต่อเนื่องกันตามธรรมชาติ สิ่งนี้กำลังทำให้ตัวชี้การลดราคาถูกลงอย่างมีประสิทธิภาพแม้ว่าจะเป็นทางอ้อมโดยการปรับปรุงท้องถิ่นของการอ้างอิงที่เกี่ยวข้องเมื่อทำการยกเลิกการอ้างอิง
พอยน์เตอร์ไล่ตามสถานที่ต่างๆ
สมมติว่าเรามีรายการที่เชื่อมโยงเดี่ยว:
Foo->Bar->Baz->null
ปัญหาคือว่าถ้าเราจัดสรรโหนดเหล่านี้ทั้งหมดแยกจากกันกับตัวจัดสรรวัตถุประสงค์ทั่วไป (และอาจไม่ทั้งหมดในคราวเดียว) หน่วยความจำจริงอาจจะกระจายไปในลักษณะนี้ (แผนภาพง่าย):
เมื่อเราเริ่มไล่ตามพอยน์เตอร์และเข้าถึงFooโหนดเราเริ่มต้นด้วยการบังคับพลาด (และอาจเป็นความผิดพลาดของหน้า) การย้ายอันจากพื้นที่หน่วยความจำจากพื้นที่หน่วยความจำช้าลงไปสู่พื้นที่หน่วยความจำที่เร็วขึ้นเช่น:
สิ่งนี้ทำให้เราแคช (อาจเป็นหน้า) พื้นที่หน่วยความจำเท่านั้นเพื่อเข้าถึงส่วนหนึ่งของมันและขับไล่ส่วนที่เหลือเมื่อเราไล่ล่าพอยน์เตอร์รอบรายการนี้ อย่างไรก็ตามโดยการควบคุมตัวจัดสรรหน่วยความจำอย่างไรก็ตามเราสามารถจัดสรรรายการดังกล่าวได้อย่างต่อเนื่องเช่น:
... และด้วยเหตุนี้จึงปรับปรุงความเร็วที่เราสามารถตรวจสอบพอยน์เตอร์และประมวลผลคะแนนของพวกเขาได้อย่างมีนัยสำคัญ ดังนั้นแม้ว่าจะเป็นทางอ้อมมากเราสามารถเร่งความเร็วการเข้าถึงตัวชี้ได้ด้วยวิธีนี้ แน่นอนถ้าเราเพิ่งเก็บสิ่งเหล่านี้อย่างต่อเนื่องในอาเรย์เราจะไม่พบปัญหานี้ในตอนแรก แต่ตัวจัดสรรหน่วยความจำที่นี่ทำให้เราสามารถควบคุมเลย์เอาต์ของหน่วยความจำอย่างชัดเจนสามารถบันทึกวันเมื่อต้องการโครงสร้างที่เชื่อมโยง
* หมายเหตุ: นี่เป็นไดอะแกรมที่มีความซับซ้อนมากและการอภิปรายเกี่ยวกับลำดับชั้นหน่วยความจำและสถานที่อ้างอิง แต่หวังว่ามันจะเหมาะสมสำหรับระดับของคำถาม