CPU - การไหลของข้อมูลหน่วยความจำ GPU [ปิด]

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

• ข้อมูลส่งไปยังหน่วยความจำ GPU เพียงครั้งเดียวและนั่งอยู่ที่นั่นตลอดไปหรือไม่?
• เมื่อแบบจำลองได้รับการแสดงผลจริงในแต่ละเฟรมแล้วตัวประมวลผล GPU ต้องดึงข้อมูลทุกครั้งจากหน่วยความจำ GPU หรือไม่ สิ่งที่ฉันหมายถึงคือ - ถ้าฉันมี 2 แบบจำลองที่แสดงหลายครั้งในแต่ละครั้ง - มันจะสำคัญไหมถ้าฉันแสดงครั้งแรกทีละหลายครั้งและอีกอันที่สองหลายครั้งหรือถ้าฉันแสดงครั้งแรกเพียงครั้งเดียว interleaving มันแบบนั้นเหรอ? ฉันสามารถเรียกคำถามนี้ว่า "การไหลของข้อมูล GPU ภายใน" ในแง่นี้
• เห็นได้ชัดว่าการ์ดกราฟิกมี RAM จำกัด - เมื่อมันไม่สามารถเก็บข้อมูลโมเดลทั้งหมดที่จำเป็นสำหรับการเรนเดอร์ 1 เฟรมฉันคิดว่ามันดึงข้อมูล (บางส่วน) จาก CPU RAM แต่ละเฟรมมาถูกต้องหรือไม่

ฉันรู้ว่ามีหนังสือและสิ่งต่าง ๆ มากมายเกี่ยวกับสิ่งนี้บนอินเทอร์เน็ต แต่บางทีคุณอาจมีแนวทางทั่วไปอย่างรวดเร็วเกี่ยวกับวิธีการจัดการการไหลของข้อมูลนี้

แก้ไข: ฉันลืมที่จะทำให้หนึ่งความแตกต่าง: มีการส่งข้อมูลกับ GPUและมีการตั้งค่า / ผลผูกพันบัฟเฟอร์เป็นปัจจุบัน หลังทำให้เกิดการไหลของข้อมูลใด ๆ ?

แก้ไข 2: หลังจากอ่านโพสต์ของ Raxvan ฉันต้องการแยกการกระทำบางอย่าง:

• การสร้างบัฟเฟอร์ด้วยการเริ่มต้น (ตามที่เขาบอกว่าฉันสามารถเก็บข้อมูลใน CPU ram หรือ GPU หนึ่ง)
• การอัปเดตข้อมูลบัฟเฟอร์ (ซึ่งฉันเชื่อว่าตรงไปตรงมาเมื่อข้อมูลถูกเก็บไว้ใน CPU ram และต้องดึงข้อมูลจาก GPU ไปยัง CPU ram (แล้วย้อนกลับ) เมื่อเก็บไว้ใน GPU ram)
• ผูกบัฟเฟอร์เป็น active (เป็นเพียงวิธีบอก API ว่าฉันต้องการให้บัฟเฟอร์นี้ถูกเรนเดอร์ในการเรียกใช้ครั้งถัดไปและมันไม่ได้ทำอะไรด้วยตัวเองหรือไม่?)
• API การเรียกแบบดึง (ที่นี่ฉันอยากได้ยินจากคุณว่าเกิดอะไรขึ้นที่นั่นจริง ๆ )

ข้อมูลส่งไปยังหน่วยความจำ GPU เพียงครั้งเดียวและนั่งอยู่ที่นั่นตลอดไปหรือไม่?

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

ตัวอย่างเช่นหากถูกตั้งค่าสถานะเป็นบัฟเฟอร์ openGL แบบไดนามิก (เช่น VBO) มีแนวโน้มที่จะถูกเก็บไว้ใน RAM GPU ใช้การเข้าถึงหน่วยความจำโดยตรง (DMA) เพื่อเข้าถึง ram โดยตรงโดยไม่ต้องมีการแทรกแซงจาก CPU นี่คือการควบคุมโดยคอนโทรลเลอร์ DMA ในกราฟิกการ์ดและไดรเวอร์กราฟิกและดำเนินการในโหมดเคอร์เนล

เมื่อแบบจำลองได้รับการแสดงผลจริงในแต่ละเฟรมแล้วตัวประมวลผล GPU จะต้องดึงข้อมูลในแต่ละครั้งจากหน่วยความจำ GPU แม้ว่ารูปแบบจะแสดงผลหลายครั้งหรือไม่

เช่นเดียวกับ CPU GPUs ได้รับอนุญาตให้สั่งซื้อ GPU อีกครั้งและดำเนินการเข้าถึงหน่วยความจำ (อ่าน: ดำเนินการตามคำสั่ง ) ดังนั้น GPU ส่วนใหญ่จะจัดการกับสถานการณ์ที่คุณกล่าวถึงโดยการเข้าถึงหน่วยความจำที่อยู่ในแคช ) แต่บางครั้งก็ทำไม่ได้

