Visual Computing -- What is the next challenge?

By Orion R. Granatir for our content partner: Digital Innovation Gazette

Five years ago, a new wave of consoles brought the inception of high-definition (HD) content to the video game industry. Some companies excelled in this era, others did not. Nevertheless, the industry is now HD.

As evidenced by console manufacturers developing new input controls to extend the life of this generation of consoles, the industry is looking for the next challenge. With the release of DirectX 11, the increasing capabilities of processor graphics, and a new surge of mobile devices, there certainly is plenty to explore.

Some think programming for multicore is a punishment reserved for the eighth ring of hell. (I recently beat EA’s Dante’s Inferno, so it’s on my mind.) But you don’t need to fight your way through purgatory to reach multicore heaven. If you keep two concepts in mind, things get easier:

1. Use data decomposition: A game can’t scale just by dividing subsystems onto separate threads (sometimes referred to as “functional decomposition”). It has to divide data intelligently to run across multiple cores. The ever-insightful Mike Acton has a great article on this very subject over at Insomniac Games’ R&D page

2. Use tasks, not threads directly: To scale on an arbitrary number of cores and be truly cross-platform, work should be divided into tasks. A task is a unit of work (for example, a function pointer and data) that can run without (or with very limited) synchronization. These units of work are processed by a thread pool, which is scaled appropriately to the available parallelism in the hardware.

By utilizing tasking and data decomposition together, it is possible to take advantage of multicore for all subsystems. Prior to DX11, rendering was still the locked gateway to heaven. With DX11, it’s now possible to divide the work of rendering into multiple tasks using deferred contexts.

It’s interesting to note that DX11’s multithreaded goodness can run on DX10 hardware. DX11 supports “feature level,” which allows the latest API to be used on a wide range of hardware (provided the application is running on Vista/Win7) by emulating any missing behavior in software.

There is a growing uptake of task-based architectures in game engine design. Mark Randel’s implementation of physics and AI in Terminal Reality’s Infernal Engine is nothing short of amazing. The fellows over at BitSquid are building a new game engine written with solid support for multicore. Furthermore, the Civilization V team at Firaxis is getting great performance out of a task-based approach. (Check out their GDC 2010 presentation: “Firaxis’ Civilization V: A Case Study in Scalable Game Performance.”)

Orion R. Granatir is a senior
engineer with Intel’s Visual Computing Software Division [disclosure: Intel is
a sponsor of this website]. Prior to that, Orion worked on several PlayStation
3 titles as a senior programmer with Insomniac Games. His most recent published
titles are Resistance: Fall of Man and Ratchet and Clank
Future: Tools of Destruction.