887429749

Build Type

github

Committed by GitHub

Commit Message

Merge b7217eca0 into f5f53f43a

Pull Request Pull Request #1149: Improve benchs

Run Details

2300 of 3694 branches covered (62.26%)

Branch coverage included in aggregate %.

11 of 14 new or added lines in 4 files covered. (78.57%)

21 existing lines in 8 files now uncovered.

6162 of 8023 relevant lines covered (76.8%)

45577.4 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.67

/Zilon.Core/Zilon.Core/World/GlobeTransitionHandler.cs

﻿using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

using Zilon.Core.Graphs;
using Zilon.Core.MapGenerators;
using Zilon.Core.Tactics;

namespace Zilon.Core.World
{
    public sealed class GlobeTransitionHandler : IGlobeTransitionHandler, IDisposable
    {
        private const int TRANSITION_PER_GLOBE_ITERATION = 10;
        private readonly IGlobeExpander _globeExpander;

        private readonly SemaphoreSlim _semaphoreSlim;
        private readonly ITransitionPool _transitionPool;

        public GlobeTransitionHandler(IGlobeExpander globeExpander, ITransitionPool transitionPool)
        {
            _globeExpander = globeExpander ?? throw new ArgumentNullException(nameof(globeExpander));
            _transitionPool = transitionPool ?? throw new ArgumentNullException(nameof(transitionPool));

            //Instantiate a Singleton of the Semaphore with a value of 1. This means that only 1 thread can be granted access at a time.
            _semaphoreSlim = new SemaphoreSlim(1, 1);
        }

        private static bool FilterNodeToTransition(IGraphNode textNode, ISector nextSector)
        {
            var nodeIsBusyWithMonster = nextSector.ActorManager.Items.Any(x => x.Node == textNode);
            if (nodeIsBusyWithMonster)
            {
                return false;
            }

            var nodeIsBusyWithStaticObject = nextSector.StaticObjectManager.Items.Any(x => x.Node == textNode);
            if (nodeIsBusyWithStaticObject)
            {
                return false;
            }

            return true;
        }

        private async Task ProcessInnerAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
        {
            var sectorNode = transition.SectorNode;

            //TODO Разобраться с этим кодом.
            // https://blog.cdemi.io/async-waiting-inside-c-sharp-locks/
            //Asynchronously wait to enter the Semaphore. If no-one has been granted access to the Semaphore, code execution will proceed, otherwise this thread waits here until the semaphore is released 
            await _semaphoreSlim.WaitAsync();
            try
            {
                if (sectorNode.State != SectorNodeState.SectorMaterialized)
                {
                    await _globeExpander.ExpandAsync(sectorNode).ConfigureAwait(false);
                    globe.AddSectorNode(sectorNode);
                }

                // It was used as fallback later.
                var oldActorNode = actor.Node;

                try
                {
                    sector.ActorManager.Remove(actor);
                }
                catch (InvalidOperationException exception)
                {
                    // Пока ничего не делаем
                    Console.WriteLine(exception);
                    Console.WriteLine(actor);
                }

                var nextSector = sectorNode.Sector;

                if (nextSector is null)
                {
                    throw new InvalidOperationException();
                }

                var transitionItem =
                    new TransitionPoolItem(actor.Person, actor.TaskSource, nextSector, sector, oldActorNode);
                _transitionPool.Push(transitionItem);
            }
            finally
            {
                //When the task is ready, release the semaphore. It is vital to ALWAYS release the semaphore when we are ready, or else we will end up with a Semaphore that is forever locked.
                //This is why it is important to do the Release within a try...finally clause; program execution may crash or take a different path, this way you are guaranteed execution
                _semaphoreSlim.Release();
            }
        }

        private static void TryToTransitPersonToTargetSector(TransitionPoolItem transitionItem)
        {
            var nextSector = transitionItem.NextSector;

            var transitionKeyPairsInNextSector = nextSector.Map.Transitions
                .Where(x => x.Value.SectorNode.Sector == transitionItem.OldSector);

            IGraphNode? nodeForTransition;
            if (transitionKeyPairsInNextSector.Any())
            {
                var transitionKeyPairInNextSector = transitionKeyPairsInNextSector.First();

                nodeForTransition = transitionKeyPairInNextSector.Key;
            }
            else
            {
                Debug.Fail("In target sector must be transition to source sector.");
                nodeForTransition = nextSector.Map.Nodes.FirstOrDefault();

                if (nodeForTransition is null)
                {
                    nodeForTransition = transitionItem.OldNode;
                }
            }

            var availableNextNodesToTransition = nextSector.Map.GetNext(nodeForTransition);

            var allPotentialNodesToTransition = new[] { nodeForTransition }.Concat(availableNextNodesToTransition);
            var allAvailableNodesToTransition = allPotentialNodesToTransition
                .Where(x => FilterNodeToTransition(x, nextSector)).ToArray();

            var availableNodeToTransition = allAvailableNodesToTransition.FirstOrDefault();
            if (availableNodeToTransition is null)
            {
                // I dont know what I can do.
                // I think it was solved when a some transition pool was developed.
                // Now just return person into old sector in old transition node.
                nextSector = transitionItem.OldSector;
                availableNodeToTransition = transitionItem.OldNode;
            }

            var actorInNewSector =
                new Actor(transitionItem.Person, transitionItem.TaskSource, availableNodeToTransition);
            nextSector.ActorManager.Add(actorInNewSector);
        }

