Physics Parallelization. Erwin Coumans SCEA

Transcription

1 Physics Parallelization A B C Erwin Coumans SCEA

2 Takeaway Multi-threading the physics pipeline collision detection and constraint solver Refactoring algorithms and data for SPUs Maintain unified multi-platform codebase SPU task maps well to multi-core thread

3 Parallelism and SPUs Both data and code needs to fit in 256kb DMA transfer to upload code and data Similar to GPU shader and texture upload Hide latency using double buffering Upload next batch while processing current Patterns for Parallel Programming [TM2005]

4 Broadphase N-Body Find potential overlapping pairs O (n2) number of pairs in theory But O (n) in practice

5 Broadphase Methods Uniform Grid Octree, BSP tree Spatial Hashing Multi-resolution Sweep and Prune Incremental Full sort (radix/quicksort)

6 Uniform Grid Can be parallelized on GPU What cell size to use?

7 Voxelize objects Performance versus Precision

8 Sweep and Prune (SAP) Incremental version has data dependencies Sometimes, the best serial algorithm has poor parallel scalability [Intel07]

9 Parallel sorted SAP Array-based sorting [CE2005] Split each axis array into segments Sort segments in parallel and merge Traverse array to find all overlapping pairs

10 Parallel sorted SAP Need method to check overlap on other axis Perform full AABB check Compare array-indices instead of begin/endpoint values

11 Pair management Broadphase either: 1) Rebuild all pairs from scratch 2) Incrementally add/remove pairs

12 Adding/removing pairs 1) Use hash map to find existing pairs 2) Index into uniform grid (GPU) 3) Avoid random access find

13 Sort and cull pairs sort check overlap, remove duplicates next frame: sort 0 Perform AABB overlap check during traversal Mark non-overlapping pairs zero Look forward for duplicates

14 Pairwise Collision Dispatch Collision pairs are independent: embarrassingly parallel More culling needed for complex objects: AABB trees Output: contact points

15 Load balancing collision detection Broadphase is producer, mid/narrowphase multiple consumers Evenly distribute work, avoid synchronization Consume pairs while they are produced

16 Exceptions Deal with user callbacks Collision filter callback (needs collision yes/no?) Serial fallback for unhandled cases (PPU)

17 Concave Shapes: AABB trees Make big tree fit cache/spu Avoid random access due to recursion Output can go to narrow phase collision detector

18 Tree to array mapping Streaming large trees in parts Stackless traversal [EG2007]

19 Recursive versus Stackless void recursetree(node* node, Aabb* aabb) { if (testoverlap(node,aabb)) { if (isleafnode(node)) donarrowphase(node); else { recursetree (node->leftchildnode); recursetree (node->rightchildnode); } } } void iteratetree(node* node, Aabb* aabb) { int curindex=0; while (curindex < endnodeindex) { aabboverlap = testoverlap(node,aabb); if (aabboverlap ) { if (isleafnode(node)) donarrowphase(node); } if (aabboverlap isleafnode(node)) node++; curindex++; else { node += node->escapeindex; curindex += node->escapeindex; } } } }

20 Narrowphase collision algorithms Code size can become an issue for SPUs Can load/unload code using overlays or SPU Shaders [MA2008] Or use compact general purpose algorithms

21 Convex: GJK and EPA

22 GJK and EPA on SPUs See Gino van den Bergen s book [Ber2003] Virtual methods like getsupportingvertex Refactor into switch statement EPA polytope expansion can exceed memory Use PPU fallback or other solution like SAT or Minkowski sampling

23 Contact Point Allocation Incremental or from scratch each frame Memory pre/de/re/allocation can be a big deal We preallocate fixed-size cache (4 points) for each pair

24 SPU & Contact Point Caching Contact cache is input and output Find/update existing points Perform contact reduction (to 4 points) on SPU

25 Solver parallelization Constraint solving methods using large matrices won t fit Use iterative methods [Catto2005] Sequental Impulse or Projected Gauss Seidel Constraints share rigidbodies: not embarrassingly parallel

26 Each island in parallel Works well, islands are independent Doesn t parallelize large islands, load imbalance Overhead for small, single body islands

27 Grouping based on spatial hash 1D Array of Cells (N=NUM_BUCKETS) getcellindex (x,y,z) N1 Calculate cell dependency table Process cells in parallel, using table to avoid conflicts

28 Spatial hash function //compute hash bucket index in [0,NUM_BUCKETS-1] int32 getcellindex (int32 cellpos_x,int32 cellpos_y, int32 cellpos_z) { const int32 h1 = 0x8da6b343; //Large primes const int32 h2 = 0xd ; const int32 h3 = 0xcb1ab31f; int32 n = h1*cellpos_x + h2*cellpos_y + h3*cellpos_z; n = n%num_buckets; if (n<0) n+=num_buckets; return n; } //Example from Christer Ericson s book Real-time collision detection.

29 Reordering constraints [Intel07] C c3 c2 A B c1 c1 c2 C c2 c3 D B c1 D c4 c3 c4 c4 A c1 c1 c3 c3 c4 c2 c2 c4

30 Insomniac vs Bullet SPU Physics SPU physics pipeline comparison presentation is available online from Insomniac Tech website [IN2008]

31 References [Intel07] High-Performance Physical Simulations on Next-Generation Architecture with Many Cores, August 2007, Intel Technology Journal, com/technology/itj/2007/v11i3/8-simulations/1-abstract.htm [EG2007] Stackless KD-Tree Traversal for High Performance GPU Ray Tracing, Proceeding of Eurographics, [MA2008] SPU Shaders, Mike Acton, Insomniac Games, Game Developers Conference 2008, com/tech [Catto2005] Erin Catto, [IN2008] Insomniac and SCEA talk SPU Physics, insomniacgames.com/tech/articles/0108/insom_and_scea_talk_spu_physics.php

32 Books [TM2005] Patterns for Parallel Programming, Timothy Mattson et.al. Addison Wesley [CE2005] Real-time Collision Detection, Christer Ericson, Morgan Kaufmann, page 336 [Ber2003] Collision detection in interactive 3D environments, Gino van den Bergen, Morgan Kaufmann [PBA2005] Physics Based Animation, Kenny Erleben et. al. Charles River Media, page 613

33 Bullet physics library An open source 3D physics engine Written in C++ Parallelized for SPU and other architectures Check out SCEA booth #5905 at GDC Expo SPU optimized Game Physics Licensed PlayStation 3 developers can request access to SPURS version