CPU และ GPU โต้ตอบกับการแสดงกราฟิกคอมพิวเตอร์อย่างไร

ที่นี่คุณสามารถดูภาพหน้าจอของโปรแกรม C ++ ขนาดเล็กที่ชื่อว่า Triangle.exe พร้อมกับรูปสามเหลี่ยมหมุนได้ตาม OpenGL API

เป็นตัวอย่างที่ธรรมดามาก แต่ฉันคิดว่ามันใช้ได้กับการใช้งานกราฟิกการ์ดอื่น ๆ

ฉันแค่อยากรู้อยากเห็นและต้องการทราบกระบวนการทั้งหมดจากการดับเบิลคลิกที่ Triangle.exe ภายใต้ Windows XP จนกว่าฉันจะเห็นรูปสามเหลี่ยมหมุนบนหน้าจอ จะเกิดอะไรขึ้นซีพียู (อันแรกที่จัดการ. exe) และ GPU (ซึ่งในที่สุดก็ส่งออกสามเหลี่ยมบนหน้าจอ) โต้ตอบอย่างไร

ฉันเดาว่าเกี่ยวข้องกับการแสดงสามเหลี่ยมหมุนนี้ส่วนใหญ่เป็นฮาร์ดแวร์ / ซอฟต์แวร์ต่อไปนี้ในหมู่คนอื่น ๆ :

ฮาร์ดแวร์

• HDD
• หน่วยความจำระบบ (RAM)
• ซีพียู
• หน่วยความจำวิดีโอ
• GPU
• จอแสดงผล LCD

ซอฟต์แวร์

• ระบบปฏิบัติการ
• DirectX / OpenGL API
• ไดรเวอร์ Nvidia

ทุกคนสามารถอธิบายกระบวนการได้หรืออาจใช้ผังงานเพื่อประกอบการอธิบายบ้าง

ไม่ควรเป็นคำอธิบายที่ซับซ้อนที่ครอบคลุมทุกขั้นตอน (คาดเดาว่าจะเกินขอบเขต) แต่คำอธิบายที่คนไอทีระดับกลางสามารถติดตามได้

ฉันค่อนข้างมั่นใจว่าผู้คนมากมายที่จะเรียกตัวเองว่าผู้เชี่ยวชาญด้านไอทีไม่สามารถอธิบายกระบวนการนี้ได้อย่างถูกต้อง

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

การนำเสนอ

สิ่งที่ต้องใช้แม้จะมีภาพเดียวที่คุณโพสต์ในคำถามของคุณวาดบนหน้าจอ?

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

แต่ก่อนที่เราจะวาดอะไรได้เราต้องเริ่มนั่งร้านก่อน เราจะเห็นว่าทำไมในภายหลัง:

// Clear The Screen And The Depth Buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

// Reset The Current Modelview Matrix
glMatrixMode(GL_MODELVIEW); 
glLoadIdentity();

// Drawing Using Triangles
glBegin(GL_TRIANGLES);

  // Red
  glColor3f(1.0f,0.0f,0.0f);
  // Top Of Triangle (Front)
  glVertex3f( 0.0f, 1.0f, 0.0f);

  // Green
  glColor3f(0.0f,1.0f,0.0f);
  // Left Of Triangle (Front)
  glVertex3f(-1.0f,-1.0f, 1.0f);

  // Blue
  glColor3f(0.0f,0.0f,1.0f);
  // Right Of Triangle (Front)
  glVertex3f( 1.0f,-1.0f, 1.0f);

// Done Drawing
glEnd();

แล้วมันทำอะไร?

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

• OpenGL
• Direct3D
• CUDA

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

อินเตอร์เฟซนี้ถูกผูกไว้เพื่อให้คุณบางเครื่องมือ เครื่องมือเหล่านี้มีรูปแบบของAPIที่คุณสามารถโทรได้จากโปรแกรมของคุณ

API นั้นคือสิ่งที่เราเห็นว่ามีการใช้งานในตัวอย่างด้านบน ลองมาดูอย่างใกล้ชิด

นั่งร้าน

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

แต่เราจะไม่มองสิ่งนั้น เราก็จะใช้เวลามองที่สิ่งที่คุณจะต้องทำทุกเฟรม ชอบ:

การล้างหน้าจอ

ไปป์ไลน์กราฟิกจะไม่ล้างหน้าจอสำหรับคุณทุกเฟรม คุณจะต้องบอกมัน ทำไม? นี่คือเหตุผล:

หากคุณไม่ได้ล้างหน้าจอคุณก็แค่วาดมันทุกเฟรม นั่นเป็นเหตุผลที่เราโทรหาglClearด้วยGL_COLOR_BUFFER_BITชุด อีกบิต ( GL_DEPTH_BUFFER_BIT) บอก OpenGL เพื่อล้างบัฟเฟอร์ความลึก บัฟเฟอร์นี้ใช้เพื่อกำหนดว่าพิกเซลใดที่อยู่ข้างหน้า (หรือหลัง) พิกเซลอื่น ๆ

