mppf
commented
5 years ago Looking at muladsubb. First, I have a small performance reproducer:
use Time;
// num_samples: 3000 for "long", 300000 for "medium", 50000000 for "short"
config const num_samples = 50000000; // "short"
// array length: 44217 for "long", 5001 for "medium", 171 for "short"
config const len = 171; // "short"
proc main() {
var ltimer:Timer;
var RealArray_1D: [0..10][0..#len] real;
// The stuff from LCALSLoops.chpl loopInit
for i in 1..5 do
initData(RealArray_1D[i-1], i);
// This portion from RunBRawLoops.chpl runBRawLoops e.g.
ref out1 = RealArray_1D[0];
ref out2 = RealArray_1D[1];
ref out3 = RealArray_1D[2];
ref in1 = RealArray_1D[3];
ref in2 = RealArray_1D[4];
ltimer.start();
for 0..#num_samples {
for i in 0..#len {
out1[i] = in1[i] * in2[i];
out2[i] = in1[i] + in2[i];
out3[i] = in1[i] - in2[i];
}
}
ltimer.stop();
var chksum: real = 0.0;
// Get this portion from LCALSLoops.chpl loopFinalize
updateChksum(chksum, len, RealArray_1D[0]);
updateChksum(chksum, len, RealArray_1D[1]);
updateChksum(chksum, len, RealArray_1D[2]);
// Get the Checksum from LCALSChecksums.chpl
var expect = 391727437.25186200960888527333736;
writeln("Got checksum ", chksum, " expected ", expect);
writeln("Kernel ran in ", ltimer.elapsed(), " seconds");
}
proc initData(ra: [] real, id: int) {
const factor: real = if id % 2 != 0 then 0.1 else 0.2;
for (r,j) in zip(ra, 0..) {
r = factor*(j + 1.1)/(j + 1.12345);
}
}
proc updateChksum(ref chksum:real, length: int,
ra: [] real, scale_factor: real = 1.0) {
use LongDouble;
ref data = ra;
var len = ra.numElements;
var tchk: longdouble = chksum;
for (j, dat) in zip(0..#len, data) {
tchk += (j+1)*dat*scale_factor;
}
chksum = tchk:real;
}Next, I ran the (optimized) C version in gdb and hit control-c in the middle of execution. This loop is appraently the kernel:
0x423108 <chpl_user_main+6184>: vmovupd (%r11,%rdx,1),%ymm0
0x42310e <chpl_user_main+6190>: vmulpd (%rbx,%rdx,1),%ymm0,%ymm0
0x423113 <chpl_user_main+6195>: add $0x1,%r10
0x423117 <chpl_user_main+6199>: vmovupd %ymm0,(%r15,%rdx,1)
=> 0x42311d <chpl_user_main+6205>: vmovupd (%r11,%rdx,1),%ymm0
0x423123 <chpl_user_main+6211>: vaddpd (%rbx,%rdx,1),%ymm0,%ymm0
0x423128 <chpl_user_main+6216>: vmovupd %ymm0,(%r14,%rdx,1)
0x42312e <chpl_user_main+6222>: vmovapd (%rbx,%rdx,1),%ymm0
0x423133 <chpl_user_main+6227>: vsubpd (%r11,%rdx,1),%ymm0,%ymm0
0x423139 <chpl_user_main+6233>: vmovupd %ymm0,(%r9,%rdx,1)
0x42313f <chpl_user_main+6239>: add $0x20,%rdx
0x423143 <chpl_user_main+6243>: cmp %r10,%r13
0x423146 <chpl_user_main+6246>: ja 0x423108 <chpl_user_main+6184>Here is the kernel in the optimized LLVM version:
0x428e00 <chpl_user_main+6400>: vmovsd 0x8(%rcx,%rbp,8),%xmm0
0x428e06 <chpl_user_main+6406>: vmulsd 0x8(%rdx,%rbp,8),%xmm0,%xmm0
0x428e0c <chpl_user_main+6412>: vmovsd %xmm0,0x8(%rax,%rbp,8)
0x428e12 <chpl_user_main+6418>: vmovsd 0x8(%rcx,%rbp,8),%xmm0
0x428e18 <chpl_user_main+6424>: vaddsd 0x8(%rdx,%rbp,8),%xmm0,%xmm0
0x428e1e <chpl_user_main+6430>: vmovsd %xmm0,0x8(%rsi,%rbp,8)
=> 0x428e24 <chpl_user_main+6436>: vmovsd 0x8(%rcx,%rbp,8),%xmm0
0x428e2a <chpl_user_main+6442>: vsubsd 0x8(%rdx,%rbp,8),%xmm0,%xmm0
0x428e30 <chpl_user_main+6448>: vmovsd %xmm0,0x8(%rdi,%rbp,8)
0x428e36 <chpl_user_main+6454>: vmovsd 0x10(%rcx,%rbp,8),%xmm0
0x428e3c <chpl_user_main+6460>: vmulsd 0x10(%rdx,%rbp,8),%xmm0,%xmm0
0x428e42 <chpl_user_main+6466>: vmovsd %xmm0,0x10(%rax,%rbp,8)
0x428e48 <chpl_user_main+6472>: vmovsd 0x10(%rcx,%rbp,8),%xmm0
0x428e4e <chpl_user_main+6478>: vaddsd 0x10(%rdx,%rbp,8),%xmm0,%xmm0
0x428e54 <chpl_user_main+6484>: vmovsd %xmm0,0x10(%rsi,%rbp,8)
0x428e5a <chpl_user_main+6490>: vmovsd 0x10(%rcx,%rbp,8),%xmm0
0x428e60 <chpl_user_main+6496>: vsubsd 0x10(%rdx,%rbp,8),%xmm0,%xmm0
0x428e66 <chpl_user_main+6502>: vmovsd %xmm0,0x10(%rdi,%rbp,8)
0x428e6c <chpl_user_main+6508>: add $0x2,%rbp
0x428e70 <chpl_user_main+6512>: cmp %r14,%rbp
0x428e73 <chpl_user_main+6515>: jl 0x428e00 <chpl_user_main+6400>This benchmark has equivalent performance with clang-included and with --llvm, so it's not necessarily the case that we're simply encoding the LLVM IR wrong. It seems that LLVM is not vectorizing.
If I adjust the program to run with vectorizeOnly, the LLVM version becomes faster than the GCC one.
Possible remedy: extend no-alias metadata for the sub-array case.
LCALS performance differs for --llvm especially for the raw,short configuration, but to some degree for other benchmarks.
https://chapel-lang.org/perf/chapcs/llvm/?startdate=2018/09/12&graphs=lcalsrawshort,lcalsrawmedium,lcalsrawlong,lcalsrawompshort,lcalsrawompmedium,lcalsrawomplong
For example,
This task is a spike to investigate the cause of these differences.