public void Dispatch() { IQueueReader reader = null; Item item = new Item(); IQueueReader[] outstandingReaders = null; IQueueWaiter[] waiters = null; bool itemAvailable = true; lock (ThisLock) { itemAvailable = !((queueState == QueueState.Closed) || (queueState == QueueState.Shutdown)); this.GetWaiters(out waiters); if (queueState != QueueState.Closed) { itemQueue.MakePendingItemAvailable(); if (readerQueue.Count > 0) { item = itemQueue.DequeueAvailableItem(); reader = readerQueue.Dequeue(); if (queueState == QueueState.Shutdown && readerQueue.Count > 0 && itemQueue.ItemCount == 0) { outstandingReaders = new IQueueReader[readerQueue.Count]; readerQueue.CopyTo(outstandingReaders, 0); readerQueue.Clear(); itemAvailable = false; } } } } if (outstandingReaders != null) { if (completeOutstandingReadersCallback == null) { completeOutstandingReadersCallback = new Action <object>(CompleteOutstandingReadersCallback); } ActionItem.Schedule(completeOutstandingReadersCallback, outstandingReaders); } if (waiters != null) { CompleteWaitersLater(itemAvailable, waiters); } if (reader != null) { InvokeDequeuedCallback(item.DequeuedCallback); reader.Set(item); } }
private static void InvokeDequeuedCallbackLater(Action dequeuedCallback) { if (dequeuedCallback != null) { if (InputQueue <T> .onInvokeDequeuedCallback == null) { InputQueue <T> .onInvokeDequeuedCallback = new Action <object>(InputQueue <T> .OnInvokeDequeuedCallback); } ActionItem.Schedule(InputQueue <T> .onInvokeDequeuedCallback, dequeuedCallback); } }
static void InvokeDequeuedCallbackLater(Action dequeuedCallback) { if (dequeuedCallback != null) { if (onInvokeDequeuedCallback == null) { onInvokeDequeuedCallback = new Action <object>(OnInvokeDequeuedCallback); } ActionItem.Schedule(onInvokeDequeuedCallback, dequeuedCallback); } }
private static void ScheduleElapsedTimers(IOThreadTimer.TimerGroup timerGroup, long now) { IOThreadTimer.TimerQueue timerQueue = timerGroup.TimerQueue; while (timerQueue.Count > 0) { IOThreadTimer minTimer = timerQueue.MinTimer; if (minTimer.dueTime - now > minTimer.maxSkew) { break; } timerQueue.DeleteMinTimer(); ActionItem.Schedule(minTimer.callback, minTimer.callbackState); } }
public void Dispatch() { InputQueue <T> .IQueueReader queueReader = null; InputQueue <T> .Item item = new InputQueue <T> .Item(); InputQueue <T> .IQueueReader[] queueReaderArray = null; InputQueue <T> .IQueueWaiter[] queueWaiterArray = null; bool flag = true; lock (this.ThisLock) { flag = (this.queueState == InputQueue <T> .QueueState.Closed ? false : this.queueState != InputQueue <T> .QueueState.Shutdown); this.GetWaiters(out queueWaiterArray); if (this.queueState != InputQueue <T> .QueueState.Closed) { this.itemQueue.MakePendingItemAvailable(); if (this.readerQueue.Count > 0) { item = this.itemQueue.DequeueAvailableItem(); queueReader = this.readerQueue.Dequeue(); if (this.queueState == InputQueue <T> .QueueState.Shutdown && this.readerQueue.Count > 0 && this.itemQueue.ItemCount == 0) { queueReaderArray = new InputQueue <T> .IQueueReader[this.readerQueue.Count]; this.readerQueue.CopyTo(queueReaderArray, 0); this.readerQueue.Clear(); flag = false; } } } } if (queueReaderArray != null) { if (InputQueue <T> .completeOutstandingReadersCallback == null) { InputQueue <T> .completeOutstandingReadersCallback = new Action <object>(InputQueue <T> .CompleteOutstandingReadersCallback); } ActionItem.Schedule(InputQueue <T> .completeOutstandingReadersCallback, queueReaderArray); } if (queueWaiterArray != null) { InputQueue <T> .CompleteWaitersLater(flag, queueWaiterArray); } if (queueReader != null) { InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback); queueReader.Set(item); } }
private static void CompleteWaitersLater(bool itemAvailable, InputQueue <T> .IQueueWaiter[] waiters) { if (itemAvailable) { if (InputQueue <T> .completeWaitersTrueCallback == null) { InputQueue <T> .completeWaitersTrueCallback = new Action <object>(InputQueue <T> .CompleteWaitersTrueCallback); } ActionItem.Schedule(InputQueue <T> .completeWaitersTrueCallback, waiters); return; } if (InputQueue <T> .completeWaitersFalseCallback == null) { InputQueue <T> .completeWaitersFalseCallback = new Action <object>(InputQueue <T> .CompleteWaitersFalseCallback); } ActionItem.Schedule(InputQueue <T> .completeWaitersFalseCallback, waiters); }
static void ScheduleElapsedTimers(TimerGroup timerGroup, long now) { TimerQueue timerQueue = timerGroup.TimerQueue; while (timerQueue.Count > 0) { IOThreadTimer timer = timerQueue.MinTimer; long timeDiff = timer.dueTime - now; if (timeDiff <= timer.maxSkew) { timerQueue.DeleteMinTimer(); ActionItem.Schedule(timer.callback, timer.callbackState); } else { break; } } }
public void Clear() { lock (this.syncLock) { foreach (ConcurrentTransactionalDictionary <TKey, TValue> .TransactionInformation value in this.pendingTransactions.Values) { if (!value.HasWaiters) { continue; } while (value.Waiters.Count > 0) { ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = value.Waiters.Dequeue(); ActionItem.Schedule((object w) => ((ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)w).Cancel(), transactionalAsyncWaiter); } } this.internalDictionary.Clear(); this.pendingTransactions.Clear(); } }
static void CompleteWaitersLater(bool itemAvailable, IQueueWaiter[] waiters) { if (itemAvailable) { if (completeWaitersTrueCallback == null) { completeWaitersTrueCallback = new Action <object>(CompleteWaitersTrueCallback); } ActionItem.Schedule(completeWaitersTrueCallback, waiters); } else { if (completeWaitersFalseCallback == null) { completeWaitersFalseCallback = new Action <object>(CompleteWaitersFalseCallback); } ActionItem.Schedule(completeWaitersFalseCallback, waiters); } }
public TransactionInformation(Transaction transaction, TKey key, TValue previousValue, bool newEntry, ConcurrentTransactionalDictionary <TKey, TValue> owner) { this.key = key; this.NewEntry = newEntry; this.owner = owner; this.PreviousValue = previousValue; this.transaction = transaction; this.transaction.TransactionCompleted += Fx.ThunkTransactionEventHandler((object s, TransactionEventArgs e) => { bool status = e.Transaction.TransactionInformation.Status == TransactionStatus.Committed; bool flag = false; TValue tValue = default(TValue); lock (this.owner.syncLock) { this.owner.pendingTransactions.Remove(this.key); if (!status) { if (!this.NewEntry) { this.owner.internalDictionary[this.key] = this.PreviousValue; } else { this.owner.internalDictionary.Remove(this.key); } } if (this.waiters != null) { flag = this.owner.internalDictionary.TryGetValue(this.key, out tValue); } } if (this.waiters != null) { while (this.waiters.Count > 0) { ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter transactionalAsyncWaiter = this.waiters.Dequeue(); ActionItem.Schedule((object w) => ((ConcurrentTransactionalDictionary <TKey, TValue> .TransactionalAsyncWaiter)w).Signal(flag, tValue), transactionalAsyncWaiter); } } }); }
public static void Schedule(Action <object> callback, object state) { ActionItem.Schedule(callback, state, false); }
void ScheduleWait() { ActionItem.Schedule(this.onWaitCallback, null); this.waitScheduled = true; }
private void EnqueueAndDispatch(InputQueue <T> .Item item, bool canDispatchOnThisThread) { bool flag = false; InputQueue <T> .IQueueReader queueReader = null; bool flag1 = false; InputQueue <T> .IQueueWaiter[] queueWaiterArray = null; bool flag2 = true; lock (this.ThisLock) { flag2 = (this.queueState == InputQueue <T> .QueueState.Closed ? false : this.queueState != InputQueue <T> .QueueState.Shutdown); this.GetWaiters(out queueWaiterArray); if (this.queueState != InputQueue <T> .QueueState.Open) { flag = true; } else if (canDispatchOnThisThread) { if (this.readerQueue.Count != 0) { queueReader = this.readerQueue.Dequeue(); } else { this.itemQueue.EnqueueAvailableItem(item); } } else if (this.readerQueue.Count != 0) { this.itemQueue.EnqueuePendingItem(item); flag1 = true; } else { this.itemQueue.EnqueueAvailableItem(item); } } if (queueWaiterArray != null) { if (!canDispatchOnThisThread) { InputQueue <T> .CompleteWaitersLater(flag2, queueWaiterArray); } else { InputQueue <T> .CompleteWaiters(flag2, queueWaiterArray); } } if (queueReader != null) { InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback); queueReader.Set(item); } if (!flag1) { if (flag) { InputQueue <T> .InvokeDequeuedCallback(item.DequeuedCallback); this.DisposeItem(item); } return; } if (InputQueue <T> .onDispatchCallback == null) { InputQueue <T> .onDispatchCallback = new Action <object>(InputQueue <T> .OnDispatchCallback); } ActionItem.Schedule(InputQueue <T> .onDispatchCallback, this); }
void EnqueueAndDispatch(Item item, bool canDispatchOnThisThread) { bool disposeItem = false; IQueueReader reader = null; bool dispatchLater = false; IQueueWaiter[] waiters = null; bool itemAvailable = true; lock (ThisLock) { itemAvailable = !((queueState == QueueState.Closed) || (queueState == QueueState.Shutdown)); this.GetWaiters(out waiters); if (queueState == QueueState.Open) { if (canDispatchOnThisThread) { if (readerQueue.Count == 0) { itemQueue.EnqueueAvailableItem(item); } else { reader = readerQueue.Dequeue(); } } else { if (readerQueue.Count == 0) { itemQueue.EnqueueAvailableItem(item); } else { itemQueue.EnqueuePendingItem(item); dispatchLater = true; } } } else // queueState == QueueState.Closed || queueState == QueueState.Shutdown { disposeItem = true; } } if (waiters != null) { if (canDispatchOnThisThread) { CompleteWaiters(itemAvailable, waiters); } else { CompleteWaitersLater(itemAvailable, waiters); } } if (reader != null) { InvokeDequeuedCallback(item.DequeuedCallback); reader.Set(item); } if (dispatchLater) { if (onDispatchCallback == null) { onDispatchCallback = new Action <object>(OnDispatchCallback); } ActionItem.Schedule(onDispatchCallback, this); } else if (disposeItem) { InvokeDequeuedCallback(item.DequeuedCallback); DisposeItem(item); } }