การแปลง

แหล่งที่มาของภาพ

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

ต่อไปเราใช้เมทริกซ์การฉายของเรา นี่เป็นการย้ายพิกัดทั้งหมดเพื่อให้พวกเขาหันหน้าเข้าหากล้องของเราอย่างถูกต้อง

ตอนนี้เราแปลงอีกครั้งด้วยเมทริกซ์วิวพอร์ตของเรา เราทำเช่นนี้เพื่อปรับขนาดโมเดลของเราตามขนาดของจอภาพ ตอนนี้เรามีจุดยอดที่พร้อมจะแสดง!

เราจะกลับมาเปลี่ยนแปลงอีกในภายหลัง

การวาดภาพ

การวาดรูปสามเหลี่ยมเราก็สามารถบอก OpenGL ที่จะเริ่มต้นใหม่รายชื่อของรูปสามเหลี่ยมโดยการโทรglBeginที่มีGL_TRIANGLESอย่างต่อเนื่อง
^{นอกจากนี้ยังมีรูปแบบอื่น ๆ ที่คุณสามารถวาด เช่นเดียวกับแถบสามเหลี่ยมหรือแฟนสามเหลี่ยม สิ่งเหล่านี้เป็นการปรับให้เหมาะสมที่สุดเนื่องจากต้องการการสื่อสารที่น้อยกว่าระหว่าง CPU และ GPU เพื่อดึงสามเหลี่ยมจำนวนเท่ากัน}

หลังจากนั้นเราสามารถให้รายการชุดของ 3 จุดยอดที่ควรประกอบเป็นสามเหลี่ยมแต่ละอัน สามเหลี่ยมทุกอันใช้ 3 พิกัด (เนื่องจากเราอยู่ในพื้นที่ 3D) นอกจากนี้ผมยังให้สีสำหรับแต่ละจุดสุดยอดโดยการเรียกglColor3f ก่อนที่จะglVertex3fเรียก

สีระหว่าง 3 จุด (3 มุมของรูปสามเหลี่ยม) คำนวณโดย OpenGL โดยอัตโนมัติ มันจะทำการแทรกสีให้ทั่วใบหน้าของรูปหลายเหลี่ยม

ปฏิสัมพันธ์

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

นี้ได้รับจำนวนมากยากมากขึ้นเมื่อคุณต้องการที่จะเริ่มมีปฏิสัมพันธ์กับฉาก 3 มิติของคุณ

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

ดังนั้นคุณจะทำให้มันหมุนได้อย่างไร

การแปลง

ฉันตระหนักถึงการแปลงสองประเภทที่ใช้โดยทั่วไป:

• การแปลงตามเมทริกซ์
• การเปลี่ยนแปลงของกระดูก

แตกต่างก็คือกระดูกส่งผลกระทบต่อเดียวจุด เมทริกซ์จะมีผลต่อจุดยอดที่วาดในลักษณะเดียวกัน ลองดูตัวอย่าง

ตัวอย่าง

ก่อนหน้านี้เราโหลดเมทริกซ์เอกลักษณ์ของเราก่อนที่จะวาดรูปสามเหลี่ยมของเรา เมทริกซ์เอกลักษณ์เป็นสิ่งที่ไม่มีการเปลี่ยนแปลงเลย ดังนั้นสิ่งที่ฉันวาดได้รับผลกระทบจากมุมมองของฉันเท่านั้น ดังนั้นสามเหลี่ยมจะไม่ถูกหมุนเลย

ถ้าฉันต้องการหมุนตอนนี้ฉันสามารถทำคณิตศาสตร์ด้วยตัวเอง (บน CPU) และเพียงแค่เรียกglVertex3fกับพิกัดอื่น (ที่หมุน) หรือฉันสามารถปล่อยให้ GPU ทำทุกอย่างได้โดยการโทรglRotatefก่อนวาดภาพ:

// Rotate The Triangle On The Y axis
glRotatef(amount,0.0f,1.0f,0.0f);               

amountแน่นอนว่าเป็นเพียงค่าคงที่ หากคุณต้องการเคลื่อนไหวคุณจะต้องติดตามamountและเพิ่มทุกเฟรม

ดังนั้นรอเกิดอะไรขึ้นกับเมทริกซ์พูดก่อนหน้านี้?

ในตัวอย่างง่ายๆนี้เราไม่ต้องสนใจเมทริกซ์ เราเพียงแค่โทรหาglRotatefและดูแลทุกอย่างให้เรา

