internal void Request(int index, long n) { if (SubscriptionHelper.Validate(n)) { var rs = requests; BackpressureHelper.GetAndAddCap(ref rs[index], n); if (Volatile.Read(ref subscriberCount) == rs.Length) { Drain(); } } }
public virtual void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { qs = s as IQueueSubscription <T>; if (BeforeSubscribe()) { actual.OnSubscribe(this); AfterSubscribe(); } } }
public override void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (Volatile.Read(ref once) == 0 && Interlocked.CompareExchange(ref once, 1, 0) == 0) { if (n >= this.n) { s.Request(long.MaxValue); return; } } s.Request(n); } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { actual.OnSubscribe(this); if (maxConcurrency == int.MaxValue) { s.Request(long.MaxValue); } else { s.Request(maxConcurrency); } } }
public override void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (Volatile.Read(ref once) == 0 && Interlocked.CompareExchange(ref once, 1, 0) == 0) { long u = BackpressureHelper.MultiplyCap(n - 1, skip); long v = BackpressureHelper.AddCap(u, size); s.Request(v); } else { long u = BackpressureHelper.MultiplyCap(n, skip); s.Request(u); } } }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (BackpressureHelper.GetAndAddCap(ref requested, n) == 0) { if (n == long.MaxValue) { FastPath(); } else { SlowPath(n); } } } }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (Interlocked.CompareExchange(ref once, 1, 0) == 0) { if (fusionMode == FuseableHelper.ASYNC) { actual.OnNext(default(T)); } else { actual.OnError(error); } } } }
public override void Request(long n) { if (SubscriptionHelper.Validate(n)) { if (!BackpressureHelper.PostCompleteRequest <IList <T> >(ref requested, n, actual, lists, ref cancelled)) { if (Volatile.Read(ref once) == 0 && Interlocked.CompareExchange(ref once, 1, 0) == 0) { long r = BackpressureHelper.MultiplyCap(n - 1, size - skip); long u = BackpressureHelper.AddCap(r, size); s.Request(u); } else { long r = BackpressureHelper.MultiplyCap(n, size - skip); s.Request(r); } } } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { var qs = s as IQueueSubscription <T>; if (qs != null) { int mode = qs.RequestFusion(FuseableHelper.ANY | FuseableHelper.BOUNDARY); if (mode == FuseableHelper.SYNC) { this.sourceMode = mode; this.queue = qs; Volatile.Write(ref done, true); SubscribeActual(); Schedule(); return; } else if (mode == FuseableHelper.ASYNC) { this.sourceMode = mode; this.queue = qs; SubscribeActual(); s.Request(prefetch < 0 ? long.MaxValue : prefetch); return; } } queue = QueueDrainHelper.CreateQueue <T>(prefetch); SubscribeActual(); s.Request(prefetch < 0 ? long.MaxValue : prefetch); } }
public void OnSubscribe(ISubscription s) { if (SubscriptionHelper.Validate(ref this.s, s)) { var qs = s as IQueueSubscription <T>; if (qs != null) { int m = qs.RequestFusion(FuseableHelper.ANY); if (m == FuseableHelper.SYNC) { fusionMode = m; queue = qs; Volatile.Write(ref done, true); actual.OnSubscribe(this); Drain(); return; } else if (m == FuseableHelper.ASYNC) { fusionMode = m; queue = qs; actual.OnSubscribe(this); s.Request(prefetch < 0 ? long.MaxValue : prefetch); return; } } queue = QueueDrainHelper.CreateQueue <T>(prefetch); actual.OnSubscribe(this); s.Request(prefetch < 0 ? long.MaxValue : prefetch); } }
public void Request(long n) { if (SubscriptionHelper.Validate(n)) { for (;;) { long r = Volatile.Read(ref requested); if (r == long.MinValue) { break; } long u = r + n; if (u < 0L) { u = long.MaxValue; } if (Interlocked.CompareExchange(ref requested, u, r) == r) { break; } } } }