Lecture Notes in Computer Science 4917

32 J. Psota and A. Agarwal
speedup
7
6
5
4
3
2
1
0
GDN
rMPI
LAM
16 32 64 128 256 512 1024 2048
input data size
Fig. 7. Speedup for Jacobi. x-axis shows N,
where the input matrix is N×N.
overhead
500.00%
450.00%
400.00%
350.00%
300.00%
250.00%
200.00%
150.00%
100.00%
50.00%
0.00%
N=16 N=32 N=64 N=128 N=256 N=512 N=1024 N=2048
problem size
2 tiles
4 tiles
8 tiles
16 tiles
Fig. 9. Overhead of rMPI for Jacobi Relaxation
relative to a GDN implementation for various
input sizes. Overhead computed using cycle
counts.
Throughput (computed elements/cycle)
0.04
0.035
0.03
0.025
0.02
0.015
0.01
0.005
0
data cache overflows
16 32 64 128 256 512 1024 2048
input data size
Fig. 8. Throughput (computations/cycle) for Jacobi
(on Raw). Cache overflows at 512×512 input
size.
run time (cycles)
38000
36000
34000
32000
30000
28000
26000
24000
22000
20000
2kB 4kB 8kB 16kB 32kB 64kB 128kB 256kB
instruction cache size
Fig. 10. Performance of jacobi with varying instruction
cache size. Lower is better.
Figure 3 characterizes the overhead of rMPI for a simple send/receive pair of processors
on the Raw chip. To characterize rMPI’s overhead for real applications, which
may have complex computation and communication patterns, the overhead of rMPI was
measured for jacobi. The experiment measured the complete running time of jacobi experiments
for various input data sizes and numbers of processors for both the GDN and
rMPI implementations. Figure 9 shows the results of this experiment. Here, rMPI overhead
is computed as overheadrMPI =(cyclesrMPI − cyclesGDN)/(cyclesGDN).
As can be seen, rMPI’s overhead is quite large for small data sets. Furthermore, its
overhead is particularly high for small data sets running on a large number of processors,
as evidenced by the 16×16 case for 16 processors, which has an overhead of
nearly 450%. However, as the input data set increases, rMPI’s overhead drops quickly.
It should also be noted that for data sizes from 16×16 through 512×512, adding processors
increases overhead, but for data sizes larger than 512×512, adding processors
decreases overhead. In fact, the 1024×1024 data size for 16 processors has just a 1.7%
overhead. The 2048×2048 for 16 processors actually shows a speedup beyond the GDN