Game Developers Conference 2009 Multithreaded AI For The Win! Orion Granatir Senior Software Engineer

Agenda Define a Simple AI Challenge Threading AI Working in a Multithread Land Smoke: Multithread Land Summary

Agenda Define a Simple AI Challenge Threading AI Working in a Multithread Land Smoke: Multithread Land Summary

Multi-core Needs Parallel Applications Challenge The number of cores is increasing To really maximize performance and features, a game needs to fully utilize the CPU This means threading! GHz EraMulti-core Era APP PERFORMANCE TIME PLATFORM POTENTIAL PERFORMANCE Parallel Serial Challenge

Distributing work among cores means more monsters! Core Challenge

Agenda Define a Simple AI Challenge Threading AI Working in a Multithread Land Smoke: Multithread Land Summary

Game Main Loop... Let’s define a simple AI Simple AI Graphics Physics AI A simple game loop that updates in a serial manner Each AI has a state machine that makes decisions and triggers collisions and pathfinding queries as needed AI State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding

AI_SPAWN Let’s define some states case AI_SPAWN: { // Initial Setup Setup(); m_State = AI_IDLE; break; } Simple AI

AI_IDLE Let’s define some states case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::RayCast( m_Pos, GetPlayerPos() ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } Simple AI

AI_ATTACK Let’s define some states case AI_ATTACK: { // Find a path to the player Collision::Path Path = Collision:: FindPath( m_Pos, GetPlayerPos() ); // Update our position to move towards the player Move( Path ); // Check if we are close to the player Vector Distance = GetPlayerPos() - m_Pos; if( Distance.Magnitude() < 1.0f ) { m_State = AI_EXPLODE; } break; } Simple AI

case AI_EXPLODE: { // Find a path to the player Collision::Result Result = Collision::Sphere( m_Pos ); if( Result.m_Hit ) { // Cause damage to anything near us //... } break; } AI_EXPLODE Let’s define some states Simple AI

AI_EXPLODE m_HP = 0 Let’s define some states // Check out hit points if( m_HitPoints == 0 ) { m_State = AI_EXPLODE; } Simple AI

Let’s put it all together Simple AI AI_IDLE AI_SPAWN AI_ATTACK AI_EXPLODE m_HP = 0 See the player Near the player

void Ai::Update( void ) { switch( m_State ) { case AI_SPAWN: { // Initial Setup Setup(); m_State = AI_IDLE; break; } case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::RayCast( m_Pos, GetPlayerPos() ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } case AI_ATTACK: { // Find a path to the player Collision::Path Path = Collision::FindPath( m_Pos, GetPlayerPos() ); // Update our position to move towards the player Move( Path ); // Check if we are close to the player Vector Distance = GetPlayerPos() - m_Pos; if( Distance.Magnitude() < 1.0f ) { m_State = AI_EXPLODE; } break; } case AI_EXPLODE: { // Cause damage to anything near us… } // Check out hit points if( m_HitPoints == 0 ) { m_State = AI_EXPLODE; } Let’s put it all together Simple AI

Agenda Define a Simple AI Challenge Threading AI Working in a Multithread Land Smoke: Multithread Land Summary

Process your AI in parallel Threading AI AI State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding void UpdateAI( void ) { for( int i = 0; i < g_Num_AI; i++ ) { g_AI_Array[ i ].Update(); }

AI State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding Use data decomposition Threading AI State Machine Collision Pathfinding State Machine Collision Pathfinding Divide the AIs into groups. This is data decomposition. void UpdateAI( void ) { for( int i = 0; i < g_Num_AI; i++ ) { g_AI_Array[ i ].Update(); }

AI State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding Threading AI State Machine Collision Pathfinding State Machine Collision Pathfinding Divide the AIs into groups. This is data decomposition. void UpdateAI( void ) { for( int i = 0; i < g_Num_AI; i++ ) { g_AI_Array[ i ].Update(); } Use data decomposition

AI Threading AI Divide the AIs into groups. This is data decomposition. Submit the AIs to a job queue or use threading API like OpenMP or Intel® Threading Building Blocks. void UpdateAI( void ) { #pragma omp parallel for for( int Index = 0; Index < g_Num_AI; Index++ ) { g_AI_Array[ Index ].Update(); } Use data decomposition State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding

AI Threading AI class ParallelAIContext { void operator()( const tbb::blocked_range &range ) { for(int i = range.begin(); i != range.end(); ++i) { g_AI_Array [ i ].Update(); } void UpdateAI( void ) { tbb::parallel_for( tbb::blocked_range (0, g_Num_AI), *pParallelAIContext ); } Use data decomposition Divide the AIs into groups. This is data decomposition. Submit the AIs to a job queue or use threading API like OpenMP or Intel® Threading Building Blocks. State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding State Machine Collision Pathfinding

There might be dragons Threading AI void Ai::Update( void ) { switch( m_State ) { case AI_SPAWN: { // Initial Setup Setup(); m_State = AI_IDLE; break; } case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::RayCast( m_Pos, GetPlayerPos() ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } case AI_ATTACK: { // Find a path to the player Collision::Path Path = Collision::FindPath( m_Pos, GetPlayerPos() ); // Update our position to move towards the player Move( Path ); // Check if we are close to the player Vector Distance = GetPlayerPos() - m_Pos; if( Distance.Magnitude() < 1.0f ) { m_State = AI_EXPLODE; } break; } case AI_EXPLODE: { // Cause damage to anything near us… } // Check out hit points if( m_HitPoints == 0 ) { m_State = AI_EXPLODE; }

void Ai::Update( void ) { switch( m_State ) { case AI_SPAWN: { // Initial Setup Setup(); m_State = AI_IDLE; break; } case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::RayCast( m_Pos, GetPlayerPos() ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } case AI_ATTACK: { // Find a path to the player Collision::Path Path = Collision::FindPath( m_Pos, GetPlayerPos() ); // Update our position to move towards the player Move( Path ); // Check if we are close to the player Vector Distance = GetPlayerPos() - m_Pos; if( Distance.Magnitude() < 1.0f ) { m_State = AI_EXPLODE; } break; } case AI_EXPLODE: { // Cause damage to anything near us… } // Check out hit points if( m_HitPoints == 0 ) { m_State = AI_EXPLODE; } There might be dragons What if the collision system is accessed by multiple threads? Threading AI

void Ai::Update( void ) { switch( m_State ) { case AI_SPAWN: { // Initial Setup Setup(); m_State = AI_IDLE; break; } case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::RayCast( m_Pos, GetPlayerPos() ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } case AI_ATTACK: { // Find a path to the player Collision::Path Path = Collision::FindPath( m_Pos, GetPlayerPos() ); // Update our position to move towards the player Move( Path ); // Check if we are close to the player Vector Distance = GetPlayerPos() - m_Pos; if( Distance.Magnitude() < 1.0f ) { m_State = AI_EXPLODE; } break; } case AI_EXPLODE: { // Cause damage to anything near us… } // Check out hit points if( m_HitPoints == 0 ) { m_State = AI_EXPLODE; } What if multiple threads are running Move? There might be dragons Threading AI

There might be dragons void Ai::Update( void ) { switch( m_State ) { case AI_SPAWN: { // Initial Setup Setup(); m_State = AI_IDLE; break; } case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::RayCast( m_Pos, GetPlayerPos() ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } case AI_ATTACK: { // Find a path to the player Collision::Path Path = Collision::FindPath( m_Pos, GetPlayerPos() ); // Update our position to move towards the player EnterCriticalSection( &critical_section ); Move( Path ); LeaveCriticalSection( &critical_section ); // Check if we are close to the player Vector Distance = GetPlayerPos() - m_Pos; if( Distance.Magnitude() < 1.0f ) { m_State = AI_EXPLODE; } break; } case AI_EXPLODE: { // Cause damage to anything near us //... } //... } We could add a critical section. But this makes all AI in AI_ATTACK block on each other. Threading AI

Move Collision First one there wins Uses exact positions Path data is read/write First one there wins Uses positions from last frame Path data is read only, update at end of frame Processed in order Cache data Environment is read/write Serial Parallel Processed out of order Use data from last frame Environment is read only Threading AI Clearly define interactions

Move Collision First one there wins Uses exact positions Path data is read/write First one there wins Uses positions from last frame Path data is read only, update at end of frame Processed in order Cache data Environment is read/write Serial Parallel Processed out of order Use data from last frame Environment is read only Threading AI Clearly define interactions

Move Collision First one there wins Uses exact positions Path data is read/write First one there wins Uses positions from last frame Path data is read only, update at end of frame Processed in order Cache data Environment is read/write Serial Parallel Processed out of order Use data from last frame Environment is read only Threading AI Clearly define interactions

Let someone else worry about it! We used Havok Physics™ for Smoke to process all collisions and character movement and it’ll enforce good results. Move Collision First one there wins Uses exact positions Path data is read/write First one there wins Uses positions from last frame Path data is read only, update at end of frame Processed in order Cache data Environment is read/write Serial Parallel Processed out of order Use data from last frame Environment is read only Threading AI Clearly define interactions

Why deal with it? Move Collision AI If Move/Collision can update on last frame’s data… Threading AI

Why deal with it? Move Collision AI If Move/Collision can update on last frame’s data… Threading AI

Why deal with it? Move Collision AI If Move/Collision can update on last frame’s data… Threading AI

Agenda Define a Simple AI Challenge Threading AI Working in a Multithread Land Smoke: Multithread Land Summary

Getting a job in Multithread Land Multithread Land How do we get collisions running independent of AI? Issue early, use late Deferred requests Task stealing

void Ai::Update( void ) { switch( m_State ) { case AI_SPAWN: { // Initial Setup Setup(); m_State = AI_IDLE; break; } case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::RayCast( m_Pos, GetPlayerPos() ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } case AI_ATTACK: { // Find a path to the player Collision::Path Path = Collision::FindPath( m_Pos, GetPlayerPos() ); // Update our position to move towards the player Move( Path ); // Check if we are close to the player Vector Distance = GetPlayerPos() - m_Pos; if( Distance.Magnitude() < 1.0f ) { m_State = AI_EXPLODE; } case AI_EXPLODE: { // Cause damage to anything near us //... } // Check out hit points if( m_HitPoints == 0 ) { m_State = AI_EXPLODE; } Let’s look at collision Multithread Land

Issue early, use late void Ai::PreUpdate( void ) { switch( m_State ) { case AI_IDLE: { // Issue collision check m_Handle = Collision::RayCast( m_Pos, GetPlayerPos() ); break; } void Ai::Update( void ) { switch( m_State ) { case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::GetResult(m_Handle ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } // … } Block if results are not ready Multithread Land

Issue early, use late void UpdateAI( void ) { #pragma omp parallel for for( int Index = 0; Index < g_Num_AI; Index++ ) { g_AI_Array[ Index ].Update(); } Multithread Land

Issue early, use late void UpdateAI( void ) { // Process all PreUpdates #pragma omp parallel for for( int Index = 0; Index < g_Num_AI; Index++ ) { g_AI_Array[ Index ].PreUpdate(); } // Process all Updates #pragma omp parallel for for( int Index = 0; Index < g_Num_AI; Index++ ) { g_AI_Array[ Index ].Update(); } Multithread Land

Deferred requests void Ai::PreUpdate( void ) { switch( m_State ) { case AI_IDLE: { if( !m_Hande ) { // Issue collision check if none are pending m_Handle = Collision::RayCast( m_Pos, GetPlayerPos() ); } break; } void Ai::Update( void ) { switch( m_State ) { case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::GetResult(m_Handle ); if( Result && Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } // … } Don’t block if results are not ready… just wait until next frame Multithread Land

Task stealing void Ai::PreUpdate( void ) { switch( m_State ) { case AI_IDLE: { if( !m_Hande ) { // Issue collision check if none are pending m_Handle = Collision::RayCast( m_Pos, GetPlayerPos() ); } break; } void Ai::Update( void ) { switch( m_State ) { case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::GetResult(m_Handle ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } // … } If results are not ready, have this thread start processing collision request. Multithread Land

Task stealing void Ai::PreUpdate( void ) { switch( m_State ) { case AI_IDLE: { if( !m_Hande ) { // Issue collision check if none are pending m_Handle = Collision::RayCast( m_Pos, GetPlayerPos() ); } break; } void Ai::Update( void ) { switch( m_State ) { case AI_IDLE: { // Check is we can see the player Collision::Result Result = Collision::GetResult(m_Handle ); if( Result.m_Hit == GetPlayerID() ) { m_State = AI_ATTACK; } break; } // … } If results are not ready, have this thread start processing collision request. Multithread Land Optimizing Game Architectures with Intel Threading Building Blocks (Brad Werth) 4:30 PM – 5:30 PM in Room 2011, West Hall

Agenda Define a Simple AI Challenge Threading AI Working in a Multithread Land Smoke: Multithread Land Summary

Smoke is a Multithread Land! Smoke Framework built by Intel for N-threads Demo uses real game technologies: Havok, FMOD, Ogre3D, DX9, animation, AI, and procedural content Well partitioned and configurable

AI Graphics How is Smoke threaded? Framework Change Control Manager Physics Interfaces Managers Environment Platform... Scheduler Task Manager Job Pool Scheduler updates each system every frame Change Control Manager traffics changes between systems Interfaces define interaction Smoke

AI Graphics How is Smoke threaded? Framework Change Control Manager Physics Interfaces Managers Environment Platform... Scheduler Task Manager Job Pool Scheduler calls into each system to update Smoke

AI Graphics How is Smoke threaded? Framework Change Control Manager Physics Interfaces Managers Environment Platform... Scheduler Task Manager Job Pool Each system divides its work and adds jobs to the job pool The Scheduler creates one worker thread per core on the platform Smoke

AI Graphics How is Smoke threaded? Framework Change Control Manager Physics Interfaces Managers Environment Platform... Scheduler Task Manager Job Pool If a system makes a change that other systems need to know about, it posts that change to the Change Control Manager This allows systems to run independently Smoke

AI Graphics How is Smoke threaded? Framework Change Control Manager Physics Interfaces Managers Environment Platform... Scheduler Task Manager Job Pool When all the jobs are processed, the Change Control Manager distributes changes 1 2 Smoke

How does AI work in Smoke? AI Task Scene Object... Framework Scheduler Interfaces Object When it’s time to update the frame, the Schedule calls into the AI system and tells it to update Smoke

How does AI work in Smoke? AI Task Scene Object... Framework Scheduler Interfaces Object The task updates the scene by dividing all the AIs into job. These jobs are put into the job pool in the Scheduler and farmed out to worker threads. Smoke

How does AI work in Smoke? AI Scene Object... Framework Scheduler Interfaces Object Each Object is an AI Each AI type has a state machine Each AI can have one or more goals. Goals are shared functionality between AI types State Machine Goal... Task Smoke

AI How does AI work in Smoke? Object AI Objects post changes as needed. Physics wants to know about velocity changes. Graphics wants to know about position changes from Physics. State Machine Goal... Physics (Havok) Graphics (Ogre3D) Object Smoke

Summary Thread your AI with data decomposition To maximize AI you need to thread Design AI to work with “remote” system Download Smoke at Whatif.intel.com

Q/A Summary Does multithreaded AI imply non- deterministic AI? Can scripting support threaded AI? ???

For More Information See Intel at GDC: –Intel Booth at Expo, North Hall –Intel Interactive Lounge – West Hall 3 rd floor Take a collateral DVD –Here in the room! –Intel Booth or Interactive Lounge

Get the “Story Behind the Story” Investing in Talent and Technology See What’s New Developers Connecting with Intel Engineers Training the Next Generation Enhance Your Products and Your Business The gateway to Intel’s worldwide technology, engineering and go-to-market support for Visual Computing developers

GDC Wednesday, March 25 –Intel’s New Graphics Performance Analyzers 2:30 PM – 3:30 PM in Room 3004, West Hall –Kaboom: Real-Time Multi-Threaded Fluid Simulation for Games 4:00 PM – 5:00 PM in Room 2011, West Hall

More GDC Thursday, March 26 –Who Moved the Goalposts? The Rapidly Changing World of CPU’s and Optimization 1:30 PM – 2:30 PM in Room 2011, West Hall –Taming Your Game Production Demons: the Offset approach 3:00 PM – 4:00 PM in Room 2011, West Hall –Optimizing Game Architectures with Intel Threading Building Blocks 4:30 PM – 5:30 PM in Room 2011, West Hall

Last of GDC Friday, March 27 –Procedural and Multi-Core Techniques to take Visuals to the Next Level 9:00 AM – 10:00 AM in Room 2010, West Hall –Rasterization on Larrabee: A First Look at the Larrabee New Instructions (LRBni) in Action 9:00 AM – 10:00 AM in Room 135, North Hall –SIMD Programming on Larrabee: A Second Look at the Larrabee New Instructions (LRBni) in Action 10:30 AM – 11:30 AM in Room 3002, West Hall

 INFORMATION IN THIS DOCUMENT IS PROVIDED IN CONNECTION WITH INTEL® PRODUCTS. NO LICENSE, EXPRESS OR IMPLIED, BY ESTOPPEL OR OTHERWISE, TO ANY INTELLECTUAL PROPERTY RIGHTS IS GRANTED BY THIS DOCUMENT. EXCEPT AS PROVIDED IN INTEL’S TERMS AND CONDITIONS OF SALE FOR SUCH PRODUCTS, INTEL ASSUMES NO LIABILITY WHATSOEVER, AND INTEL DISCLAIMS ANY EXPRESS OR IMPLIED WARRANTY, RELATING TO SALE AND/OR USE OF INTEL® PRODUCTS INCLUDING LIABILITY OR WARRANTIES RELATING TO FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, OR INFRINGEMENT OF ANY PATENT, COPYRIGHT OR OTHER INTELLECTUAL PROPERTY RIGHT. INTEL PRODUCTS ARE NOT INTENDED FOR USE IN MEDICAL, LIFE SAVING, OR LIFE SUSTAINING APPLICATIONS.  Intel may make changes to specifications and product descriptions at any time, without notice.  All products, dates, and figures specified are preliminary based on current expectations, and are subject to change without notice.  Intel, processors, chipsets, and desktop boards may contain design defects or errors known as errata, which may cause the product to deviate from published specifications. Current characterized errata are available on request.  Performance tests and ratings are measured using specific computer systems and/or components and reflect the approximate performance of Intel products as measured by those tests. Any difference in system hardware or software design or configuration may affect actual performance.  Intel, Intel Inside, and the Intel logo are trademarks of Intel Corporation in the United States and other countries.  *Other names and brands may be claimed as the property of others.  Copyright © 2009 Intel Corporation. Legal Disclaimer

Risk Factors This presentation contains forward-looking statements. All statements made that are not historical facts are subject to a number of risks and uncertainties, and actual results may differ materially. Please refer to our most recent Earnings Release and our most recent Form 10-Q or 10-K filing available on our website for more information on the risk factors that could cause actual results to differ.