glRotateก่อให้เกิดการหมุนของangleองศารอบเวกเตอร์ xyz เมทริกซ์ปัจจุบัน (ดูglMatrixMode ) ถูกคูณด้วยเมทริกซ์การหมุนด้วยผลิตภัณฑ์ที่แทนที่เมทริกซ์ปัจจุบันราวกับว่าglMultMatrixถูกเรียกด้วยเมทริกซ์ต่อไปนี้เป็นอาร์กิวเมนต์:

x 2 ⁡ 1 - c + cx ⁢ y ⁡ 1 - c - z ⁢ sx ⁢ z ⁡ 1 - c + y ⁢ s 0 y ⁢ x ⁡ 1 - c + z ⁢ sy 2 ⁡ 1 - c + cy ⁢ z ⁡ 1 - c - x ⁢ s 0 x ⁢ z ⁡ 1 - c - y ⁢ sy ⁢ z ⁡ 1 - c + x ⁢ sz 2 ⁡ 1 - c + c 0 0 0 0 1 1

ขอบคุณมากสำหรับสิ่งนั้น!

ข้อสรุป

สิ่งที่ชัดเจนคือมีการพูดคุยกับ OpenGL มากมาย แต่มันไม่ได้บอกอะไรเรา การสื่อสารอยู่ที่ไหน

สิ่งเดียวที่ OpenGL บอกกับเราในตัวอย่างนี้คือเมื่อทำเสร็จแล้ว ทุกการดำเนินการจะใช้เวลาพอสมควร การดำเนินการบางอย่างใช้เวลานานอย่างไม่น่าเชื่อการดำเนินการบางอย่างรวดเร็วอย่างไม่น่าเชื่อ

การส่งจุดสุดยอดไปยัง GPU จะเร็วมากฉันไม่รู้ด้วยซ้ำว่าจะแสดงออกมาอย่างไร การส่งจุดยอดนับพันจากซีพียูไปยัง GPU ในทุก ๆ เฟรมเป็นไปได้มากที่สุดที่จะไม่มีปัญหาเลย

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

นอกจากนั้นเราสามารถถาม OpenGL เกี่ยวกับความสามารถของกราฟิกการ์ดของเราได้ (ความละเอียดสูงสุดการลบรอยหยักสูงสุดความลึกสีสูงสุด ... )

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

จากนั้นเราสามารถ "แสดง" ผลลัพธ์ของการคำนวณของเรา (ในรูปแบบของสีใหม่) ลงในพื้นผิวใหม่

นั่นเป็นวิธีที่คุณสามารถทำให้ GPU ใช้งานได้ในวิธีอื่น ฉันถือว่า CUDA ดำเนินการคล้ายกับด้านนั้น แต่ฉันไม่เคยมีโอกาสได้ทำงานกับมัน

พวกเราสัมผัสวัตถุทั้งหมดเพียงเล็กน้อยเท่านั้น การเขียนโปรแกรมกราฟิก 3D เป็นนรกของสัตว์ร้าย

แหล่งที่มาของภาพ

เป็นการยากที่จะเข้าใจอย่างชัดเจนว่าคุณไม่เข้าใจอะไร

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

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

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

ฉันแค่อยากรู้อยากเห็นและต้องการทราบกระบวนการทั้งหมดจากการดับเบิลคลิกที่ Triangle.exe ภายใต้ Windows XP จนกว่าฉันจะเห็นรูปสามเหลี่ยมหมุนบนหน้าจอ จะเกิดอะไรขึ้นซีพียู (อันแรกที่จัดการ. exe) และ GPU (ซึ่งในที่สุดก็ส่งออกสามเหลี่ยมบนหน้าจอ) โต้ตอบอย่างไร

ลองสมมติว่าคุณรู้จริงว่าการทำงานของรันบนระบบปฏิบัติการได้อย่างไรและวิธีการที่เอ็กซีคิวต์นั้นส่งจาก GPU ของคุณไปยังจอภาพ แต่ไม่รู้ว่าเกิดอะไรขึ้นระหว่างนั้น ดังนั้นมาดูจากด้านฮาร์ดแวร์และขยายเพิ่มเติมในคำตอบด้านโปรแกรมเมอร์ ...

อินเทอร์เฟซระหว่าง CPU และ GPU คืออะไร

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

แต่คุณไม่สามารถพูดกับฮาร์ดแวร์หรือไดรเวอร์จากรหัสโดยตรงได้ ดังนั้นสิ่งนี้จะต้องเกิดขึ้นผ่าน API เช่น OpenGL, Direct3D, CUDA, HLSL, Cg ในขณะที่คำแนะนำการเรียกใช้ GPU ในอดีตและ / หรืออัปเดตหน่วยความจำ GPU นั้นจริง ๆ แล้วจะรันโค้ดบน GPU ตามที่เป็นภาษาทางฟิสิกส์ / shader

ทำไมต้องเรียกใช้รหัสบน GPU ไม่ใช่บน CPU?

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

