More explosions, more chaos, and definitely more blowing stuff up

Antoine Cohade & Emil Persson
16/03/2016
More Explosions, More Chaos,
and Definitely More Blowing Stuff Up :
Optimizations and New DirectX Features in

Intel Software – Developer Relations Division Copyright © 2016, Intel Corporation. All rights reserved. * Other names and brands may be
claimed as the property of others.
Legal
Copyright © 2016 Intel Corporation. All rights reserved.
*Other names and brands may be claimed as the property of others.
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.
A "Mission Critical Application" is any application in which failure of the Intel Product could result, directly or indirectly, in personal injury or death. SHOULD YOU PURCHASE OR USE INTEL'S PRODUCTS FOR ANY SUCH MISSION CRITICAL
APPLICATION, YOU SHALL INDEMNIFY AND HOLD INTEL AND ITS SUBSIDIARIES, SUBCONTRACTORS AND AFFILIATES, AND THE DIRECTORS, OFFICERS, AND EMPLOYEES OF EACH, HARMLESS AGAINST ALL CLAIMS COSTS, DAMAGES,
AND EXPENSES AND REASONABLE ATTORNEYS' FEES ARISING OUT OF, DIRECTLY OR INDIRECTLY, ANY CLAIM OF PRODUCT LIABILITY, PERSONAL INJURY, OR DEATH ARISING IN ANY WAY OUT OF SUCH MISSION CRITICAL
APPLICATION, WHETHER OR NOT INTEL OR ITS SUBCONTRACTOR WAS NEGLIGENT IN THE DESIGN, MANUFACTURE, OR WARNING OF THE INTEL PRODUCT OR ANY OF ITS PARTS.
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.
Any code names featured are used internally within Intel to identify products that are in development and not yet publicly announced for release. Customers, licensees and other third parties are not authorized by Intel to use code names
in advertising, promotion or marketing of any product or services and any such use of Intel's internal code names is at the sole risk of the user.
Intel product plans in this presentation do not constitute Intel plan of record product roadmaps. Please contact your Intel representative to obtain Intel’s current plan of record product roadmaps.
Performance claims: Software and workloads used in performance tests may have been optimized for performance only on Intel® microprocessors. Performance tests, such as SYSmark and MobileMark, are measured using specific
computer systems, components, software, operations and functions. Any change to any of those factors may cause the results to vary. You should consult other information and performance tests to assist you in fully evaluating your
contemplated purchases, including the performance of that product when combined with other products. For more information go to
http://www.Intel.com/performance
Iris™ graphics is available on select systems. Consult your system manufacturer.
Intel, Intel Inside, the Intel logo, Intel Core and Iris are trademarks of Intel Corporation in the United States and other countries.

Agenda
- Introduction
- Tools
- Optimizations
- DirectX features
- Future Work
- Conclusion

4
Intel ® HD Graphics: Market Share
72.8%
totalGPUmarket
18.49%
STEAM
23.9%
Unity
Jon Peddie Research, Q3 2015 Steam HW Survey, Jan 2016 Unity HW Stats, Q4 2015
Millions of gamers with Intel ® HD Graphics equipped PCs

5
Introduction: Avalanche Studios
Avalanche Studios
- Founded in 2003
- Offices in Stockholm and New York
Games
- Just Cause 1, 2 and 3
- Mad Max
- theHunter, theHunter: Primal
- Renegade Ops
- Rumble City

6
Introduction: Just Cause 3
• Open world action-adventure game
• Developed by Avalanche Studios
• Published by Square Enix
• Released Dec 1, 2015
• Huge open world
• 1000 km2 or 400 square miles
• Advanced graphics technology

7
About this project
Small targeted development effort
- Collaboration with Intel®
- Focused on Intel® GPU performance optimizations
- DirectX features pioneered by Intel®
- Additional resources (from R&D, Engine etc.)
- Separate from JC3 mainline development

9
GPA: Just Cause 3 Analysis
HUD / System Analyzer:
Frame Analyzer:
Platform Analyzer:
CPU Limited
GPU Limited
Capture
frame
Capture
trace
?Run with
Intel® GPA
Live Analysis Offline Analysis