เห็นได้ชัดว่าการ์ดกราฟิกมี RAM จำกัด - เมื่อมันไม่สามารถเก็บข้อมูลโมเดลทั้งหมดที่จำเป็นสำหรับการเรนเดอร์ 1 เฟรมฉันคิดว่ามันดึงข้อมูล (บางส่วน) จาก CPU RAM แต่ละเฟรมมาถูกต้องหรือไม่

คุณไม่ต้องการให้สิ่งนี้เกิดขึ้น แต่ไม่ว่าจะเกิดอะไรขึ้น GPU จะเริ่มย้ายหน่วยความจำระหว่าง RAM และ VRAM (ตัวประมวลผลคำสั่งบน GPU เป็นผู้รับผิดชอบสิ่งนี้) ซึ่งจะทำให้การแสดงผลช้าลงมากซึ่งจะทำให้ GPU หยุดทำงานเพราะจะต้องรอข้อมูล ที่จะคัดลอกจาก / ถึง V / RAM

มีการส่งข้อมูลไปยัง GPU และมีการตั้งค่า / เชื่อมบัฟเฟอร์เป็นปัจจุบัน หลังทำให้เกิดการไหลของข้อมูลใด ๆ ?

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

นั่นเป็นหนึ่งในเหตุผลที่ glBegin / glEnd เลิกใช้แล้วการส่งคำสั่งใหม่จำเป็นต้องมีการซิงโครไนซ์คิว (โดยใช้รั้ว / อุปสรรคหน่วยความจำ)

สำหรับประเด็นอื่น ๆ ของคุณ:

การสร้างบัฟเฟอร์ด้วยการเริ่มต้น

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

การอัพเดตข้อมูลบัฟเฟอร์

คุณสามารถใช้ glMapBuffer เพื่ออัปเดตหน่วยความจำทางด้าน GPU ไม่ว่าหน่วยความจำจะถูกคัดลอกจาก / ถึง RAM ไม่ใช่ poart ของมาตรฐานจริงหรือไม่และจะแตกต่างกันอย่างมากขึ้นอยู่กับผู้ขายประเภท GPU และไดรเวอร์

API การเรียกแบบดึง (ที่นี่ฉันอยากได้ยินจากคุณว่าเกิดอะไรขึ้นที่นั่นจริง ๆ )

ประเด็นที่สองของฉันในคำถามหลักครอบคลุมถึงเรื่องนี้

ผูกบัฟเฟอร์ขณะที่ใช้งานอยู่ (เป็นเพียงวิธีบอก API ว่าฉันต้องการให้บัฟเฟอร์นี้ถูกเรนเดอร์ในการเรียกใช้ครั้งถัดไปและไม่ได้ทำอะไรด้วยตัวเองหรือไม่)

คิดว่าการผูกเป็นการใช้thisตัวชี้ในภาษาเชิงวัตถุใด ๆ แม้ว่าจะไม่เหมือนกันอย่างเคร่งครัดการเรียก API ที่ตามมาใด ๆ จะสัมพันธ์กับบัฟเฟอร์การเชื่อมโยงนั้น

โดยทั่วไปแล้วขอบเขตและการมีส่วนร่วมของซีพียูกับ GPU นั้นเฉพาะในแพลตฟอร์ม แต่ส่วนใหญ่จะใช้ซีพียูรุ่นนี้: ซีพียูมี ram บ้าง, gpu และคุณสามารถย้ายหน่วยความจำไปรอบ ๆ ได้ (ในบางกรณีแรมใช้ร่วมกัน แต่สำหรับ เพราะความเรียบง่ายมาแยกแรมส์กัน)

จุดแรก : ข้อมูลที่คุณกำหนดค่าเริ่มต้นคุณสามารถเลือกเก็บไว้ใน CPU ram หรือ GPU ram และข้อดีสำหรับทั้งคู่ เมื่อคุณแสดงบางสิ่งบางอย่าง GPU ต้องทำการยกอย่างหนักดังนั้นจึงเป็นที่ชัดเจนว่าข้อมูลที่อยู่ในหน่วยความจำ GPU นั้นจะให้ประสิทธิภาพที่ดีขึ้น สำหรับซีพียูนั้นจะต้องส่งข้อมูลไปยัง GPU ก่อน (ซึ่งสามารถเลือกที่จะเก็บไว้ซักครู่) จากนั้นจึงทำการเรนเดอร์

