protected virtual void UnregisterReceiver(ReceiverTask receiver) { lock (Store) { Store.RemoveReceiver(receiver); } }
public Interleave(TeardownReceiverGroup teardown, ExclusiveReceiverGroup mutex, ConcurrentReceiverGroup concurrent) { ReceiverTask[] branches = teardown._branches; for (int i = 0; i < branches.Length; i++) { ReceiverTask receiverTask = branches[i]; receiverTask.ArbiterContext = new InterleaveReceiverContext(InterleaveReceivers.Teardown); } ReceiverTask[] branches2 = mutex._branches; for (int j = 0; j < branches2.Length; j++) { ReceiverTask receiverTask2 = branches2[j]; receiverTask2.ArbiterContext = new InterleaveReceiverContext(InterleaveReceivers.Exclusive); } ReceiverTask[] branches3 = concurrent._branches; for (int k = 0; k < branches3.Length; k++) { ReceiverTask receiverTask3 = branches3[k]; receiverTask3.ArbiterContext = new InterleaveReceiverContext(InterleaveReceivers.Concurrent); } _mutexBranches = new List <ReceiverTask>(teardown._branches); ReceiverTask[] branches4 = mutex._branches; for (int l = 0; l < branches4.Length; l++) { ReceiverTask item = branches4[l]; _mutexBranches.Add(item); } _concurrentBranches = new List <ReceiverTask>(concurrent._branches); }
public void Shutdown() { sendQueue.ShutdownGracefully(); recvQueue.ShutdownGracefully(); socket.Shutdown(SocketShutdown.Send); SenderTask.Wait(); ReceiverTask.Wait(); }
public bool Evaluate(ReceiverTask receiver, ref ITask deferredTask) { deferredTask = null; if (ShouldCommit()) { deferredTask = new Task(new Handler(Commit)); } return(false); }
private static ITask DequeuePendingItem(ReceiverTask receiver, int queueDepthMin) { Queue <Tuple <ITask, ReceiverTask> > pendingItems = ((InterleaveReceiverContext)receiver.ArbiterContext).PendingItems; if (pendingItems.Count >= queueDepthMin) { return(pendingItems.Dequeue().Item0); } return(null); }
protected virtual void RegisterReceiver(ReceiverTask receiver) { lock (Store) { if (!Store.IsElementListEmpty) { PortElement <T> portElement = Store.ElementListFirst; int num = Store.ElementCount; while (true) { PortElement <T> next = portElement._next; ITask task = null; bool flag2 = receiver.Evaluate(portElement, ref task); if (task != null) { receiver.TaskQueue.Enqueue(task); } if (flag2) { Store.ElementListRemove(portElement); } if (receiver.State != ReceiverTaskState.Persistent) { if (flag2) { break; } if (task != null) { goto IL_88; } } portElement = next; num--; if (num <= 0) { goto IL_88; } } return; } IL_88: if (_mode == PortMode.OptimizedSingleReissueReceiver && Store.ReceiverCount == 1) { throw new InvalidOperationException("PortMode.OptimizedSingleReissueReceiver allows only a single receiver"); } Store.AddReceiver(receiver); } }
public bool Evaluate(ReceiverTask receiver, ref ITask deferredTask) { if (receiver == null) { throw new ArgumentNullException("receiver"); } Choice.ChoiceStage choiceStage = (Choice.ChoiceStage)Interlocked.Increment(ref _stage); if (choiceStage == Choice.ChoiceStage.Commited) { Task <ITask> task = new Task <ITask>(deferredTask, new Handler <ITask>(Cleanup)); deferredTask = task; return(true); } deferredTask = null; return(false); }
protected virtual ReceiverTask[] GetReceivers() { ReceiverTask[] result; lock (Store) { if (Store.ReceiverCount == 0) { result = new ReceiverTask[0]; } else { result = Store.ReceiverListAsObjectArray; } } return(result); }
void ReceiverTask_RisedEventSetsCorrectData_ArraysAreEqual() { var data = new byte[] { 60, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 10, 62 }; var receivedData = new byte[22]; var streamResource = new Mock <IStreamResource>(); streamResource.Setup(x => x.Read(data, 0, 22)).Returns(22); streamResource.Setup(x => x.BytesToRead()).Returns(22); var receiverTask = new ReceiverTask(streamResource.Object); receiverTask.DataReceived += (sender, args) => receivedData = args.Data; receiverTask.Start(); Assert.Equal(receivedData.Length, data.Length); }
internal void AddReceiver(ReceiverTask r) { if (ActiveReceiver == null && (Receivers == null || Receivers.Count == 0)) { ActiveReceiver = r; return; } if (Receivers == null) { Receivers = new List <ReceiverTask>(); } if (ActiveReceiver != null) { Receivers.Add(ActiveReceiver); ActiveReceiver = null; } Receivers.Add(r); }
internal void RemoveReceiver(ReceiverTask r) { if (ActiveReceiver == r) { ActiveReceiver = null; return; } if (Receivers == null) { return; } Receivers.Remove(r); if (Receivers.Count == 1) { ActiveReceiver = Receivers[0]; Receivers.Clear(); } }
public TeardownReceiverGroup(params ReceiverTask[] branches) : base(branches) { if (branches == null) { throw new ArgumentNullException("branches"); } for (int i = 0; i < branches.Length; i++) { ReceiverTask receiverTask = branches[i]; if (receiverTask == null) { throw new ArgumentNullException("branches"); } if (receiverTask.State == ReceiverTaskState.Persistent) { throw new ArgumentOutOfRangeException("branches", Resource1.TeardownBranchesCannotBePersisted); } } }
public Choice(params ReceiverTask[] branches) { if (branches == null) { throw new ArgumentNullException("branches"); } if (_stage != 0) { throw new InvalidOperationException(Resource1.ChoiceAlreadyActiveException); } for (int i = 0; i < branches.Length; i++) { ReceiverTask receiverTask = branches[i]; if (receiverTask.State == ReceiverTaskState.Persistent) { throw new ArgumentOutOfRangeException("branches", Resource1.ChoiceBranchesCannotBePersisted); } } _branches = new List <ReceiverTask>(branches); }
public override string ToString() { ICollection <ReceiverTask> receivers = GetReceivers(); int itemCount = ItemCount; int count = receivers.Count; string text = string.Format(CultureInfo.InvariantCulture, "Port Summary:\n Hash:{0}\n Type:{1}\n Elements:{2}\n ReceiveThunks:{3}\nReceive Arbiter Hierarchy:\n", new object[] { GetHashCode(), base.GetType().GetGenericArguments()[0], itemCount, count }); ReceiverTask[] receivers2 = GetReceivers(); for (int i = 0; i < receivers2.Length; i++) { ReceiverTask receiverTask = receivers2[i]; string str = receiverTask.ToString(); text = text + str + "\n"; } return(text); }
public void Disconnect() { CancellationSource.Cancel(); if (SenderTask != null) { SenderTask.Wait(); SenderTask = null; } if (ReceiverTask != null) { ReceiverTask.Wait(); ReceiverTask = null; } if (Socket != null) { Socket.Close(); Socket = null; } }
public ITask TryDequeuePendingTask(ReceiverTask receiver, int queueDepthMin) { if (receiver == null) { throw new ArgumentNullException("receiver"); } if (!(receiver.ArbiterContext is InterleaveReceiverContext)) { throw new ArgumentException("receiver", Resource1.InterleaveInvalidReceiverTaskArgumentForTryDequeuePendingItems); } if (queueDepthMin <= 0) { throw new ArgumentOutOfRangeException("queueDepthMin"); } ITask result; lock (_mutexBranches) { result = Interleave.DequeuePendingItem(receiver, queueDepthMin); } return(result); }
public void Disconnect() { CancellationSource.Cancel(); if (SenderTask != null) { // Remove this line and se if that fix the problem. // SenderTask.Wait(); SenderTask = null; } if (ReceiverTask != null) { ReceiverTask.Wait(); ReceiverTask = null; } if (Socket != null) { // Socket.Close(); Socket = null; } }
void IPortReceive.UnregisterReceiver(ReceiverTask receiver) { UnregisterReceiver(receiver); }
private void PostInternalFast(T item) { ReceiverTask activeReceiver = Store.ActiveReceiver; activeReceiver.Consume(new PortElement <T>(item)); }
public bool Evaluate(ReceiverTask receiver, ref ITask deferredTask) { if (_state == ArbiterTaskState.Done) { deferredTask = null; return(false); } lock (_mutexBranches) { if (((InterleaveReceiverContext)receiver.ArbiterContext).ReceiverGroup == InterleaveReceivers.Teardown && receiver.State == ReceiverTaskState.Onetime) { _state = ArbiterTaskState.Done; object obj = Interlocked.CompareExchange(ref _final, deferredTask, null); if (obj != null) { deferredTask = null; return(false); } } bool flag2 = ((InterleaveReceiverContext)receiver.ArbiterContext).ReceiverGroup != InterleaveReceivers.Concurrent; bool flag3 = Arbitrate(flag2); if (flag2) { if (flag3) { if (_final == deferredTask) { _final = null; deferredTask = new Task <ITask>(deferredTask, new Handler <ITask>(Cleanup)); } else { deferredTask.ArbiterCleanupHandler = new Handler(ExclusiveFinalizer); } } else { if (deferredTask != _final) { ((InterleaveReceiverContext)receiver.ArbiterContext).PendingItems.Enqueue(new Tuple <ITask, ReceiverTask>(deferredTask, receiver)); } deferredTask = null; } if (deferredTask != null) { receiver.TaskQueue.Enqueue(deferredTask); deferredTask = null; } } else if (flag3) { deferredTask.ArbiterCleanupHandler = new Handler(ConcurrentFinalizer); } else { ((InterleaveReceiverContext)receiver.ArbiterContext).PendingItems.Enqueue(new Tuple <ITask, ReceiverTask>(deferredTask, receiver)); deferredTask = null; } } return(true); }
void IPortReceive.RegisterReceiver(ReceiverTask receiver) { RegisterReceiver(receiver); }
internal void PostInternal(bool insertAtHead, PortElement <T> node) { bool flag = false; ITask task = null; DispatcherQueue dispatcherQueue = null; lock (Store) { if (insertAtHead) { Store.ElementListAddFirst(node); } else { Store.ElementListAddLast(node); } if (Store.ReceiverCount == 0) { return; } int num = 1; if (Store.ActiveReceiver == null) { num = Store.ReceiverCount; } ReceiverTask receiverTask = Store.ActiveReceiver; int i = 0; while (i < num) { if (num != 1) { receiverTask = Store.GetReceiverAtIndex(i); } task = null; flag = receiverTask.Evaluate(node, ref task); dispatcherQueue = receiverTask.TaskQueue; if (flag) { Store.ElementListRemove(node); if (receiverTask.State != ReceiverTaskState.Persistent) { Store.RemoveReceiver(receiverTask); if (i > 1) { i--; } else { receiverTask = Store.ActiveReceiver; } num = Store.ReceiverCount; break; } break; } else { if (task != null) { dispatcherQueue.Enqueue(task); } i++; } } } if (flag && task != null) { dispatcherQueue.Enqueue(task); } }