internal override void TryAlt(ref Worker wr, int i, Cont<Unit> uK, Else aE) {
var pkSelf = aE.pk;
Spin:
if (0 == this.Count) goto TryPick;
var state = this.State;
if (state < 0) goto Spin;
if (Interlocked.Exchange(ref this.State, ~state) < state) goto Spin;
if (0 == this.Count) goto UnlockAndTryPick;
WaitQueue.AddTaker(ref this.Awaiters, i, pkSelf, uK);
this.State = 0;
aE.TryElse(ref wr, i + 1);
return;
UnlockAndTryPick:
this.State = 0;
TryPick:
var st = Pick.TryPick(pkSelf);
if (st > 0) goto AlreadyPicked;
if (st < 0) goto TryPick;
Pick.SetNacks(ref wr, i, pkSelf);
Work.Do(uK, ref wr);
AlreadyPicked:
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <Y> yK, Else tE)
{
var tM = this.tM;
var pkSelf = tE.pk;
Spin:
var state = tM.State;
if (state == MVar.Locked)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref tM.State, MVar.Locked, state))
{
goto Spin;
}
if (state <= MVar.Empty)
{
goto EmptyOrDemand;
}
TryPick:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto TryPick;
}
Pick.SetNacks(ref wr, i, pkSelf);
var t = tM.Value;
tM.State = MVar.Empty;
MVarTryModifyFunCont <T, Y> .Do(this, yK, ref wr, t);
return;
AlreadyPicked:
tM.State = MVar.Full;
return;
EmptyOrDemand:
WaitQueue.AddTaker(ref tM.Takers, i, pkSelf, new MVarTryModifyFunCont <T, Y>(this, yK));
tM.State = MVar.Demand;
tE.TryElse(ref wr, i + 1);
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
var pkSelf = aE.pk;
Spin:
var state = this.State;
if (state == Locked)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref this.State, Locked, state))
{
goto Spin;
}
if (state <= Empty)
{
goto EmptyOrDemand;
}
TryPick:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto TryPick;
}
Pick.SetNacks(ref wr, i, pkSelf);
T value = this.Value;
this.Value = default(T);
this.State = Empty;
Cont.Do(aK, ref wr, value);
return;
AlreadyPicked:
this.State = Full;
return;
EmptyOrDemand:
WaitQueue.AddTaker(ref this.Takers, i, pkSelf, aK);
this.State = Demand;
aE.TryElse(ref wr, i + 1);
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <X> xK, Else xE)
{
Spin:
var st = this.state;
if (st > 0)
{
goto Done;
}
if (st < 0)
{
goto Spin;
}
if (0 != Interlocked.CompareExchange(ref this.state, -1, st))
{
goto Spin;
}
var pk = xE.pk;
TryPick:
var stPk = Pick.TryPick(pk);
if (stPk > 0)
{
goto AlreadyPicked;
}
if (stPk < 0)
{
goto TryPick;
}
this.state = 1;
Pick.SetNacks(ref wr, i, pk);
var x = this.value;
this.value = default(X);
Cont.Do(xK, ref wr, x);
return;
AlreadyPicked:
st = 0;
Done:
xE.TryElse(ref wr, i);
}
internal override void TryAlt(ref Worker wr, int i, Cont <Unit> uK, Else uE)
{
var pk = uE.pk;
Spin:
var state = this.State;
if (state > Running)
{
goto TryPick;
}
if (state < Running)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref this.State, Locked, state))
{
goto Spin;
}
WaitQueue.AddTaker(ref this.Joiners, i, pk, uK);
this.State = Running;
uE.TryElse(ref wr, i + 1);
return;
TryPick:
var st = Pick.TryPick(pk);
if (st > 0)
{
goto AlreadyPicked;
}
if (st < 0)
{
goto TryPick;
}
Pick.SetNacks(ref wr, i, pk);
Work.Do(uK, ref wr);
AlreadyPicked:
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
var pkSelf = aE.pk;
this.Lock.Enter();
if (this.Values.Count > 0)
{
goto GotValue;
}
WaitQueue.AddTaker(ref this.Takers, i, pkSelf, aK);
this.Lock.Exit();
aE.TryElse(ref wr, i + 1);
return;
GotValue:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto GotValue;
}
T value = this.Values.Dequeue();
this.Lock.Exit();
Pick.SetNacks(ref wr, i, pkSelf);
Cont.Do(aK, ref wr, value);
return;
AlreadyPicked:
this.Lock.Exit();
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <X> xK, Else xE)
{
xE.TryElse(ref wr, i);
}
internal override void TryElse(ref Worker wr, int i)
{
nk.I1 = i;
xE.TryElse(ref wr, i);
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> xK, Else xE)
{
var pkSelf = xE.pk;
this.Lock.Enter();
var tail = this.Givers;
if (null == tail)
{
goto TryTaker;
}
Send <T> cache = null;
var cursor = tail.Next;
TryGiver:
var giver = cursor as Giver <T>;
Pick pkOther = null;
if (null != giver)
{
goto Giver;
}
TryPick:
var st = Pick.TryPick(pkSelf);
if (st > 0)
{
goto AlreadyPicked;
}
if (st < 0)
{
goto TryPick;
}
WaitQueue.RemoveRange(ref this.Givers, cursor);
this.Lock.Exit();
Pick.SetNacks(ref wr, i, pkSelf);
Cont.Do(xK, ref wr, cursor.Value);
return;
AlreadyPicked:
WaitQueue.RemoveRangeInclusive(this.Givers, cursor);
this.Lock.Exit();
return;
Giver:
cursor = cursor.Next;
pkOther = giver.Pick;
if (null == pkOther)
{
goto TryPickSelf;
}
if (pkOther == pkSelf)
{
goto OtherIsSelf;
}
TryPickOther:
var stOther = Pick.TryClaim(pkOther);
if (stOther > 0)
{
goto TryNextGiver;
}
if (stOther < 0)
{
goto TryPickOther;
}
TryPickSelf:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto SelfAlreadyPicked;
}
if (stSelf < 0)
{
goto BackOff;
}
//GotGiver:
WaitQueue.RemoveRange(ref this.Givers, giver);
this.Lock.Exit();
if (null != pkOther)
{
Pick.PickClaimedAndSetNacks(ref wr, giver.Me, pkOther);
}
Pick.SetNacks(ref wr, i, pkSelf);
Worker.Push(ref wr, giver.Cont);
Cont.Do(xK, ref wr, giver.Value);
return;
BackOff:
if (null == pkOther)
{
goto TryPickSelf;
}
Pick.Unclaim(pkOther);
goto TryPickOther;
OtherIsSelf:
WaitQueue.Enqueue(ref cache, giver);
if (giver != tail)
{
goto TryGiver;
}
this.Givers = cache;
goto TryTaker;
TryNextGiver:
if (giver != tail)
{
goto TryGiver;
}
this.Givers = cache;
TryTaker:
WaitQueue.AddTaker(ref this.Takers, i, pkSelf, xK);
this.Lock.Exit();
xE.TryElse(ref wr, i + 1);
return;
SelfAlreadyPicked:
if (null != pkOther)
{
Pick.Unclaim(pkOther);
}
WaitQueue.RemoveRangeInclusive(this.Givers, giver);
this.Lock.Exit();
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <Unit> uK, Else uE)
{
var pkSelf = uE.pk;
var ch = this.Ch;
ch.Lock.Enter();
var tail = ch.Takers;
if (null == tail)
{
goto TryGiver;
}
Cont <T> cache = null;
var cursor = tail.Next;
TryTaker:
var taker = cursor as Cont <T>;
cursor = cursor.Next;
int me = 0;
var pkOther = taker.GetPick(ref me);
if (null == pkOther)
{
goto TryPickSelf;
}
if (pkOther == pkSelf)
{
goto OtherIsSelf;
}
TryPickOther:
var stOther = Pick.TryClaim(pkOther);
if (stOther > 0)
{
goto TryNextTaker;
}
if (stOther < 0)
{
goto TryPickOther;
}
TryPickSelf:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto SelfAlreadyPicked;
}
if (stSelf < 0)
{
goto BackOff;
}
WaitQueue.RemoveRange(ref ch.Takers, taker);
ch.Lock.Exit();
if (null != pkOther)
{
Pick.PickClaimedAndSetNacks(ref wr, me, pkOther);
}
Pick.SetNacks(ref wr, i, pkSelf);
taker.Value = this.X;
Worker.Push(ref wr, taker);
Work.Do(uK, ref wr);
return;
BackOff:
if (null == pkOther)
{
goto TryPickSelf;
}
Pick.Unclaim(pkOther);
goto TryPickOther;
OtherIsSelf:
WaitQueue.Enqueue(ref cache, taker);
if (taker != tail)
{
goto TryTaker;
}
ch.Takers = cache;
goto TryGiver;
TryNextTaker:
if (taker != tail)
{
goto TryTaker;
}
ch.Takers = cache;
TryGiver:
WaitQueue.AddGiver(ref ch.Givers, this.X, i, pkSelf, uK);
ch.Lock.Exit();
uE.TryElse(ref wr, i + 1);
return;
SelfAlreadyPicked:
if (null != pkOther)
{
Pick.Unclaim(pkOther);
}
WaitQueue.RemoveRangeInclusive(ch.Takers, taker);
ch.Lock.Exit();
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
Spin:
var state = this.State;
Reconsider:
if (state > Running)
{
goto Completed;
}
if (state < Delayed)
{
goto Spin;
}
var check = state;
state = Interlocked.CompareExchange(ref this.State, state - MakeLocked, state);
if (Delayed == state)
{
goto Delayed;
}
if (state != check)
{
goto Reconsider;
}
WaitQueue.AddTaker(ref this.Readers, i, aE.pk, aK);
this.State = Running;
aE.TryElse(ref wr, i + 1);
return;
Delayed:
var readers = this.Readers;
this.Readers = null;
this.State = Running;
var fulfill = readers as Fulfill;
fulfill.reader = aK;
fulfill.me = i;
fulfill.pk = aE.pk;
Worker.PushNew(ref wr, fulfill);
aE.TryElse(ref wr, i + i);
return;
Completed:
var pkSelf = aE.pk;
TryPick:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto TryPick;
}
Pick.SetNacks(ref wr, i, pkSelf);
if (state == HasValue)
{
Cont.Do(aK, ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail <T>).exn);
}
AlreadyPicked:
return;
}
internal override void TryAlt(ref Worker wr, int i, Cont <T> aK, Else aE)
{
var pkSelf = aE.pk;
Spin:
var state = this.State;
if (state > Running)
{
goto Completed;
}
if (state < Delayed)
{
goto Spin;
}
if (state != Interlocked.CompareExchange(ref this.State, ~state, state))
{
goto Spin;
}
if (Delayed == state)
{
goto Delayed;
}
WaitQueue.AddTaker(ref this.Readers, i, pkSelf, aK);
this.State = Running;
aE.TryElse(ref wr, i + 1);
return;
Delayed:
var taker = new Taker <T>();
taker.Cont = aK;
taker.Me = i;
taker.Pick = pkSelf;
taker.Next = taker;
var readers = this.Readers;
this.Readers = taker;
this.State = Running;
var fulfill = readers as Fulfill;
var tJ = fulfill.tP;
fulfill.tP = this;
Worker.PushNew(ref wr, new JobWork <T>(tJ, fulfill));
aE.TryElse(ref wr, i + i);
return;
Completed:
var stSelf = Pick.TryPick(pkSelf);
if (stSelf > 0)
{
goto AlreadyPicked;
}
if (stSelf < 0)
{
goto Completed;
}
Pick.SetNacks(ref wr, i, pkSelf);
if (state == HasValue)
{
Cont.Do(aK, ref wr, this.Value);
}
else
{
aK.DoHandle(ref wr, (this.Readers as Fail <T>).exn);
}
AlreadyPicked:
return;
}