จุดที่สอง : มีกลอุบายมากมายในการเรนเดอร์ แต่วิธีหลักที่ทำได้คือการใช้รูปหลายเหลี่ยม บนเฟรม gpu จะแสดงวัตถุที่ทำจากรูปหลายเหลี่ยมทีละหนึ่งและหลังจากเสร็จสิ้นการที่ GPU จะส่งภาพไปยังจอแสดงผล ไม่มีแนวคิดเช่นวัตถุมีรูปหลายเหลี่ยมเพียงอย่างเดียวและวิธีที่คุณรวมเข้าด้วยกันจะสร้างภาพ หน้าที่ของ GPU คือการฉายรูปหลายเหลี่ยมเหล่านั้นตั้งแต่ 3d ถึง 2d และใช้เอฟเฟกต์ (ถ้าต้องการ) รูปหลายเหลี่ยมไปทางเดียวกับ CPU-> GPU-> SCREEN หรือ GPU-> SCREEN โดยตรง (หากรูปหลายเหลี่ยมอยู่ใน RAM GPU แล้ว)

จุดที่สาม : เมื่อคุณสร้างภาพเคลื่อนไหวตัวอย่างเช่นจะเป็นการดีกว่าที่จะเก็บข้อมูลไว้ใกล้กับ cpu เพราะที่นั่นเขายกของหนักขึ้นมามันจะไม่เหมาะสมที่สุดในการเก็บข้อมูลใน GPU ย้ายมันไปที่ CPU และสำรองทุกเฟรม มีตัวอย่างอื่น ๆ อีกมากมายเช่นนี้ที่จะนับ แต่โดยทั่วไปข้อมูลทั้งหมดจะอยู่ใกล้กับผู้ที่กำลังทำการคำนวณ โดยปกติแล้วคุณต้องการย้ายข้อมูลให้มากที่สุดเท่าที่จะเป็นไปได้กับหน่วยความจำ GPU เพื่อเพิ่มประสิทธิภาพ

การส่งข้อมูลไปยัง gpu จริงนั้นทำโดย API ที่คุณใช้ (directx / opengl หรืออื่น ๆ ) และแนวคิดของการเชื่อมโยงและสิ่งต่าง ๆ เช่นนี้เป็นเพียงนามธรรมเพื่อให้ API เข้าใจสิ่งที่คุณต้องการทำ

แก้ไขเพื่อการแก้ไข:

• buffer creation with initialisation: มันเหมือนกับความแตกต่างระหว่าง int a = new int[10]และa[0] = 0,a[1] = 1.... etc เมื่อคุณสร้างบัฟเฟอร์คุณสร้างพื้นที่สำหรับข้อมูลและเมื่อคุณเริ่มต้นข้อมูลที่คุณใส่สิ่งที่คุณต้องการในนั้น

