Dependency Graph Scheduling in a Ray Tracing Architecture

1
Dependency Graph Scheduling in a Ray Tracing
Architecture

• Susan Frank and Arie Kaufman
• Center for Visual Computing
• Department of Computer Science
• State University of New York at Stony Brook, USA

2
Why use ray tracing?

• Global illumination
• Unifying technique for volumes
• Processing and rendering
• Triangles, points, implicit surfaces etc.
• Early ray termination
• Scene complexity independence
• Inherently parallel

3
Why not use ray tracing?

• Non-uniform memory access
• Need spatial coherence

4
Ray Tracing Systems

• Ray Queues Pharr et al. 97
• GI-Cube Dachille, Kaufman 00
• Pyramid clipping and octree subdivision Reinhard
  et al. 99
• Kilauea system Nishimura et al. 01
• AR250 ART 99
• Coherent Ray Tracing Wald, et al. 2001

5
Outline

• Our System
• Cell Tree
• Dependency Graph Scheduling
• Peel Algorithm
• Results

6
GI-Cube Architecture
DSP
PCI Bus
SDRAM
Ray Bus
Block Processor
Block Processor
Block Processor
Block Processor
800MHz
RDRAM
RDRAM
RDRAM
RDRAM
7
Single Processor
Frame Buffer
Block Processor
DSP
Main Memory
Ray Bus
PCI Bus
SDRAM
RDRAM
CPU
8
Ray Queues

• Maintain ray queue for each cell
• Process all rays while a cell is in cache
• Spawned rays added to queue of next intersected
  cell

Subdivide Volume Into Cells
9
Our Scheduling Schema

• Cell Tree
• Ray-cell dependencies from frame i used to create
  schedule for frame i1
• Max Work
• First frame (ray dependencies unknown) and if
  rays remain after Cell Tree schedule
• Any level of the memory hierarchy
• Cell size set to memory size

10
Outline

• Our System
• Cell Tree
• Dependency Graph Scheduling
• Peel Algorithm
• Results

11
Psuedo-Random Ray Traversal
12
Cell Tree

• Gathers clusters of rays as theyre generated
• Concisely describes all ray-cell dependencies of
  completed frame
• 100 times fewer nodes than rays represented
• Predict better schedule for next frame

13
Cell Tree Creation

• Initialize
• Maintain CellTreeNode in Ray Packet
• Add nodes to Cell Tree as needed to represent
  ray-cell dependencies

14
Ray Packet
256
Position X
Position Y
Position Z
Direction X
196
Direction Z
Direction Y
Destination U
Lifetime
Destination V
128
Contribution
Ray ID
Generation
Opacity
64
Red
CellTreeNode
Type
Cell
Interaction
Green
Blue
0
0
4
8
12
16
20
24
28
32
15
Initialization
1
root
4
5
0
1
7
6
3
2
16
Initialization
1
root
4
5
0
1
7
6
3
2
17
Initialization
1
root
2
4
5
0
1
7
6
3
2
18
Initialization
1
root
2
4
5
0
1
7
6
3
2
19
Reflections Refractions and Shadows
1
root
1
2
5
4
0
1
7
6
3
2
20
Reflections Refractions and Shadows
1
root
1
2
5
4
0
1
7
6
3
2
21
Reflections Refractions and Shadows
1
root
1
2
5
5
4
0
1
7
6
3
2
22
Reflections Refractions and Shadows
1
root
1
2
5
5
4
0
1
7
6
3
2
23
Reflections Refractions and Shadows
2
1
root
1
2
5
5
4
0
1
7
6
3
2
24
Reflections Refractions and Shadows
2
1
root
1
2
5
5
4
0
1
7
6
3
2
25
Secondary Reflections
2
1
2
root
1
2
5
5
4
0
1
7
6
3
2
26
Secondary Reflections
2
1
2
root
1
2
5
5
4
0
1
7
6
3
2
27
Secondary Reflections
2
1
2
root
1
2
2
5
5
4
0
1
7
6
3
2
28
Secondary Reflections
1
2
1
2
root
1
2
2
5
5
4
0
1
7
6
3
2
29
Outline

• Our System
• Cell Tree
• Dependency Graph Scheduling
• Peel Algorithm
• Results

30
Task Scheduling Problem

• Goal - minimize memory fetches
• Equivalently - minimize color changes in super
  sequence which contains all sequences

31
Cyclic Dependency Graphs

• Rays must visit cells in a particular order

• A ray may revisit a cell several times

• Sub-volume must be cached each time

