opengl: glFlush () กับ glFinish ()

ฉันมีปัญหาในการแยกแยะความแตกต่างระหว่างการโทรglFlush()และglFinish().

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

เมื่ออ่านคำจำกัดความแล้วฉันคิดว่าถ้าฉันจะใช้glFlush()ฉันอาจประสบปัญหาในการส่งการดำเนินการไปยัง OpenGL มากกว่าที่จะดำเนินการได้ ดังนั้นเพื่อที่จะลองฉันสลับglFinish()a glFlush()และแท้จริงของฉันและดูเถิดโปรแกรมของฉันทำงาน (เท่าที่ฉันสามารถบอกได้) เหมือนกันทุกประการ อัตราเฟรมการใช้ทรัพยากรทุกอย่างเหมือนเดิม

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

รหัสของฉันคือลูปเกมทั่วไป:

while (running) {
    process_stuff();
    render_stuff();
}

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

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

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

ตามที่คำตอบอื่น ๆ ได้บอกเป็นนัยว่าไม่มีคำตอบที่ดีตามข้อกำหนด เจตนาโดยทั่วไปglFlush()คือหลังจากเรียกใช้แล้ว CPU โฮสต์จะไม่มีงานที่เกี่ยวข้องกับ OpenGL ให้ทำ - คำสั่งจะถูกผลักไปที่ฮาร์ดแวร์กราฟิก จุดประสงค์ทั่วไปglFinish()คือหลังจากส่งคืนแล้วจะไม่มีงานเหลืออยู่และผลลัพธ์ควรมีอยู่ด้วยเช่นกันสำหรับ API ที่ไม่ใช่ OpenGL ที่เหมาะสม (เช่นอ่านจาก framebuffer ภาพหน้าจอ ฯลฯ ... ) สิ่งที่เกิดขึ้นนั้นขึ้นอยู่กับไดรเวอร์หรือไม่ ข้อกำหนดนี้อนุญาตให้มีละติจูดได้มากพอ ๆ กับสิ่งที่ถูกกฎหมาย

ฉันสับสนอยู่เสมอเกี่ยวกับคำสั่งทั้งสองนี้เช่นกัน แต่ภาพนี้ทำให้ทุกอย่างชัดเจนสำหรับฉัน: เห็นได้ชัดว่าไดรเวอร์ GPU บางตัวไม่ส่งคำสั่งที่ออกให้กับฮาร์ดแวร์เว้นแต่จะมีการสะสมคำสั่งจำนวนหนึ่ง ในตัวอย่างนี้หมายเลขที่5
ภาพแสดงคำสั่งต่างๆของ OpenGL (A, B, C, D, E ... ) ที่ออกมา ดังที่เราเห็นที่ด้านบนคำสั่งยังไม่ได้รับเนื่องจากคิวยังไม่เต็ม

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

ที่ด้านล่างเราจะเห็นตัวอย่างโดยใช้glFinish(). เกือบจะทำสิ่งเดียวกันกับglFlush()ยกเว้นว่าจะทำให้เธรดการโทรรอจนกว่าคำสั่งทั้งหมดจะได้รับการประมวลผลโดยฮาร์ดแวร์

ภาพที่นำมาจากหนังสือ "การเขียนโปรแกรมกราฟิกขั้นสูงโดยใช้ OpenGL"

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

ในทางปฏิบัติงานทั้งหมดที่คุณส่งไปยังไดรเวอร์จะถูกแบ่งเป็นกลุ่มและส่งไปยังฮาร์ดแวร์ในภายหลัง (เช่นในเวลา SwapBuffer)

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

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

โปรดทราบว่า API เช่น Direct3D ไม่รองรับแนวคิด Finish เลย

glFlush ย้อนหลังไปถึงรูปแบบไคลเอนต์เซิร์ฟเวอร์จริงๆ คุณส่งคำสั่ง gl ทั้งหมดผ่านไพพ์ไปยังเซิร์ฟเวอร์ gl ท่อนั้นอาจบัฟเฟอร์ เช่นเดียวกับไฟล์หรือเครือข่ายที่ i / o อาจบัฟเฟอร์ glFlush ระบุเพียงว่า "ส่งบัฟเฟอร์เดี๋ยวนี้แม้ว่าจะยังไม่เต็มก็ตาม!" ในระบบโลคัลแทบจะไม่จำเป็นต้องใช้เลยเนื่องจาก OpenGL API ในเครื่องไม่น่าจะบัฟเฟอร์เองและเพียงแค่ออกคำสั่งโดยตรง นอกจากนี้คำสั่งทั้งหมดที่ทำให้เกิดการแสดงผลจริงจะทำการล้างโดยปริยาย

ในทางกลับกัน glFinish ถูกสร้างขึ้นเพื่อการวัดประสิทธิภาพ ชนิดของ PING ไปยังเซิร์ฟเวอร์ GL มันปัดเศษคำสั่งและรอจนกว่าเซิร์ฟเวอร์จะตอบกลับว่า "ฉันไม่ได้ใช้งาน"

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

โดยสรุป: ถือว่าทั้ง glFinish และ glFlush ไม่มีทางปฏิบัติเว้นแต่คุณจะเข้ารหัสเซิร์ฟเวอร์ SGI OpenGL ระยะไกลแบบโบราณ

ได้ดูที่นี่ กล่าวโดยย่อว่า:

glFinish () มีผลเช่นเดียวกับ glFlush () โดยที่ glFinish () จะบล็อกจนกว่าคำสั่งทั้งหมดที่ส่งมาจะได้รับการดำเนินการ

อีกบทความอธิบายความแตกต่างอื่น ๆ :

• ฟังก์ชัน Swap (ใช้ในแอพพลิเคชั่นที่บัฟเฟอร์สองครั้ง) จะล้างคำสั่งโดยอัตโนมัติจึงไม่จำเป็นต้องโทร glFlush
• glFinish บังคับให้ OpenGL ดำเนินการคำสั่งที่โดดเด่นซึ่งเป็นความคิดที่ไม่ดี (เช่นกับ VSync)

สรุปได้หมายความว่าคุณไม่จำเป็นต้องใช้ฟังก์ชันเหล่านี้เมื่อใช้การบัฟเฟอร์สองครั้งยกเว้นว่าการใช้งาน swap-buffers ของคุณจะไม่ล้างคำสั่งโดยอัตโนมัติ

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

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

ฉันยังไม่ได้ลอง แต่อีกไม่นาน

ฉันได้ลองใช้กับแอปพลิเคชั่นเก่าที่ใช้ CPU และ GPU ได้ค่อนข้างดี (เดิมใช้finish)

พอเปลี่ยนเป็นflushตอนท้ายและfinishตอนแรกไม่มีปัญหาเฉพาะหน้า (ทุกอย่างดูดี!) การตอบสนองของโปรแกรมเพิ่มขึ้นอาจเป็นเพราะ CPU ไม่ได้หยุดรอบน GPU เป็นวิธีที่ดีกว่าแน่นอน

สำหรับการเปรียบเทียบฉันลบออกfinishedจากจุดเริ่มต้นของเฟรมทิ้งไว้flushและทำเช่นเดียวกัน

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

คำถามคือคุณต้องการให้โค้ดของคุณทำงานต่อไปในขณะที่กำลังเรียกใช้คำสั่ง OpenGL หรือให้รันหลังจากที่คำสั่ง OpenGL ของคุณถูกเรียกใช้เท่านั้น

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