GPU ที่เหมาะสำหรับหนึ่งในการคำนวณที่สำคัญที่สุดในกราฟิกMatrix จัดการ ในขณะที่ CPU มีการคำนวณการคูณแต่ละครั้งในการจัดการเมทริกซ์แบบหนึ่งต่อหนึ่ง (ต่อมาสิ่งต่าง ๆ เช่น3DNow!และSSEทัน), GPU สามารถทำคูณเหล่านั้นทั้งหมดในครั้งเดียว! ความเท่าเทียม

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

คำแนะนำ GPU / หน่วยความจำ / รหัสเหล่านี้แสดงกราฟิกอย่างไร

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

ลองยกตัวอย่างที่คุณต้องการวาดสไปรต์เลือด (ภาพ) ที่ไหนสักแห่ง; ครั้งแรกพื้นผิวของต้นไม้เองถูกโหลดลงในหน่วยความจำ GPU ซึ่งทำให้ง่ายต่อการวาดใหม่ตามต้องการ ต่อไปในการวาดเทพดาที่ไหนสักแห่งเราสามารถแปลเทพดาโดยใช้จุดสุดยอด (วางไว้ในตำแหน่งที่เหมาะสม) rasterising มัน (เปลี่ยนจากวัตถุ 3 มิติเป็นพิกเซล) และอัพเดท framebuffer เพื่อให้ได้แนวคิดที่ดียิ่งขึ้นนี่คือแผนภูมิการไหลของท่อส่ง OpenGL จาก Wikipedia:

นี่คือส่วนสำคัญของแนวคิดกราฟิกทั้งหมดการวิจัยเพิ่มเติมเป็นการบ้านสำหรับผู้อ่าน

เพื่อให้ง่ายขึ้นเราสามารถอธิบายแบบนี้ได้ ที่อยู่หน่วยความจำบางส่วนถูกสงวนไว้ (โดย BIOS และ / หรือระบบปฏิบัติการ) ไม่ใช่สำหรับ RAM แต่สำหรับการ์ดวิดีโอ ข้อมูลใด ๆ ที่เขียนด้วยค่าเหล่านั้น (พอยน์เตอร์) จะไปที่การ์ด ดังนั้นในทางทฤษฎีโปรแกรมใด ๆ สามารถเขียนไปที่วิดีโอได้โดยตรงเพียงแค่รู้ช่วงที่อยู่และนี่คือสิ่งที่มันทำในสมัยก่อน ในทางปฏิบัติกับระบบปฏิบัติการที่ทันสมัยสิ่งนี้ได้รับการจัดการโดยไดรเวอร์วิดีโอและ / หรือไลบรารีกราฟิกด้านบน (DirectX, OpenGL ฯลฯ )

โดยปกติแล้ว GPU จะขับเคลื่อนด้วยบัฟเฟอร์ DMA นั่นคือไดรเวอร์จะรวบรวมคำสั่งที่ได้รับจากโปรแกรมพื้นที่ผู้ใช้ลงในสตรีมของคำสั่ง (เปลี่ยนสถานะวาดสิ่งนี้ในลักษณะนั้นสลับบริบท ฯลฯ ) ซึ่งจะถูกคัดลอกไปยังหน่วยความจำอุปกรณ์ จากนั้นจะสั่งให้ GPU รันคำสั่งบัฟเฟอร์นี้ผ่านทาง PCI register หรือวิธีอื่นที่คล้ายกัน

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

บนคอนโซลคุณสามารถสนุกไปกับการทำทั้งหมดด้วยตัวเองโดยเฉพาะบน PS3

ฉันคิดว่า CPU ส่งข้อมูลวิดีโอไปยัง GPU ผ่านทางรถบัสแล้ว GPU แสดงมัน ดังนั้น GPU ที่เร็วกว่าจึงสามารถรองรับข้อมูลได้มากขึ้นจาก CPU ด้วยวิธีนี้บางส่วนของการประมวลผล cpuoffload กับ GPU ดังนั้นคุณจะได้ความเร็วที่เร็วขึ้นในเกม

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

หรือการ์ดเสียงหรือการ์ดเน็ตเวิร์กทำงานบนหลักการเดียวกันนั่นคือรับข้อมูลและลดการทำงานของซีพียู

ฉันคิดว่า op ไม่แน่ใจว่า cpu กำลังสั่งให้การ์ดกราฟิกทำอะไรและทำไมคำสั่งที่เกี่ยวข้องกับกราฟิก (เช่นคำสั่ง opengl หรือ direct3d) ไม่ได้ส่งโดยตรงไปยัง GPU

ซีพียูเพียงบอก GPU สิ่งที่จะแสดง คำแนะนำทั้งหมดต้องผ่านซีพียูก่อนเพื่อให้ GPU สามารถทำการเรนเดอร์ได้