public void AddRemoveAndCount() { for (int i = 0; i < 10000; i++) { var random = new Random(); var removed = 0; var subject = new ConcurrentLinkedList <int>(); var toAdd = random.Next(0, 1000); var toRemove = random.Next(0, 1000); var actions = new List <Action>(); for (int j = 0; j < toAdd; j++) { actions.Add(() => subject.Add(0)); } for (int j = 0; j < toRemove; j++) { actions.Add(() => { if (subject.RemoveStart()) { Interlocked.Increment(ref removed); } }); } Parallel.Invoke(actions.OrderBy(x => random.NextDouble()).ToArray()); Assert.Equal(toAdd - removed, subject.Count); Assert.Equal(toAdd - removed, subject.Count()); } }
//internal void OnDisconnect(Func<Exception, Task> onDisconnect) //{ //} //IAsyncEnumerable does not really make sense here public void ApplyInputs(Dictionary <Guid, PlayerInputs> inputs) { gameState.Handle(gameStateTracker.UpdateGameState()); PlayerInputApplyer.Apply(gameState, inputs); //foreach (var (p1, p2) in PhysicsEngine2.PlayerPairs(gameState)) //{ // PhysicsMath2.TryPushBallBall(p1, p2); //} gameState.Simulate(gameStateTracker); // clear out effects after a few frames var nextCollisions = new ConcurrentLinkedList <GameState.Collision>(); foreach (var item in gameState.collisions.Where(x => x.Frame + 3 > gameState.Frame)) { nextCollisions.Add(item); } gameState.collisions = nextCollisions; var nextGoalsScored = new ConcurrentLinkedList <GameState.GoalScored>(); foreach (var item in gameState.GoalsScored.Where(x => x.Frame + 3 > gameState.Frame)) { nextGoalsScored.Add(item); } gameState.GoalsScored = nextGoalsScored; }
public SessionClient(Action <ActionToken> actionChangeCallback) { _actionChangeCallback = actionChangeCallback; IsHandleFrameEnabled = true; RunningActions = new ConcurrentLinkedList <ActionBase>(); PendingExclusiveActions = new ConcurrentQueue <ActionBase>(); }
public Enumerator(ConcurrentLinkedList <T> list) { _List = list; _Current = default; _CurrentAddress = list._HeadAddress; MoveNext(); }
private ConcurrentLinkedList <BOX <int> > AddCheckEntries(bool bTail = true, int countEntries = 10) { var LL = new ConcurrentLinkedList <BOX <int> >(); var n = new List <int>(Enumerable.Range(0, countEntries)); foreach (var i in n) { if (bTail) { LL.AddTail(new BOX <int>(i)); } else { LL.AddHead(new BOX <int>(i)); } } var nFound = 0; var node = LL.Head; do { Assert.AreNotEqual(node.Value, null); Assert.AreEqual(true, n.Contains(node.Value.VALUE)); nFound++; }while ((node = node.Next) != null); Trace.WriteLine(string.Format("Total Entries {0}", LL.Count), "info"); Assert.AreEqual(nFound, n.Count); return(LL); }
public static void Handle(this GameState gameState, GameStateUpdate gameStateUpdate) { gameState.Frame = gameStateUpdate.Frame; gameState.GameBall = gameStateUpdate.Ball; var nextCollisions = new ConcurrentLinkedList <Collision>(); foreach (var item in gameStateUpdate.Collisions) { nextCollisions.Add(item); } gameState.collisions = nextCollisions; gameState.CountDownState = gameStateUpdate.CountDownState; var nextGoalsScores = new ConcurrentLinkedList <GoalScored>(); foreach (var item in gameStateUpdate.GoalsScored) { nextGoalsScores.Add(item); } gameState.GoalsScored = nextGoalsScores; var nextPlayers = new RawConcurrentIndexed <Guid, Player>(); foreach (var item in gameStateUpdate.Players) { nextPlayers.TryAdd(item.Id, item); } gameState.players = nextPlayers; gameState.RightScore = gameStateUpdate.RightScore; gameState.LeftScore = gameStateUpdate.LeftScore; }
public PublisherThread(NMSConnectionFactory factory, ConcurrentLinkedList <Message> messageSource, String topic, String user, String password) { this.factory = factory; this.messageSource = messageSource; this.topic = topic; this.user = user; this.password = password; }
public void AddBeforeIsNotContainsTargetNodeThenAddedValueAsNewFirstNode() { var list = new ConcurrentLinkedList <int>(); list.AddLast(10); var newNode = list.AddBefore(new ConcurrentLinkedListNode <int>(), 35); Assert.Equal(newNode, list.First); }
public void AddAfterContainsTargetNodeButHeIsLast() { var list = new ConcurrentLinkedList <int>(); var node = list.AddLast(10); var addedNode = list.AddAfter(node, 35); Assert.Equal(addedNode, list.Last); }
public void AddBeforeContainsTargetNode() { var list = new ConcurrentLinkedList <int>(); var node = list.AddLast(10); var addedNode = list.AddBefore(node, 35); Assert.Equal(addedNode, node.Prev); }
public void AddFirstTest() { var list = new ConcurrentLinkedList <Guid>(); var array = Enumerable.Range(0, 4).Select(x => Guid.NewGuid()).ToArray(); foreach (var value in array.Reverse()) { list.AddFirst(value); } list.ToArray().Should().Equal(array); }
public void AddLastByItemIsNodeResultNodeHasNoOneNodePrev() { var list = new ConcurrentLinkedList <int>(); var node = new ConcurrentLinkedListNode <int>() { Value = 10 }; list.AddFirst(node); Assert.NotNull(list._root); Assert.Null(node.Prev); }
public void AddAtHeadCheckCount() { var LL = new ConcurrentLinkedList <BOX <int> >(); var n = Enumerable.Range(0, 100); foreach (var i in n) { LL.AddHead(new BOX <int>(i)); } Trace.WriteLine(string.Format("Total Entries{0}", LL.Count), "info"); Assert.AreEqual(LL.Count, n.Count()); }
public void AddFirstByItemParamResultNodeHasNoOneNodePrev() { var list = new ConcurrentLinkedList <int>(); list.AddFirst(10); list.AddFirst(5); list.AddFirst(3); var node = list.AddFirst(7); Assert.NotNull(list._root); Assert.Null(node.Prev); Assert.NotNull(list.First); Assert.Equal(7, list.First.Value); }
public void AddLastByItemResultNodeHasNoOneNodeNext() { var list = new ConcurrentLinkedList <int>(); list.AddLast(10); list.AddLast(5); list.AddLast(6); var node = list.AddLast(11); Assert.NotNull(list._root); Assert.Null(node.Next); Assert.NotNull(list.Last); Assert.Equal(11, list.Last.Value); }
public void AddParallelTest() { var list = new ConcurrentLinkedList <Guid>(); var array = Enumerable.Range(0, 1024).Select(_ => Guid.NewGuid()).ToArray(); Parallel.ForEach(array, () => - 1, (guid, state, index) => { if (index == -1) { return(list.AddFirst(guid)); } else { return(list.AddAfter(index, guid)); } }, i => { }); list.ToArray().Should().BeEquivalentTo(array); }
private ConcurrentLinkedList <BOX <long> > CreateProducersConsumers(int countEntries, int TailProducers, int TailConsumers, int HeadProducers, int HeadConsumers, int MaxProducerRandomDelay, int MaxConsumersRandomDelay, int InitialConsumerDelay = 10) { var currentEntry = 0; var totalProduced = 0; var totalConsumed = 0; var LL = new ConcurrentLinkedList <BOX <long> >(); var rnd = new Random(); List <Task <int> > consumerTasks = new List <Task <int> >(); List <Task <int> > producerTasks = new List <Task <int> >(); Func <bool, string, Task <int> > producer = async(bIsTail, producerId) => { var produced = 0; Trace.WriteLine(string.Format("Producer {0} is {1}", producerId, bIsTail ? "Tail" : "Head")); while (Interlocked.Increment(ref currentEntry) <= countEntries) { produced++; var newVal = DateTime.UtcNow.Ticks; Trace.WriteLine(string.Format("Producer {0} + {1}", producerId, newVal)); if (bIsTail) { LL.AddTail(new BOX <long>(newVal)); } else { LL.AddHead(new BOX <long>(newVal)); } await Task.Delay(rnd.Next(0, MaxProducerRandomDelay)); } return(produced); }; Func <bool, string, Task <int> > consumer = async(bIsTail, consumerId) => { // all consumer wait a bit this almost elminate the need for that CX below await Task.Delay(InitialConsumerDelay); // Trace.WriteLine(string.Format("Consumer {0} is {1}", consumerId, bIsTail ? "Tail" : "Head")); var consumed = 0; BOX <long> node; while ((bIsTail && null != (node = LL.RemoveTail())) || (!bIsTail && null != (node = LL.RemoveHead()))) { Assert.AreNotEqual(null, node.VALUE); Trace.WriteLine(string.Format("Consumer {0} - {1}", consumerId, node.VALUE)); consumed++; await Task.Delay(rnd.Next(0, MaxConsumersRandomDelay)); } Trace.WriteLine(string.Format("Consumer {0} is {1} -- Exited", consumerId, bIsTail ? "Tail" : "Head")); return(consumed); }; // give a head start for consumers. for (int p = 1; p <= TailProducers + HeadProducers; p++) { //avoid hoisted variables. var isTail = (TailProducers > 0 && p <= TailProducers); var producerName = string.Concat("P", p); producerTasks.Add(Task.Run( async() => await producer(isTail, producerName)) ); } for (int c = 1; c <= TailConsumers + HeadConsumers; c++) { var isTail = (TailConsumers > 0 && c <= TailConsumers); var consumerName = string.Concat("C", c); consumerTasks.Add(Task.Run( async() => await consumer(isTail, consumerName)) ); } Task.WhenAll(producerTasks).Wait(); Task.WhenAll(consumerTasks).Wait(); // if after all said and done we still have items consume them. if (LL.Count > 0) { Trace.WriteLine("Consumers exited before producers completed work, creating a CX", "warnings"); totalConsumed += Task <int> .Run(async() => await consumer(true, "CX")).Result; } // calculate all produced and consumed foreach (var p in producerTasks) { totalProduced += p.Result; } foreach (var c in consumerTasks) { totalConsumed += c.Result; } // are we clean? Trace.WriteLine(string.Format("completed produced:{0} consumed:{1}", totalProduced, totalConsumed), "info"); Assert.AreEqual(totalProduced, totalConsumed); return(LL); }
public ThreadedStringListener() { cll = new ConcurrentLinkedList<string> (); }
public void AddBeforeIsNotContainsNodes() { var list = new ConcurrentLinkedList <int>(); Assert.Throws <Exception>(() => list.AddBefore(new ConcurrentLinkedListNode <int>(), 10)); }