        public void Dispose()
        {
            _semaphoreSlim.Dispose();
        }

        public Task InitActorTransitionAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
        {
            if (globe is null)
            {
                throw new ArgumentNullException(nameof(globe));
            }

            if (sector is null)
            {
                throw new ArgumentNullException(nameof(sector));
            }

            if (actor is null)
            {
                throw new ArgumentNullException(nameof(actor));
            }

            if (transition is null)
            {
                throw new ArgumentNullException(nameof(transition));
            }

            return ProcessInnerAsync(globe, sector, actor, transition);
        }

        public void UpdateTransitions()
        {
            // The counter is restriction of transition per globe iteration.
            var counter = TRANSITION_PER_GLOBE_ITERATION;

            // Transit persons from pool to target sector levels while the pool is not empty or transition limit reached.
            do
            {
                var transitionItem = _transitionPool.Pop();

                if (transitionItem is null)
                {
                    return;
                }

                TryToTransitPersonToTargetSector(transitionItem);

                counter--;
            } while (counter > 0);
        }
    }
}

1	using System;
2	using System.Diagnostics;
3	using System.Linq;
4	using System.Threading;
5	using System.Threading.Tasks;
6
7	using Zilon.Core.Graphs;
8	using Zilon.Core.MapGenerators;
9	using Zilon.Core.Tactics;
10
11	namespace Zilon.Core.World
12	{
13	public sealed class GlobeTransitionHandler : IGlobeTransitionHandler, IDisposable
14	{
15	private const int TRANSITION_PER_GLOBE_ITERATION = 10;
16	private readonly IGlobeExpander _globeExpander;
17
18	private readonly SemaphoreSlim _semaphoreSlim;
19	private readonly ITransitionPool _transitionPool;
20
21	public GlobeTransitionHandler(IGlobeExpander globeExpander, ITransitionPool transitionPool)	72✔
22	{
23	_globeExpander = globeExpander ?? throw new ArgumentNullException(nameof(globeExpander));	72!
24	_transitionPool = transitionPool ?? throw new ArgumentNullException(nameof(transitionPool));	72!
25
26	//Instantiate a Singleton of the Semaphore with a value of 1. This means that only 1 thread can be granted access at a time.
27	_semaphoreSlim = new SemaphoreSlim(1, 1);	72✔
28	}	72✔
29
30	private static bool FilterNodeToTransition(IGraphNode textNode, ISector nextSector)
31	{
32	var nodeIsBusyWithMonster = nextSector.ActorManager.Items.Any(x => x.Node == textNode);	44✔
33	if (nodeIsBusyWithMonster)	44!
34	{
UNCOV 35	return false;	×
36	}
37
38	var nodeIsBusyWithStaticObject = nextSector.StaticObjectManager.Items.Any(x => x.Node == textNode);	44✔
39	if (nodeIsBusyWithStaticObject)	44!
40	{
41	return false;	×
42	}
43
44	return true;	44✔
45	}
46
47	private async Task ProcessInnerAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
48	{
49	var sectorNode = transition.SectorNode;
50
51	//TODO Разобраться с этим кодом.
52	// https://blog.cdemi.io/async-waiting-inside-c-sharp-locks/
53	//Asynchronously wait to enter the Semaphore. If no-one has been granted access to the Semaphore, code execution will proceed, otherwise this thread waits here until the semaphore is released
54	await _semaphoreSlim.WaitAsync();
55	try
56	{
57	if (sectorNode.State != SectorNodeState.SectorMaterialized)
58	{
59	await _globeExpander.ExpandAsync(sectorNode).ConfigureAwait(false);
60	globe.AddSectorNode(sectorNode);
61	}
62
63	// It was used as fallback later.
64	var oldActorNode = actor.Node;
65
66	try
67	{
68	sector.ActorManager.Remove(actor);
69	}
70	catch (InvalidOperationException exception)
71	{
72	// Пока ничего не делаем
73	Console.WriteLine(exception);
74	Console.WriteLine(actor);
75	}
76
77	var nextSector = sectorNode.Sector;
78
79	if (nextSector is null)
80	{
81	throw new InvalidOperationException();
82	}
83
84	var transitionItem =
85	new TransitionPoolItem(actor.Person, actor.TaskSource, nextSector, sector, oldActorNode);
86	_transitionPool.Push(transitionItem);
87	}
88	finally
89	{
90	//When the task is ready, release the semaphore. It is vital to ALWAYS release the semaphore when we are ready, or else we will end up with a Semaphore that is forever locked.
91	//This is why it is important to do the Release within a try...finally clause; program execution may crash or take a different path, this way you are guaranteed execution
92	_semaphoreSlim.Release();
93	}
94	}
95
96	private static void TryToTransitPersonToTargetSector(TransitionPoolItem transitionItem)
97	{
98	var nextSector = transitionItem.NextSector;	7✔
99
100	var transitionKeyPairsInNextSector = nextSector.Map.Transitions	7✔
101	.Where(x => x.Value.SectorNode.Sector == transitionItem.OldSector);	7✔
102
103	IGraphNode? nodeForTransition;
104	if (transitionKeyPairsInNextSector.Any())	7!
105	{
106	var transitionKeyPairInNextSector = transitionKeyPairsInNextSector.First();	7✔
107
108	nodeForTransition = transitionKeyPairInNextSector.Key;	7✔
109	}
110	else
111	{
112	Debug.Fail("In target sector must be transition to source sector.");
NEW 113	nodeForTransition = nextSector.Map.Nodes.FirstOrDefault();	×
114
NEW 115	if (nodeForTransition is null)	×
116	{
NEW 117	nodeForTransition = transitionItem.OldNode;	×
118	}
119	}
120
121	var availableNextNodesToTransition = nextSector.Map.GetNext(nodeForTransition);	7✔
122
123	var allPotentialNodesToTransition = new[] { nodeForTransition }.Concat(availableNextNodesToTransition);	7✔
124	var allAvailableNodesToTransition = allPotentialNodesToTransition	7✔
125	.Where(x => FilterNodeToTransition(x, nextSector)).ToArray();	7✔
126
127	var availableNodeToTransition = allAvailableNodesToTransition.FirstOrDefault();	7✔
128	if (availableNodeToTransition is null)	7!
129	{
130	// I dont know what I can do.
131	// I think it was solved when a some transition pool was developed.
132	// Now just return person into old sector in old transition node.
133	nextSector = transitionItem.OldSector;	×
134	availableNodeToTransition = transitionItem.OldNode;	×
135	}
136
137	var actorInNewSector =	7✔
138	new Actor(transitionItem.Person, transitionItem.TaskSource, availableNodeToTransition);	7✔
139	nextSector.ActorManager.Add(actorInNewSector);	7✔
140	}	7✔
141
142	public void Dispose()
143	{
144	_semaphoreSlim.Dispose();	×
145	}	×
146
147	public Task InitActorTransitionAsync(IGlobe globe, ISector sector, IActor actor, SectorTransition transition)
148	{
149	if (globe is null)	7!
150	{
151	throw new ArgumentNullException(nameof(globe));	×
152	}
153
154	if (sector is null)	7!
155	{
156	throw new ArgumentNullException(nameof(sector));	×
157	}
158
159	if (actor is null)	7!
160	{
161	throw new ArgumentNullException(nameof(actor));	×
162	}
163
164	if (transition is null)	7!
165	{
166	throw new ArgumentNullException(nameof(transition));	×
167	}
168
169	return ProcessInnerAsync(globe, sector, actor, transition);	7✔
170	}
171
172	public void UpdateTransitions()
173	{
174	// The counter is restriction of transition per globe iteration.
175	var counter = TRANSITION_PER_GLOBE_ITERATION;	7,310✔
176
177	// Transit persons from pool to target sector levels while the pool is not empty or transition limit reached.
178	do
179	{
180	var transitionItem = _transitionPool.Pop();	7,317✔
181
182	if (transitionItem is null)	7,317✔
183	{
184	return;	7,310✔
185	}
186
187	TryToTransitPersonToTargetSector(transitionItem);	7✔
188
189	counter--;	7✔
190	} while (counter > 0);	7!
191	}	×
192	}
193	}

kreghek / Zilon_Roguelike / 887429749

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous