public PopResult PopBottom(out T obj) { obj = default(T); int b = CustomInterlocked.Decrement(ref bottom); var a = array; int t = top; int size = b - t; if (size < 0) { // Set bottom to t CustomInterlocked.Add(ref bottom, t - b); return(PopResult.Empty); } obj = a.segment[b % a.size]; if (size > 0) { return(PopResult.Succeed); } CustomInterlocked.Add(ref bottom, t + 1 - b); if (CustomInterlocked.CompareExchange(ref top, t + 1, t) != t) { return(PopResult.Empty); } return(PopResult.Succeed); }
public bool TryRemoveHash(int key, out T data) { if (ListDelete(key, out data)) { CustomInterlocked.Decrement(ref count); return(true); } return(false); }
public bool TryTake(out T result) { result = default(T); if (count == 0) { return(false); } int hintIndex; CyclicDeque <T> bag = GetBag(out hintIndex, false); bool ret = true; if (bag == null || bag.PopBottom(out result) != PopResult.Succeed) { var self = bag; ret = false; foreach (var other in staging) { // Try to retrieve something based on a hint ret = TryGetHint(out hintIndex) && (bag = container[hintIndex]).PopTop(out result) == PopResult.Succeed; // We fall back to testing our slot if (!ret && other.Value != self) { var status = other.Value.PopTop(out result); while (status == PopResult.Abort) { status = other.Value.PopTop(out result); } ret = status == PopResult.Succeed; hintIndex = other.Key; bag = other.Value; } // If we found something, stop if (ret) { break; } } } if (ret) { TidyBag(hintIndex, bag); CustomInterlocked.Decrement(ref count); } return(ret); }
public bool PeekBottom(out T obj) { obj = default(T); int b = CustomInterlocked.Decrement(ref bottom); var a = array; int t = top; int size = b - t; if (size < 0) { return(false); } obj = a.segment[b % a.size]; return(true); }
public void Execute() { if (CustomInterlocked.Decrement(ref counter) != 0) { return; } owner.Status = TaskStatus.Running; bool canceled = false; List <Exception> exceptions = null; foreach (var task in tasks) { if (task.IsFaulted) { if (exceptions == null) { exceptions = new List <Exception> (); } exceptions.AddRange(task.Exception.InnerExceptions); continue; } if (task.IsCanceled) { canceled = true; } } if (exceptions != null) { owner.TrySetException(new AggregateException(exceptions), false, false); return; } if (canceled) { owner.CancelReal(); return; } owner.Finish(); }
public bool Delete(uint key, TKey subKey, out T data) { uint b = key % (uint)size; Node bucket; if ((bucket = GetBucket(b)) == null) { bucket = InitializeBucket(b); } if (!ListDelete(bucket, ComputeRegularKey(key), subKey, out data)) { return(false); } CustomInterlocked.Decrement(ref count); return(true); }
public bool TryDequeue(out T result) { result = default(T); Node oldNext = null; bool advanced = false; while (!advanced) { Node oldHead = Head; Node oldTail = Tail; oldNext = oldHead.Next; if (oldHead == head) { // Empty case ? if (oldHead == oldTail) { // This should be false then if (oldNext != null) { // If not then the linked list is mal formed, update tail CustomInterlocked.CompareExchange(ref tail, oldNext, oldTail); continue; } result = default(T); return(false); } else { result = oldNext.Value; advanced = CustomInterlocked.CompareExchange(ref head, oldNext, oldHead) == oldHead; } } } oldNext.Value = default(T); CustomInterlocked.Decrement(ref count); return(true); }
public bool TryPop(out T result) { Node temp; do { temp = Head; // The stak is empty if (temp == null) { result = default(T); return(false); } } while (CustomInterlocked.CompareExchange(ref head, temp.Next, temp) != temp); CustomInterlocked.Decrement(ref count); result = temp.Value; return(true); }