| 271 |
|
private static final int MAX_PHASE = 0x7fffffff; |
| 272 |
|
private static final int PARTIES_SHIFT = 16; |
| 273 |
|
private static final int PHASE_SHIFT = 32; |
| 274 |
+ |
private static final long PHASE_MASK = -1L << PHASE_SHIFT; |
| 275 |
|
private static final int UNARRIVED_MASK = 0xffff; // to mask ints |
| 276 |
|
private static final long PARTIES_MASK = 0xffff0000L; // to mask longs |
| 277 |
|
private static final long TERMINATION_BIT = 1L << 63; |
| 439 |
|
* Resolves lagged phase propagation from root if necessary. |
| 440 |
|
*/ |
| 441 |
|
private long reconcileState() { |
| 442 |
< |
Phaser rt = root; |
| 442 |
> |
final Phaser root = this.root; |
| 443 |
|
long s = state; |
| 444 |
< |
if (rt != this) { |
| 445 |
< |
int phase; |
| 446 |
< |
while ((phase = (int)(rt.state >>> PHASE_SHIFT)) != |
| 447 |
< |
(int)(s >>> PHASE_SHIFT)) { |
| 448 |
< |
// assert phase < 0 || unarrivedOf(s) == 0 |
| 449 |
< |
long t; // to reread s |
| 450 |
< |
long p = s & PARTIES_MASK; // unshifted parties field |
| 451 |
< |
long n = (((long) phase) << PHASE_SHIFT) | p; |
| 452 |
< |
if (phase >= 0) { |
| 453 |
< |
if (p == 0L) |
| 453 |
< |
n |= EMPTY; // reset to empty |
| 454 |
< |
else |
| 455 |
< |
n |= p >>> PARTIES_SHIFT; // set unarr to parties |
| 456 |
< |
} |
| 457 |
< |
if ((t = state) == s && |
| 458 |
< |
UNSAFE.compareAndSwapLong(this, stateOffset, s, s = n)) |
| 459 |
< |
break; |
| 460 |
< |
s = t; |
| 444 |
> |
if (root != this) { |
| 445 |
> |
for (long rs; ((rs = root.state) ^ s) >>> PHASE_SHIFT != 0;) { |
| 446 |
> |
// assert rs < 0 || (s != state) || unarrivedOf(s) == 0; |
| 447 |
> |
long lp = s & PARTIES_MASK; |
| 448 |
> |
long n = (rs & PHASE_MASK) | lp; |
| 449 |
> |
if (rs >= 0) |
| 450 |
> |
n |= (lp == 0L) ? EMPTY : (lp >>> PARTIES_SHIFT); |
| 451 |
> |
if (s == (s = state) && |
| 452 |
> |
UNSAFE.compareAndSwapLong(this, stateOffset, s, n)) |
| 453 |
> |
return n; |
| 454 |
|
} |
| 455 |
|
} |
| 456 |
|
return s; |
