Использование архитектуры системы сущностей с параллелизмом на основе задач

Фон

В свое свободное время я работал над созданием многопоточного игрового движка, и в настоящее время я пытаюсь найти лучший способ превратить систему сущностей в то, что я уже создал. До сих пор я использовал эту статью от Intel как отправную точку для своего движка. До сих пор я реализовал нормальный игровой цикл, используя задачи, и теперь я перехожу к включению некоторых систем и / или систем сущностей. В прошлом я использовал нечто похожее на Артемиду , но параллелизм меня отталкивает.

Похоже, что статья Intel отстаивает наличие нескольких копий данных сущностей, а также внесение изменений в каждую сущность, внутренне распространяемых в конце полного обновления. Это означает, что рендеринг всегда будет на один кадр позади, но это кажется приемлемым компромиссом, учитывая преимущества в производительности, которые должны быть получены. Однако, когда дело доходит до системы объектов, такой как Артемида, дублирование каждого объекта для каждой системы означает, что каждый компонент также необходимо будет дублировать. Это выполнимо, но мне кажется, что это заняло бы много памяти. Части документа Intel, которые обсуждают это в основном 2.2 и 3.2.2. Я провел некоторые поиски, чтобы посмотреть, смогу ли я найти какие-либо хорошие ссылки для интеграции архитектур, на которые я рассчитываю, но я пока не смог найти ничего полезного.

Примечание: я использую C ++ 11 для этого проекта, но я думаю, что большая часть того, что я спрашиваю, должна быть довольно независимой от языка.

Возможное решение

Иметь глобальный EntityManager, который используется для создания и управления Entity и EntityAttributes. Разрешите доступ к ним только для чтения на этапе обновления и сохраняйте все изменения в очереди для каждого потока. Как только все задачи выполнены, очереди объединяются, и изменения в каждой применяются. Это могло бы иметь проблемы с несколькими записями в одни и те же поля, но я уверен, что может быть система приоритетов или отметка времени, чтобы уладить это. Мне кажется, что это хороший подход, потому что системы могут уведомляться об изменениях сущностей довольно естественно на этапе распространения изменений.

Вопрос

Я ищу отзывы о моем решении, чтобы понять, имеет ли оно смысл. Я не буду лгать и претендовать на звание эксперта по многопоточности, и я делаю это в основном для практики. Я могу предвидеть некоторые сложные проблемы, возникающие из моего решения, когда несколько систем считывают / записывают несколько значений. Очередь изменений, о которой я упоминал, также может быть трудно отформатировать так, чтобы любое возможное изменение можно было легко передать, когда я не работаю с POD.

Любая обратная связь / совет будет высоко ценится! Спасибо!

связи

• http://software.intel.com/en-us/articles/designing-the-framework-of-a-parallel-game-engine
• http://gamadu.com/artemis/
• http://www.gamedev.net/topic/560083-rendering-in-a-task-based-multithreaded-environment/ (не упомянуто в посте, но упомянуто подобное решение)

Вилка-Join

Вам не нужны отдельные копии компонентов. Просто используйте модель fork-join, которая (крайне плохо) упоминается в этой статье от Intel.

В ECS у вас фактически есть цикл что-то вроде:

while in game:
  for each system:
    for each component in system:
      update component

Измените это на что-то вроде:

while in game:
  for each system:
    divide components into groups
    for each group:
      start thread (
        for each component in group:
          update component
      )
    wait for all threads to finish

Сложная часть - бит «разделить компоненты на группы». Для графики почти нет необходимости в общих данных, поэтому все просто (делите визуализируемые объекты равномерно по количеству доступных рабочих потоков). Для физики и ИИ вы хотите найти логические «островки» объектов, которые не взаимодействуют, и соединить их вместе. Чем меньше взаимодействие между компонентами, тем лучше.

Для взаимодействия, которое должно существовать, задержанные сообщения работают лучше всего. Если объект A должен сообщить объекту B о получении повреждения, A может просто поместить сообщение в пул для каждого потока. Когда потоки объединяются, все пулы объединяются в один пул. Хотя это и не связано напрямую с потоками, см. Серию статей о событиях от разработчиков BitSquid (на самом деле, прочитайте весь блог; я не согласен со всем там, но это фантастический ресурс).

Обратите внимание, что «fork-join» не означает использование fork()(которое создает процессы, а не потоки) и не подразумевает, что вы действительно должны присоединиться к потокам. Это просто означает, что вы берете одну задачу, разбиваете ее на более мелкие части для обработки вашим пулом рабочих потоков, а затем ждете обработки всех посылок.

Доверенные

Этот подход можно использовать сам по себе или в сочетании с методом fork-join, чтобы сделать необходимость строгого разделения менее важной.

Вы можете быть более дружественными к взаимодействующим потокам, используя простой двухслойный подход. Иметь «авторитетные» сущности и «доверенные лица». Доверенные сущности могут быть изменены только из одного потока, который является явным владельцем доверенного лица. Объекты прокси не могут быть изменены, только для чтения. В точке синхронизации в игровом цикле распространите все изменения от авторитетных сущностей на соответствующие прокси.

Замените «сущности» на «компоненты» в зависимости от ситуации. Суть в том, что вам нужно не более двух копий любого объекта, и в вашем игровом цикле есть четкие «точки синхронизации», когда вы можете копировать из одного в другое в большинстве нормальных игровых движков.

Вы можете расширить прокси-серверы, чтобы по-прежнему разрешать использование (подмножество) методов / сообщений, просто перенаправляя все эти вещи в очередь, которая доставляется доверенному объекту в следующем кадре.

Обратите внимание, что прокси-подход - это фантастический дизайн, который нужно иметь на более высоком уровне, поскольку он делает поддержку сети очень простой.