bool ListPop(out T data) { Node rightNode = null, rightNodeNext = null, leftNode = head; data = default(T); do { rightNode = head.Next; if (rightNode == tail) { return(false); } data = rightNode.Data; rightNodeNext = rightNode.Next; if (!rightNodeNext.Marked) { if (AotInterlocked.CompareExchange(ref rightNode.Next, new Node(rightNodeNext), rightNodeNext) == rightNodeNext) { break; } } } while (true); if (AotInterlocked.CompareExchange(ref leftNode.Next, rightNodeNext, rightNode) != rightNodeNext) { ListSearch(rightNode.Key, ref leftNode); } return(true); }
public void PushRange(T[] items, int startIndex, int count) { Node insert = null; Node first = null; for (int i = startIndex; i < count; i++) { Node temp = new Node(); temp.Value = items[i]; temp.Next = insert; insert = temp; if (first == null) { first = temp; } } do { first.Next = head; } while (AotInterlocked.CompareExchange(ref head, insert, first.Next) != first.Next); Interlocked.Add(ref count, count); }
public void Enqueue(T item) { Node node = new Node(); node.Value = item; Node oldTail = null; Node oldNext = null; bool update = false; while (!update) { oldTail = tail; oldNext = oldTail.Next; // Did tail was already updated ? if (tail == oldTail) { if (oldNext == null) { // The place is for us update = AotInterlocked.CompareExchange(ref tail.Next, node, null) == null; } else { // another Thread already used the place so give him a hand by putting tail where it should be AotInterlocked.CompareExchange(ref tail, oldNext, oldTail); } } } // At this point we added correctly our node, now we have to update tail. If it fails then it will be done by another thread AotInterlocked.CompareExchange(ref tail, node, oldTail); Interlocked.Increment(ref count); }
public bool CompareAndExchange(bool expected, bool newVal) { int newTemp = newVal ? Set : UnSet; int expectedTemp = expected ? Set : UnSet; return(AotInterlocked.CompareExchange(ref flag, newTemp, expectedTemp) == expectedTemp); }
public bool TryGetNextCompletion(out TCompletion continuation) { continuation = null; if (single != null && (continuation = AotInterlocked.Exchange(ref single, null)) != null) { return(true); } return(completed != null && completed.TryPop(out continuation)); }
public void Add(TCompletion continuation) { if (single == null && AotInterlocked.CompareExchange(ref single, continuation, null) == null) { return; } if (completed == null) { AotInterlocked.CompareExchange(ref completed, new ConcurrentOrderedList <TCompletion> (), null); } completed.TryAdd(continuation); }
Node SetBucket(uint index, Node node) { try { slim.EnterReadLock(); CheckSegment(index, true); AotInterlocked.CompareExchange(ref buckets[index], node, null); return(buckets[index]); } finally { slim.ExitReadLock(); } }
public void Push(T item) { Node temp = new Node(); temp.Value = item; do { temp.Next = head; } while (AotInterlocked.CompareExchange(ref head, temp, temp.Next) != temp.Next); Interlocked.Increment(ref count); }
public int TryPopRange(T[] items, int startIndex, int count) { if (items == null) { throw new ArgumentNullException("items"); } if (startIndex < 0 || startIndex >= items.Length) { throw new ArgumentOutOfRangeException("startIndex"); } if (count < 0) { throw new ArgumentOutOfRangeException("count"); } if (startIndex + count > items.Length) { throw new ArgumentException("startIndex + count is greater than the length of items."); } Node temp; Node end; do { temp = head; if (temp == null) { return(-1); } end = temp; for (int j = 0; j < count; j++) { end = end.Next; if (end == null) { break; } } } while (AotInterlocked.CompareExchange(ref head, end, temp) != temp); int i; for (i = startIndex; i < startIndex + count && temp != null; i++) { items[i] = temp.Value; end = temp; temp = temp.Next; } Interlocked.Add(ref this.count, -(i - startIndex)); return(i - startIndex); }
Node ListSearch(ulong key, TKey subKey, ref Node left, Node h) { Node leftNodeNext = null, rightNode = null; do { Node t = h; Node tNext = t.Next; do { if (!tNext.Marked) { left = t; leftNodeNext = tNext; } t = tNext.Marked ? tNext.Next : tNext; if (t == tail) { break; } tNext = t.Next; } while (tNext.Marked || t.Key < key || (tNext.Key == key && !comparer.Equals(subKey, t.SubKey))); rightNode = t; if (leftNodeNext == rightNode) { if (rightNode != tail && rightNode.Next.Marked) { continue; } else { return(rightNode); } } if (AotInterlocked.CompareExchange(ref left.Next, rightNode, leftNodeNext) == leftNodeNext) { if (rightNode != tail && rightNode.Next.Marked) { continue; } else { return(rightNode); } } } while (true); }
Node ListSearch(int key, ref Node left) { Node leftNodeNext = null, rightNode = null; do { Node t = head; Node tNext = t.Next; do { if (!tNext.Marked) { left = t; leftNodeNext = tNext; } t = tNext.Marked ? tNext.Next : tNext; if (t == tail) { break; } tNext = t.Next; } while (tNext.Marked || t.Key < key); rightNode = t; if (leftNodeNext == rightNode) { if (rightNode != tail && rightNode.Next.Marked) { continue; } else { return(rightNode); } } if (AotInterlocked.CompareExchange(ref left.Next, rightNode, leftNodeNext) == leftNodeNext) { if (rightNode != tail && rightNode.Next.Marked) { continue; } else { return(rightNode); } } } while (true); }
public bool Remove(TCompletion continuation) { TCompletion temp = single; if (temp != null && temp == continuation && AotInterlocked.CompareExchange(ref single, null, continuation) == continuation) { return(true); } if (completed != null) { return(completed.TryRemove(continuation)); } return(false); }
bool ListInsert(Node newNode) { int key = newNode.Key; Node rightNode = null, leftNode = null; do { rightNode = ListSearch(key, ref leftNode); if (rightNode != tail && rightNode.Key == key) { return(false); } newNode.Next = rightNode; if (AotInterlocked.CompareExchange(ref leftNode.Next, newNode, rightNode) == rightNode) { return(true); } } while (true); }
internal void ChildCompleted (AggregateException childEx) { if (childEx != null) { if (ExceptionSlot.ChildExceptions == null) AotInterlocked.CompareExchange (ref ExceptionSlot.ChildExceptions, new ConcurrentQueue<AggregateException> (), null); ExceptionSlot.ChildExceptions.Enqueue (childEx); } if (childTasks.Signal () && status == TaskStatus.WaitingForChildrenToComplete) { ProcessChildExceptions (); Status = exSlot == null ? TaskStatus.RanToCompletion : TaskStatus.Faulted; ProcessCompleteDelegates (); if (parent != null && #if NET_4_5 !HasFlag (parent.CreationOptions, TaskCreationOptions.DenyChildAttach) && #endif HasFlag (creationOptions, TaskCreationOptions.AttachedToParent)) parent.ChildCompleted (this.Exception); } }
public bool TryPop(out T result) { Node temp; do { temp = head; // The stak is empty if (temp == null) { result = default(T); return(false); } } while (AotInterlocked.CompareExchange(ref head, temp.Next, temp) != temp); Interlocked.Decrement(ref count); result = temp.Value; return(true); }
bool ListDelete(Node startPoint, ulong key, TKey subKey, out T data) { Node rightNode = null, rightNodeNext = null, leftNode = null; data = default(T); Node markedNode = null; do { rightNode = ListSearch(key, subKey, ref leftNode, startPoint); if (rightNode == tail || rightNode.Key != key || !comparer.Equals(subKey, rightNode.SubKey)) { return(false); } data = rightNode.Data; rightNodeNext = rightNode.Next; if (!rightNodeNext.Marked) { if (markedNode == null) { markedNode = new Node(); } markedNode.Init(rightNodeNext); if (AotInterlocked.CompareExchange(ref rightNode.Next, markedNode, rightNodeNext) == rightNodeNext) { break; } } } while (true); if (AotInterlocked.CompareExchange(ref leftNode.Next, rightNodeNext, rightNode) != rightNode) { ListSearch(rightNode.Key, subKey, ref leftNode, startPoint); } return(true); }
public bool TryDequeue(out T result) { result = default(T); bool advanced = false; while (!advanced) { Node oldHead = head; Node oldTail = tail; Node 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 AotInterlocked.CompareExchange(ref tail, oldNext, oldTail); continue; } result = default(T); return(false); } else { result = oldNext.Value; advanced = AotInterlocked.CompareExchange(ref head, oldNext, oldHead) == oldHead; } } } Interlocked.Decrement(ref count); return(true); }
bool ListInsert(Node newNode, Node startPoint, out Node current, Func <T> dataCreator) { ulong key = newNode.Key; Node rightNode = null, leftNode = null; do { rightNode = current = ListSearch(key, newNode.SubKey, ref leftNode, startPoint); if (rightNode != tail && rightNode.Key == key && comparer.Equals(newNode.SubKey, rightNode.SubKey)) { return(false); } newNode.Next = rightNode; if (dataCreator != null) { newNode.Data = dataCreator(); } if (AotInterlocked.CompareExchange(ref leftNode.Next, newNode, rightNode) == rightNode) { return(true); } } while (true); }
protected virtual void Dispose(bool disposing) { if (!disposed.TryRelaxedSet()) { return; } if (handle != null) { var tmpHandle = AotInterlocked.Exchange(ref handle, null); if (used > 0) { // A tiny wait (just a few cycles normally) before releasing SpinWait wait = new SpinWait(); while (used > 0) { wait.SpinOnce(); } } // Spicy Pixel: Must use the public interface (e.g. Close) tmpHandle.Close(); // tmpHandle.Dispose (); } }
public bool Exchange(bool newVal) { int newTemp = newVal ? Set : UnSet; return(AotInterlocked.Exchange(ref flag, newTemp) == Set); }
internal void AddChild () { if (childTasks == null) AotInterlocked.CompareExchange (ref childTasks, new CountdownEvent (1), null); childTasks.AddCount (); }