Scalable Multi-Cache Simulation Using GPUs - XCG

Report
Scalable Multi-Cache
Simulation Using GPUs
Michael Moeng
Sangyeun Cho
Rami Melhem
University of Pittsburgh
Background
• Architects simulating more cores
▫ Increasing simulation times
• Cannot keep doing single-threaded simulations
if we want to see results in a reasonable time
frame
Target Machine
Host
Machine
Simulates
Parallel Simulation Overview
• A number of people have begun researching
multithreaded simulation
• Multithreaded simulations have some key limitations
▫ Many fewer host cores than the cores in a target machine
▫ Slow communication between threads
• Graphics processors have high fine-grained parallelism
▫ Many more cores
▫ Cheap communication within ‘blocks’ (software unit)
• We propose using GPUs to accelerate timing simulation
• CPU acts as the functional feeder
Contributions
• Introduce GPUs as a tool for architectural timing
simulation
• Implement a proof-of-concept multi-cache
simulator
• Study strengths and weaknesses of GPU-based
timing simulation
Outline
• GPU programming with CUDA
• Multi-cache simulation using CUDA
• Performance Results vs CPU
▫ Impact of Thread Interaction
▫ Optimizations
• Conclusions
CUDA Dataflow
Device (GPU)
Host (CPU)
Main
Memory
Graphics
Memory
PCIe Bus
SIMD Processors
Dataflow – Concurrent CPU/GPU
Device (GPU)
Host (CPU)
Main
Memory
Graphics
Memory
PCIe Bus
SIMD Processors
Dataflow – Concurrent Kernels
Device (GPU)
Host (CPU)
Main
Memory
Graphics
Memory
PCIe Bus
SIMD Processors
GPU-driven Cache Simulation
Trace-driven Simulation
Device (GPU)
Host (CPU)
Statistics
L1 Misses
Trace Data
L2
L1 kernel
GPU-driven Cache Simulation
• Each cache way is simulated by a thread
▫ Parallel address lookup
▫ Communicate via fast shared memory
• Ways from 4 caches form a block
▫ With 16-way caches, 64 threads per block
• Cache state (tags+metadata) stored in global
memory – rely on caching for fast access
• Experimented with tree-based reduction
▫ No performance improvement (small tree)
Block-to-Block Interactions
• Within a block, we can call a cheap barrier and there
is no inaccuracy
• Shared L2
▫ Upon miss, L1 threads determine L2 home tile
▫ Atomically add miss to global memory buffer for L2 to
process
• Write Invalidations
▫ Upon write, L1 thread checks global memory for tag
state of other L1 threads
▫ Atomically invalidate matching lines in global memory
Evaluation
• Feed traces of memory accesses to simulated
cache hierarchy
▫ Mix of PARSEC benchmarks
• L1/L2 cache hierarchy with private/shared L2
• GeForce GTS 450 – 192 cores (low-mid range)
▫ Fermi GPU – caching, simultaneous kernels
▫ Newer NVIDIA GPUs range from 100-500 cores
Private L2
GPU sees 13-60%
slowdown from
32 to 96 caches
4
Host Machine
+ Simulated
Cache Count
Simulation Time
3.5
3
CPU 32
CPU 64
CPU 96
GPU 32
GPU 64
GPU 96
2.5
2
1.5
1
0.5
0
Linear CPU A
simulation scaling
B
C
D
Workload
E
F
Multithreaded
Shared L2
Largely serialized
Unbalanced traffic
load to a few tiles
4
Simulation Time
3.5
3
CPU 32
CPU 64
CPU 96
GPU 32
GPU 64
GPU 96
2.5
2
1.5
1
0.5
0
A
B
C
D
Workload
E
F
Multithreaded
Inaccuracy from Thread Interaction
• CUDA currently has little support for
synchronization between blocks
• Without synchronization support, inter-thread
communication is subject to error:
▫ Shared L2 caches – miss rate
▫ Write invalidations – invalidation count
Controlling Error
• Only way to synchronize blocks is in between
kernel invocations
▫ Number of trace items processed by each kernel
invocation controls error
▫ Similar techniques used in parallel CPU
simulation
• There is a performance and error tradeoff with
varying trace chunk size
12%
10%
8%
6%
4%
2%
0%
8
32
128
512
Trace Chunk Size
Error
Performance
CPU-only
100%
90%
80%
70%
60%
50%
40%
30%
20%
10%
0%
2048
Performance
Invalidation Count Error
Invalidation – Performance vs Error
Shared L2 – Miss Rate Error
0.70%
Miss Rate Error
0.60%
Largely serialized
execution
minimizes error
0.50%
Simulated
Cache Count
0.40%
32
64
96
0.30%
0.20%
0.10%
0.00%
A
B
C
D
Workload
E
F
Concurrent Execution
• Transfer memory while executing kernels
• Run L1 kernel concurrently with L2 kernel
Trace IO
L1
Kernel
Trace IO
L2
Kernel
L1
Kernel
Trace IO
L2
Kernel
L1
Kernel
L2
Kernel
Performance Improvement
Concurrent Execution Speedup
Load
Fromimbalance
better
parallel
80%
among
L2transfer
slices
utilization
memory
of
70%
GPUcomputation
and
60%
Greater
Benefits
benefit
end
when
when
more
GPU
data
is
is transferred
fully utilized
50%
Cache
Model
40%
L1
Private
Shared
30%
20%
10%
0%
32
64
Simulated Cache Tiles
96
CUDA Block Mapping
• For maximum throughput, CUDA requires a
balance between number of blocks and threads
per block
▫ Each block can support many more threads than
the number of ways in each cache
• We map 4 caches to each block for maximum
throughput
• Also study tradeoff from fewer caches per block
Block Mapping - Scaling
Simulation Time
3.5 Caches per Block
Fewer
3
Lower Latency
2.5
Caches
per block
2
1.5
1
More Caches per Block
0.5
0
16
Saturated at
64
32 tiles
32
48
Higher Throughput
64
80
96
Simulated Cache Tiles
1
2
4
Conclusions
• Even with a low-end GPU, we can simulate more
and more caches with very small slowdown
• With a GPU co-processor we can leverage both
CPU and GPU processor time
• Crucial that we balance the load between blocks
Future Work
•
•
•
•
Better load balance (adaptive mapping)
More detailed timing model
Comparisons against multi-threaded simulation
Studies with higher-capacity GPUs

similar documents