• buffer data updateถ้ามันอยู่บน cpu ram คุณก็vertex * verticesสามารถเล่นกับมันได้ถ้ามันไม่อยู่คุณจะต้องย้ายมันจาก GPU vertex * vertices = map(buffer_id);(แผนที่เป็นฟังก์ชั่นในตำนานที่ควรย้ายข้อมูลจาก GPU ไปยัง CPU ram มันยังมี oposite อยู่buffer_id = create_buffer(vertices);

• binding the buffer as activeมันเป็นแค่แนวคิดที่พวกเขาเรียกว่าbindingการเรนเดอร์เป็นกระบวนการที่ซับซ้อนและมันก็เหมือนกับการเรียกฟังก์ชั่นที่มีพารามิเตอร์ 10,000 ตัว การผูกเป็นเพียงคำที่พวกเขาใช้สำหรับบอกบัฟเฟอร์ที่จะไปไหน ไม่มีเวทย์มนตร์ที่แท้จริงอยู่เบื้องหลังเทอมนี้มันไม่แปลงหรือย้ายหรือจัดสรรบัฟเฟอร์ใหม่เพียงแค่บอกคนขับว่าในการเรียกใช้ครั้งต่อไปจะใช้บัฟเฟอร์นี้

• API draw callหลังจากที่มีผลผูกพันและการตั้งค่าบัฟเฟอร์ที่นี่เป็นสถานที่ที่ยางตรงตามถนน การเรียกการดึงข้อมูลจะนำข้อมูลทั้งหมด (หรือรหัสที่ชี้ไปยังข้อมูล) ที่คุณระบุส่งไปยัง GPU (หากจำเป็น) และแจ้งให้ GPU ทราบว่าจะเริ่มบีบตัวเลข สิ่งนี้ไม่เป็นความจริงอย่างสิ้นเชิงในทุกแพลตฟอร์มที่มีความแตกต่างมากมาย แต่สำหรับการทำให้ง่ายขึ้นการวาดจะบอก GPU ให้ทราบ .... การวาด

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

ข้อมูลส่งไปยังหน่วยความจำ GPU เพียงครั้งเดียวและนั่งอยู่ที่นั่นตลอดไปหรือไม่?

หวังว่าใช่ สำหรับความเร็วในการเรนเดอร์คุณต้องการให้มีข้อมูลมากพอที่จะนั่งบน GPU เท่าที่จะทำได้แทนที่จะส่งไปทุกเฟรม VBO ใช้เพื่อจุดประสงค์ที่แน่นอนนี้ มีทั้งแบบคงที่และแบบไดนามิก VBO's แบบดั้งเดิมเป็นแบบที่ดีที่สุดสำหรับแบบคงที่และแบบหลังเป็นแบบที่ดีที่สุดสำหรับแบบจำลองที่จุดยอดจะเปลี่ยนทุกเฟรม (พูดระบบอนุภาค) แม้ว่ามันจะเป็น VBO แบบไดนามิก แต่คุณไม่ต้องการส่งจุดยอดทั้งหมดใหม่ทุกเฟรม คนที่กำลังเปลี่ยนแปลง

ในกรณีของสิ่งปลูกสร้างของคุณข้อมูลจุดยอดจะนั่งอยู่ตรงนั้นและสิ่งเดียวที่เปลี่ยนแปลงคือเมทริกซ์ของคุณ (โมเดล / โลก, การฉายภาพและมุมมอง)

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

เมื่อแบบจำลองแสดงผลแต่ละเฟรมตัวประมวลผล GPU ต้องดึงข้อมูลทุกครั้งจากหน่วยความจำ GPU หรือไม่ สิ่งที่ฉันหมายถึงคือ - ถ้าฉันมี 2 แบบจำลองที่แสดงหลายครั้งในแต่ละครั้ง - มันจะสำคัญไหมถ้าฉันแสดงครั้งแรกทีละหลายครั้งและอีกอันที่สองหลายครั้งหรือถ้าฉันแสดงครั้งแรกเพียงครั้งเดียว interleaving มันแบบนั้นเหรอ?

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

เห็นได้ชัดว่าการ์ดกราฟิกมี RAM จำกัด - เมื่อมันไม่สามารถเก็บข้อมูลโมเดลทั้งหมดที่จำเป็นสำหรับการเรนเดอร์ 1 เฟรมฉันคิดว่ามันดึงข้อมูล (บางส่วน) จาก CPU RAM แต่ละเฟรมมาถูกต้องหรือไม่

คุณไม่ต้องการที่จะใช้ GPU RAM หมด ถ้าคุณทำแล้วเปลี่ยนสิ่งต่าง ๆ เพื่อให้คุณทำไม่ได้ ในสถานการณ์สมมติที่คุณหมดไปมันอาจจะผิดพลาดอย่างใดอย่างหนึ่ง แต่ฉันไม่เคยเห็นมันเกิดขึ้นดังนั้นฉันจึงไม่รู้

ฉันลืมที่จะแยกความแตกต่าง: มีการส่งข้อมูลไปยัง GPU และมีการตั้งค่า / ผูกบัฟเฟอร์เป็นปัจจุบัน หลังทำให้เกิดการไหลของข้อมูลใด ๆ ?

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

การสร้างบัฟเฟอร์ด้วยการเริ่มต้น

คำตอบของ Raxvan ฟังดูดี แต่มันไม่ค่อยแม่นยำ ใน OpenGL การสร้างบัฟเฟอร์ไม่ได้สำรองพื้นที่ใด ๆ หากคุณต้องการจองพื้นที่โดยไม่ผ่านข้อมูลใด ๆ คุณสามารถโทร glBufferData และส่งผ่านค่าว่าง (ดูส่วนบันทึกย่อที่นี่ )

การอัพเดตข้อมูลบัฟเฟอร์

ฉันเดาว่าคุณหมายถึง glBufferData หรือฟังก์ชั่นอื่น ๆ เช่นนั้นใช่ไหม นี่คือจุดที่การถ่ายโอนข้อมูลจริงเกิดขึ้น (ยกเว้นว่าคุณผ่านโมฆะอย่างที่ฉันเพิ่งพูดไปในย่อหน้าสุดท้าย)

ผูกบัฟเฟอร์เป็น active (เป็นเพียงวิธีบอก API ว่าฉันต้องการบัฟเฟอร์นี้ให้เรนเดอร์ในการเรียกใช้ครั้งถัดไปและมันไม่ได้ทำอะไรด้วยตัวเองหรือไม่?)

ใช่ แต่สามารถทำได้มากกว่านั้นเล็กน้อย ตัวอย่างเช่นถ้าคุณผูก VAO (วัตถุอาร์เรย์จุดสุดยอด) จากนั้นผูก VBO VBO นั้นจะกลายเป็นผูกพันกับ VAO ต่อมาถ้าคุณผูก VAO นั้นอีกครั้งและเรียก glDrawArrays มันจะรู้ว่า VBO จะวาดอะไร

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

API การเรียกแบบดึง

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