Скориставшись багатопоточністю між ігровим циклом та openGL

Говорячи в контексті гри, заснованої на рендері openGL:

Припустимо, є дві нитки:

1. Оновлення логіки гри і фізики тощо для ігрових об'єктів

2. Робить openGL виклики для малювання кожного ігрового об’єкта на основі даних в ігрових об'єктах (цей потік 1 постійно оновлюється)

Якщо у вас є дві копії кожного ігрового об'єкта в поточному стані гри, вам доведеться призупинити Thread 1, в той час як Thread 2 робить виклики нічиї, інакше ігрові об’єкти оновлюються в середині розіграшу для цього об’єкта, який небажано!

Але зупинка потоку 1 для безпечного здійснення дзвінків з нитки 2 вбиває всю мету багатопотокової / одночасності

Чи є кращий підхід для цього, крім використання сотень чи тисяч чи синхронізації об'єктів / парканів, щоб багатоядерну архітектуру можна було використовувати для продуктивності?

Я знаю, що я все ще можу використовувати багатопотоковість для завантаження текстури та компіляції шейдерів для об'єктів, які ще є частиною поточного стану гри, але як це зробити для активних / видимих ​​об'єктів, не викликаючи конфлікту з малюванням та оновленням?

Що робити, якщо я використовую окремий блокування синхронізації в кожному з ігрових об'єктів? Таким чином, будь-яка нитка блокується лише на одному об'єкті (ідеальний випадок), а не на весь цикл оновлення / малювання! Але наскільки затратним є зняття замків на кожному об’єкті (у грі може бути тисяча предметів)?

Описаний вами підхід із використанням блокування був би дуже неефективним і, швидше за все, повільнішим, ніж використання однієї нитки. Інший підхід збереження копій даних у кожному потоці, ймовірно, буде добре "швидким", але з надмірною вартістю пам'яті та складністю коду для збереження копій синхронізовано.

До цього існує декілька альтернативних підходів, одне популярне рішення для багатопотокової візуалізації - це використання подвійного буфера команд. Це складається з запуску зворотного кінця візуалізації в окремий потік, де виконуються всі дзвінки з викликом і зв'язок з API надання візуалізації. Лицьовий потік, який виконує логіку гри, спілкується з рендером за допомогою командного буфера (подвійний буфер). За допомогою цієї установки у вас є лише одна точка синхронізації після завершення кадру. У той час як передня частина заповнює один буфер командами візуалізації, зворотній кінець споживає інший. Якщо обидві нитки добре збалансовані, жодна не повинна голодувати. Такий підхід є недостатньо оптимальним, оскільки він вводить затримку у наданих кадрах, плюс, драйвер OpenGL, ймовірно, вже робить це у своєму процесі, тому підвищення продуктивності доведеться ретельно вимірювати. Також він використовує лише два ядра, в кращому випадку. Цей підхід застосовується в кількох успішних іграх, таких як Doom 3 і Quake 3

Більш масштабовані підходи, які краще використовують багатоядерні процесори, - це такі, які базуються на незалежних завданнях , коли ви запускаєте асинхронний запит, який обслуговується у вторинному потоці, тоді як потік, який запустив запит, продовжує іншу роботу. В ідеалі завдання не повинно бути залежним від інших потоків, уникати блокування (також уникати спільних / глобальних даних, як чума!). Архітектури, що базуються на завданнях, більш зручні в локалізованих частинах гри, таких як обчислювальна анімація, маршрутизація AI, генерація процедур, динамічне завантаження реквізиту сцени тощо. Ігри, природно, повні, більшість видів подій є асинхронними, тому легко змусити їх працювати окремими потоками.

Нарешті, рекомендую прочитати:

• Основи теми для ігор від Intel.

• Ефективна паралельність від Herb Sutter (кілька посилань на інші хороші ресурси на цій сторінці).