Cell 0
Cell 1
Cell 3
Cell 2
32
Cache Saving Links
4
3
2
0
1
feasible schedule - all rays can be processed in
required order
5
1
1
3
root
0
6
2
0
2
3
1
conflict - no feasible schedule contains both
links
7
3
1
33
Cache Saving Links
4
2
0
1
5
1
1
3
root
0
6
2
0
2
optimal schedule - maximal group of
non-conflicting links
3
1
7
3
1
34
Chains
4
2
0

• Chain of non-conflicting links may produce a
  non-feasible schedule

1
5
1
1
3
root
0
6
2
0
2
3
1
7
3
1
35
Multiple Chains
4
2
0

• A combination of chains may also produce a
  non-feasible schedule

1
5
1
1
3
root
0
6
2
0
2
3
1
7
3
1
36
Definitions
3
0
1

• generation(node) - nodes between root and node
  with same cell as node
• maxGen(cell) - max number of times any ray enters
  cell

5
1
3
1
3
root
2
3
2
1
1
3
2
1
3
1
3
37
Optimal Bound
3
0
1

• schedule size gt
• ? maxGen(cell)

5
1
3
1
cells
3
root
2
3
2
1
1
3
2
1
3
1
3
38
Outline

• Our System
• Cell Tree
• Dependency Graph Scheduling
• Peel Algorithm
• Results

39
Peel Algorithm

• Peel tree leaves to create reverse schedule
• Gather cache savings links

40
Completion Peel
3
0
1

• Remove ready cell leaf nodes from tree and add it
  to schedule

5
1
3
1
3
root
2
3
2
1
1
3
2
ready cell - all the maxGen nodes of a cell are
leaf nodes
1
3
1
3
41
Split Peel
3
0
1

• Remove non-ready cell leaf nodes from tree and
  add it to schedule

5
1
3
1
3
root
2
3
2
1
1
3
2
1
3
1
42
Peel (tree)

• While tree has any nodes
• Does tree have a ready cell c?
• yes - add c to schedule and peel c leaf nodes
• no - Find cellmax with most leaf nodes
  Peel cellmax and add it to schedule
• Return schedule

43
Peel (tree)

• While tree has any nodes
• Does tree have a ready cell c?
• yes - add c to schedule and peel c leaf nodes
• no - Find cellmax with most leaf nodes
• Peel cellmax and add it to schedule
• Return schedule

44
Peel (tree)

• While tree has any nodes
• Does tree have a ready cell c?
• yes - add c to schedule and peel c leaf nodes
• no - Find cellmax with most leaf nodes
• Peel cellmax and add it to schedule
• Return schedule

45
Peel (tree)

• While tree has any nodes
• Does tree have a ready cell c?
• yes - add c to schedule and peel c leaf nodes
• no - Find cellmax with most leaf nodes
  
• Peel cellmax and add it to schedule
• Return schedule

46
Peel (tree)

• While tree has any nodes
• Does tree have a ready cell c?
• yes - add c to schedule and peel c leaf nodes
• no - Find cellmax with most leaf nodes
• Peel cellmax and add it to schedule
• Return schedule

47
4
2
0
1
5
1
1
3
root
6
2
0
0
2
3
1
7
3
1
48
4
2
0
5
1
3
root
6
2
0
0
2
3
7
3
49
2
0
5
1
3
root
6
2
0
0
2
3
7
3
50
2
0
1
3
root
6
2
0
0
2
3
7
3
51
2
0
1
3
root
2
0
0
2
3
7
3
52
2
0
1
3
root
2
0
0
2
3
3
53
2
0
1
3
root
2
2
3
3
54
0
1
3
root
2
3
3
55
0
1
root
2
56
1
root
2
57
root
2
58
Algorithm Performance

• Guaranteed feasible
• Not guaranteed optimal
• Worst time O(n)
• Improvement over Max Work
• Hardware implementation reasonable

59
Outline

• Our System
• Cell Tree
• Dependency Graph Scheduling
• Peel Algorithm
• Results

60
Tests

• C simulation
• SGI 02/RISC 10000 128MB
• Volumes split into 8 cells and 27 cells
• Image resolution 2562

61
(No Transcript)
62
(No Transcript)
63
(No Transcript)
64
Cell Tree Sizes
 
65
30 Fewer Fetches
 
66
Conclusion

• Cell Tree captures all ray-cell dependencies
• Dependency graph based algorithm significantly
  improves cache performance

67
Future Work

• Dynamic load balance
• Dynamic volume subdivision
• Multi-level memory hierarchy
• Limited depth recursion

68
Acknowledgments

• ONR Grant N00140110034
• NYSTAR Grant COD0057
• CES Computer Solutions Inc.
• Kevin Kreeger, Frank Dachille, Michael Bender,
  Nan Zhang

69
Thank you!