10
GPA : Just Cause 3 – Platform Analyzer view
Frames
GPU queue
Other metrics
CPU Threads

11
GPA : Just Cause 3 – Frame Analyzer view
Custom view chart
Rendertargetoverview
Render target preview
RT & drawcalls(Erg)
selection & timings
Detailed metrics

Agenda
- Introduction
- Tools
- Optimizations
- DirectX features
- Conclusion

13
Performance Optimizations: Low-Level ALU
Deferred Lighting Shader
- 6-8ms on Iris™ Pro 5200
- Very long shader, lots of math
- Lots of history
Low-Level ALU optimizations
- Tweaking the math to generate fewer instructions
- Low-Level Thinking in High-Level Shading Languages [Persson13]
Low-Level Shader Optimization for Next-Gen and DX11 [Persson14]
- No changes to output

14
Remove a division, use MAD-form:
Separate scalars and vectors:
Precompute:
float k = 2.0f / sqrt(PI * (spec_power + 2.0f)); add + mul + sqrt + rcp + mul
float k = rsqrt((0.25f*PI) * spec_power + (0.5f*PI)); mad + rsqrt
return spec_color * spec_intensity * spec_mask; 6×mul (3+3)
return spec_color * (spec_intensity * spec_mask); 4×mul (1+3)
float3 Color = PointLights[index + 1].rgb;
float HDRScale = PointLights[index + 1].w;
Color *= HDRScale;
3×mul
float3 Color = PointLights[index + 1].rgb; -

15
Optimizing inputs
- 4x float4 for spotlights, partly packed
- LightDir stored in 2 floats + sign
- HDRScale and NearCap, 16bits each in a float
- Unpacking the packed
- Falloff scale and bias was 2 floats
- Compute falloff bias from scale (saved one float, added one ALU op)
- LightDir a full float3 (saves ~10 cycles of unpacking)
- HDRScale gone, NearCap gets entire float (saved 6 ALU ops of unpacking)
- Rearranged in access order
- Fewer fetches if branch not taken

16
Reuse intermediate results:
dist = dot(l_vec, l_vec) * InvRadSqr;
if (dist < 1.0f)
{
l_vec = normalize(l_vec);
dist *= rsqrt(dist);
...
dist = dot(l_vec, l_vec);
if (dist < RadiusSqr)
{
float rd = rsqrt(dist);
l_vec *= rd; // normalize()
dist *= rd;
...
mul + 2×mad + mul
rsqrt + 3×mul
rsqrt + mul
mul + 2×mad
rsqrt + 3×mul
mul

17
Operation modifiers:
float3 tex_proj;
tex_proj = mat[0].xyz * light_vec.x;
tex_proj += mat[1].xyz * light_vec.y;
tex_proj += mat[2].xyz * light_vec.z;
tex_proj *= float3(-1, -1, -1);
float3 tex_proj;
tex_proj = mat[0].xyz * -light_vec.x;
tex_proj += mat[1].xyz * -light_vec.y;
tex_proj += mat[2].xyz * -light_vec.z;
3×mul + 6×mad + 3×mul 3×mul + 6×mad

18
Loop counters:
// Point lights
for (uint pl = 0; pl < pl_count; pl++) {
uint index = LightIndices[light_index++];
...
}
// Spot lights
for (uint sl = 0; sl < sl_count; sl++) {
uint index = LightIndices[light_index++];
...
}
// Point lights
uint end = light_index + pl_count;
for (; light_index < end; ++light_index) {
uint index = LightIndices[light_index];
...
}
// Spot lights
end += sl_count;
for (; light_index < end; ++light_index) {
uint index = LightIndices[light_index];
...
}
2×iadd / loop 1×iadd / loop + 2×iadd

19
Share computations:
if (shadow > 0) {
float2 rot = ExpensivePseudoRandom();
shadow *= SampleShadow(..., rot);
...
}
for (spotlights) {
if (spot > 0) {
if (shadow_caster) {
shadow = SampleShadow(..., rot);
...
}
}
}
if (shadow > 0) {
shadow *= SampleShadow(..., rot);
...
}
for (spotlights) {
if (spot > 0) {
if (shadow_caster) {
shadow = SampleShadow(..., rot);
...
}
}
}

20
Pull computations out of the loop:
for (int i = 0; i < 16; i++) {
float2 offset;
offset.x = kernel[i].x * rot.x +
kernel[i].y * rot.y;
offset.y = kernel[i].y * rot.x –
kernel[i].x * rot.y;
float2 tap = coord.xy + offset * scale;
...
}
rot *= scale;
for (int i = 0; i < 16; i++) {
float2 tap;
tap.x = coord.x + kernel[i].x * rot.x
+ kernel[i].y * rot.y;
tap.y = coord.y + kernel[i].y * rot.x
- kernel[i].x * rot.y;
...
}
(2×mul + 4×mad)×16 (96 ops) (4×mad)×16 + 2×mul (66 ops)

21
Game had configurable attenuation curve
- Not really used. Only one curve existed.
- Using ALU saved 0.2ms on Iris™ Pro 5200.
- Small script to brute-force match a set of functions and parameters
- Picked the best match
- ~1% error
ALU instead of lookup table:
atten = Falloff.SampleLevel(Samp, dist, 0.0f); sample_l
atten = saturate((1.0f - dist) / (dist * dist * 12.21f + 1.0f)); 2×mul + mad + add + rcp

22
Deferred Lighting Shader
- 4-5.5ms on Iris™ Pro 5200
- About 2ms saved (depending on scene)
- Potential for saving more

23
Performance Optimizations: GPU gaps
Learning : Regularly check CPU/GPU concurrency to avoid surprises

24
Performance Optimizations: Instancing
Solution
- Instancing support added to common materials
- Drastic reduction in number of draw calls
- Reduced constant buffer updates
- Removed lots of unused constants
- Removed debug constants, tweak variables etc.

25
Performance Optimizations: Instancing

26
Performance Optimizations: Manual Instancing
Tree Impostors
- Many instances, tiny mesh. (4 vertices, 6 indices)
- Standard instancing implementation
- DrawIndexedInstanced(6, num_instances, 0, 0, 0);
- Poor wavefront occupancy
Manual Instancing optimization
- Draw as regular indexed mesh
- DrawIndexed(6 * num_instances, 0, 0);
- Immutable index buffer of MAX_INSTANCES * 6
- Manually fetch data from texture buffer

27
v2p main(a2v In, uint VertexID: SV_VertexID) {
...
}
struct InputData {
float Elevation;
float2 Data;
};
StructuredBuffer<InputData> Insts;
v2p main(uint VertexID: SV_VertexID) {
uint InstanceID = VertexID >> 2;
VertexID = VertexID & 0x3;
// Manually fetch vertex data
a2v In;
In.Elevation = Insts[InstanceID].Elevation;
uint2 prt = asuint(Insts[InstanceID].Data);
In.Data.x = int(prt.x & 0xFFFF) * scale;
In.Data.y = int(prt.x >> 16) * scale;
In.Data.z = int(prt.y & 0xFFFF) * scale;
In.Data.w = int(prt.y >> 16) * scale;
...
}

28
Manual Instancing
- 2.4ms before, 0.7ms after, on Iris™ Pro 5200

29
Performance Optimizations: Vegetation stalls

30
Performance Optimizations: Stencil stalls
Learning: If vegetation rendering seems abnormally long, try disabling stencil writes.
If the rendering speeds up significantly, you are impacted.

31
Performance Optimizations: Stencil stalls

32
Performance Optimizations: Forest Layer
Forest Layer
- Lowest LOD tree representation
- Provides forest silhouette in distance
- Alpha texture filling in detail
Dense grid mesh
- 129x129 per patch
- 5ms in some scenes
- Stencil writes enabled, but disabling didn’t help

33
Optimization
- Mostly Vertex Bound
- Mesh optimizations
- Added 65x65 and 33x33 LODs
- Large reduction in total vertices shaded
- Small visual difference. High settings mostly use highest LODs.
- Packed vertex format (2 floats → 2 shorts)
- 16bit index buffer

34
Optimization
- Shader optimizations
- Added a simpler “no-fade” vertex shader, used by most patches
- Pre-computations
- Prebaked scaling into the world matrix
- Folded constants
- Handful of low-level optimizations
- Simplified math

35
Results
- Good performance gain
- Down from 5.0ms to 2.5ms, Iris™ Pro 5200
- Revisited disabling stencil writes
- Down to 0.5ms (!!)
- Revisited triangle strips
- Down to 0.4ms
- More than an order of magnitude faster in the end!

36
Performance Optimizations: Low/normal settings
Optimize lower graphical settings
- Shadow size culling
- Made dependent on shadow buffer size
- Disabled cloud shadows for low shadow settings
- Velocity buffer rendering
- Disabled when motion blur and temporal AA is disabled
- Disabled planar reflection pass when screen-space reflection is enabled

37
Performance Optimizations: Buffer Clears
G-Buffers
- Cleared to (0.5f, 0.5f, 1.0f, 1.0f) for historical reasons
- Now clears to (0, 0, 0, 0), or skipped entirely
- Still clearing for SLI / CrossFire
- Screen space reflections
- Only clear when enabled and needed

38
Performance Optimizations: Shadows
Shadow Cascades
- 4 sun shadow cascades
- Scattered update pattern
- 2 cascades / frame, cycled over 8 frames
- Saves many milliseconds
- Problematic for camera flipping (shadows pop in over a few frames)
- Center outer cascade on camera
- Keeps shadow behind player (in theory)
- Have to disable frustum culling for outer cascade
- Many milliseconds lost
- Lost shadow range

39
3,747.0

40
Solution
- Revert to previous outer cascade
- Restores lost milliseconds
- Restores lost shadow range
- Reset refresh cycle on camera flip
- Outer cascade always gets updated first frame after flip
- Added resolution dependent size culling

41
718.0

42
Performance Optimizations: float3x4
Convert float4[] to float3x4[]:
float4 MatrixPalette[2 /*(SIZE*3)*/];
index *= 3;
float3x4 mat = float3x4(
MatrixPalette[index ],
MatrixPalette[index + 1],
MatrixPalette[index + 2]);
float3 s_pos = mul(mat, pos);
...
float3x4 MatrixPalette[2 /*SIZE*/];
float3x4 mat = MatrixPalette[index];
float3 s_pos = mul(mat, pos);
...
imad r2.xy, v1.xx, l(3, 3), l(1, 2)
dp4 r0.x, cb0[r0.x + 9], r1
dp4 r0.y, cb0[r2.x + 9], r1
dp4 r0.z, cb0[r2.y + 9], r1
...
imul null, r0.x, v1.x, l(3)
dp4 r2.x, cb0[r0.x + 9], r1
dp4 r2.y, cb0[r0.x + 10], r1
dp4 r2.z, cb0[r0.x + 11], r1
...

43
Performance Optimizations: Terrain optimization

44
Solution
- Terrain system continuously developed
- New system was in the build, but disabled by default
- Saved around 1-2 milliseconds depending on scene
- Unstable on some drivers
- Detect old drivers and fall back to previous system

45

46
Performance Optimizations: Misc
Misc optimizations
- CPU vs. GPU performance very different on Intel vs. the consoles
- Moved some work back to CPU
- Shorter shader, more computations for CPU
- Better culling
- When all waterboxes are culled, we could save a render pass

Performance Optimizations: Final Results
Performance benefits: Rendering time* (ms)
Performance benefits: Real performance* (ms) – impact of power
Car scene City scene Sky scene
Before 51 59 59
After 27 32 28
Delta 24 ms 27 ms 31 ms
Car scene City scene Sky scene
Average frame time (static) 27 32 28
Average frame time (dynamic) 30 35 30
*Measured on a 5th gen core™ i7 with Iris™ pro graphics 6200 @ 1366x768 Medium settings

49
Conservative Rasterization
Light assignment using CR [Örtegren16]
- Shell pass
- Lights as low-res meshes
- CR to touch all affected clusters
- Allows arbitrary convex light shapes
- “Perfect clustering”
- MIN blending resolves depth range
- Fill pass
- Writes results to cluster light lists

50
Conservative Rasterization
Light list
- Max 256 lights per type
- JC3: Tightly packed list of light indexes [ 2, 7, 12, 38 … ]
- [Örtegren16]: Linked list (2, next)→ (7, next)→ …
- New approach: Bitfield 001000010000100000 …
- Performance
- Bitfield: Faster under heavy load (0.5ms), slower under light load (-0.2ms)
- LA: 0.1 - 0.3ms cost. Shading: 0 - 3ms saved. (6gen core w/ HD Graphics 520)
- Shell pass independent of depth slice count
- Can scale to higher slice count

UAV & Rastered Order Views 101
• The DX API specifies “in order” processing rules
• UAV’s enable arbitrary R/W memory ops from a
pixel shader…

52
pixel shader…
… but no ordering of data input…
shade fragment from 1st triangle r/m/w
shade fragment from 2nd triangle r/m/w
Timeline
data
race
e.g. programmable
blending

53
pixel shader…
Timeline
order is not
deterministic
e.g. programmable
blending

54
pixel shader…
• ROV is a DX12 feature which guarantees primitive
order for R/M/W operations and :
• Avoid data races
• Ensure deterministic ordering
Timeline
Wait
data is
Safe !

Order-Independent Transparency
• Correct compositing, rendering foliage &
fences with zero aliasing !
• Raster Ordered View enable a new
approach
 Single geometry pass and fixed memory requirements
 Stable and predictable performance
 Scalable: easily trade-off image quality for
performance/memory
Correct
render
order
Different
correct
render
order

Order-Independent Transparency
• Store Visibility Function as a sorted fixed-
size array of nodes, in a UAV surface
• Sort N Layers, blend furthest fragments
• Use more layers to trade-off image quality
for perf/memory
Sample code : https://software.intel.com/en-us/articles/oit-approximation-with-pixel-synchronization-update-2014
New fragment insertion
Blending of furthest
fragments

58
Future Work: Frame time variance
0
5
10
15
20
25
30
35
40
45
50
1
79
157
235
313
391
469
547
625
703
781
859
937
1015
1093
1171
1249
1327
1405
1483
1561
1639
1717
1795
1873
1951
2029
2107
2185
2263
2341
2419
2497
2575
2653
2731
2809
2887
2965
3043
3121
3199
3277
3355
3433
3511
3589
3667
3745
3823
3901
3979
FrameTime(ms)
Frame number
JC3 Frame time variation over a 2 minutes gameplay
Frame time - 10 frames moving average PW = 33.3ms

59
Future Work: Dynamic resolution rendering
• Idea : for the most intense scene, lower the rendering resolution
• Based on an Intel sample:
https://software.intel.com/en-us/articles/dynamic-resolution-rendering-sample
if (frametime > max_allowed_frametime && render_target_size != min_RT_size)
render_target_size--;
if (frametime < min_allowed_frametime && render_target_size != max_RT_size)
render_target_size++;

60
Future Work: G-buffer blending
• To apply tire skid marks, bullet holes or explosions!
• Same principle that AOIT
– Render your G-Buffer
– Take a normal map of a decal
– Blend it with the G-Buffer
– Result will be a correctly mapped bullet hole
• Prototyped in JC3
• Requires alpha blendable decals

62
Conclusion
• Even the most demanding titles, such as JC3, can run on Iris graphics
• Feature-wise, integrated graphics are now on par with discrete
• Focused optimizations can bring terrific improvements ...
• … you have tools to help you …
• … and is definitely worth it 

63
References
[Persson13] Low-Level Thinking in High-Level Shading Languages, GDC 2013
presentation. http://humus.name/index.php?page=Articles&ID=6
[Persson14] Low-Level Shader Optimization for Next-Gen and DX11, GDC 2014
presentation. http://humus.name/index.php?page=Articles&ID=9
[Örtegren16] Clustered Shading: Assigning Lights Using Conservative
Rasterization in DirectX 12. GPU Pro 7.

More explosions, more chaos, and definitely more blowing stuff up

More explosions, more chaos, and definitely more blowing stuff up

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (8)

Semelhante a More explosions, more chaos, and definitely more blowing stuff up

Semelhante a More explosions, more chaos, and definitely more blowing stuff up (20)

Mais de Intel® Software

Mais de Intel® Software (20)

Último

Último (20)

More explosions, more chaos, and definitely more blowing stuff up