You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
For parallel reductions where the accumulators are all initialized to the same value, the PHI nodes are merged into the instructions and the reduction is made on the register of initial value, instead on "new" registers
for(unsignedi=0; i<MATSIZE; ++i) {
#pragma unroll 1
for(unsignedj=0; j<MATSIZE; j+=UNROLL) {
register doubleacc[UNROLL];
#pragma unroll
for (intu=0; u<UNROLL; ++u) acc[u] =0.0; // <- All is fine if this is e.g. c[i*MATSIZE+j+u];#pragma frep infer
for(unsignedk=0; k<MATSIZE; ++k) {
#pragma unroll
for (intu=0; u<UNROLL; ++u)
{
acc[u] +=__builtin_ssr_pop(0)*__builtin_ssr_pop(1);
}
}
#pragma unroll
for (intu=0; u<UNROLL; ++u) c[i*MATSIZE+j+u] =acc[u];
}
}
We experienced some deadlocks when we used multiple threads for logging
using `scan-builds` intercept-build tool when we used multiple threads by
e.g. logging `make -j16`
```
(gdb) bt
#0 0x00007f2bb3aff110 in __lll_lock_wait () from /lib/x86_64-linux-gnu/libpthread.so.0
#1 0x00007f2bb3af70a3 in pthread_mutex_lock () from /lib/x86_64-linux-gnu/libpthread.so.0
#2 0x00007f2bb3d152e4 in ?? ()
#3 0x00007ffcc5f0cc80 in ?? ()
#4 0x00007f2bb3d2bf5b in ?? () from /lib64/ld-linux-x86-64.so.2
#5 0x00007f2bb3b5da27 in ?? () from /lib/x86_64-linux-gnu/libc.so.6
#6 0x00007f2bb3b5dbe0 in exit () from /lib/x86_64-linux-gnu/libc.so.6
#7 0x00007f2bb3d144ee in ?? ()
#8 0x746e692f706d742f in ?? ()
#9 0x692d747065637265 in ?? ()
#10 0x2f653631326b3034 in ?? ()
#11 0x646d632e35353532 in ?? ()
#12 0x0000000000000000 in ?? ()
```
I think the gcc's exit call caused the injected `libear.so` to be unloaded
by the `ld`, which in turn called the `void on_unload() __attribute__((destructor))`.
That tried to acquire an already locked mutex which was left locked in the
`bear_report_call()` call, that probably encountered some error and
returned early when it forgot to unlock the mutex.
All of these are speculation since from the backtrace I could not verify
if frames 2 and 3 are in fact corresponding to the `libear.so` module.
But I think it's a fairly safe bet.
So, hereby I'm releasing the held mutex on *all paths*, even if some failure
happens.
PS: I would use lock_guards, but it's C.
Reviewed-by: NoQ
Differential Revision: https://reviews.llvm.org/D118439
(cherry picked from commit d919d02)
For parallel reductions where the accumulators are all initialized to the same value, the PHI nodes are merged into the instructions and the reduction is made on the register of initial value, instead on "new" registers
With
0.0
this results in the wrong assemblyFor inididual initial values (
c[i*MATSIZE+j+u]
, the problem disappearsThe text was updated successfully, but these errors were encountered: