Core/Maps: Enabled maps updater. and reduce cpu usage (i hope)

Source/Framework/Threading/ProducerConsumerQueue.cs

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2012-2018 CypherCore <http://github.com/CypherCore>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Framework.Threading
+{
+    public class ProducerConsumerQueue<T>
+    {
+        object _queueLock = new object();
+        Queue<T> _queue = new Queue<T>();
+        volatile bool _shutdown;
+
+        public ProducerConsumerQueue()
+        {
+            _shutdown = false;
+        }
+
+        public void Push(T value)
+        {
+            lock (_queueLock)
+            {
+                _queue.Enqueue(value);
+                Monitor.PulseAll(_queueLock);
+            }
+        }
+
+        public bool Empty()
+        {
+            lock (_queueLock)
+                return _queue.Count == 0;
+        }
+
+        public bool Pop(out T value)
+        {
+            value = default(T);
+            lock (_queueLock)
+            {
+                if (_queue.Count == 0 || _shutdown)
+                    return false;
+
+                value = _queue.Dequeue();
+                return true;
+            }
+        }
+
+        public void WaitAndPop(out T value)
+        {
+            value = default(T);
+            lock (_queueLock)
+            {
+                while (_queue.Count == 0 && !_shutdown)
+                    Monitor.Wait(_queueLock);
+
+                if (_queue.Count == 0 || _shutdown)
+                    return;
+
+                value = _queue.Dequeue();
+            }
+        }
+
+        public void Cancel()
+        {
+            lock (_queueLock)
+            {
+                while (_queue.Count != 0)
+                {
+                    T value = _queue.Dequeue();
+                }
+
+                _shutdown = true;
+                Monitor.PulseAll(_queueLock);
+            }
+        }
+    }
+}

Source/Game/Maps/MapManager.cs

@@ -224,10 +224,10 @@ namespace Game.Entities
                 return;
 
             var time = (uint)i_timer.GetCurrent();
-            foreach (var map in i_maps.Values.ToList())
+            foreach (var map in i_maps.Values)
             {
                 if (m_updater != null)
-                    m_updater.Enqueue(map, (uint)i_timer.GetCurrent());
+                    m_updater.ScheduleUpdate(map, (uint)i_timer.GetCurrent());
                 else
                     map.Update(time);
             }
@@ -235,7 +235,7 @@ namespace Game.Entities
             if (m_updater != null)
                 m_updater.Wait();
 
-            foreach (var map in i_maps.ToList())
+            foreach (var map in i_maps)
                 map.Value.DelayedUpdate(time);
 
             i_timer.SetCurrent(0);
@@ -269,11 +269,14 @@ namespace Game.Entities
             foreach (var pair in i_maps)
                 pair.Value.UnlinkAllChildTerrainMaps();
 
-            foreach (var pair in i_maps.ToList())
+            foreach (var pair in i_maps)
             {
                 pair.Value.UnloadAll();
                 i_maps.Remove(pair.Key);
             }
+
+            if (m_updater != null)
+                m_updater.Deactivate();
         }
 
         public uint GetNumInstances()
@@ -281,7 +284,7 @@ namespace Game.Entities
             lock (_mapsLock)
             {
                 uint ret = 0;
-                foreach (var pair in i_maps.ToList())
+                foreach (var pair in i_maps)
                 {
                     Map map = pair.Value;
                     if (!map.Instanceable())

Source/Game/Maps/MapUpdater.cs

@@ -15,76 +15,96 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-using System;
+using Framework.Threading;
-using System.Collections.Generic;
 using System.Threading;
 
 namespace Game.Maps
 {
-    public class MapUpdater : IDisposable
+    public class MapUpdater
     {
+        ProducerConsumerQueue<MapUpdateRequest> _queue = new ProducerConsumerQueue<MapUpdateRequest>();
+
+        Thread[] _workerThreads;
+        volatile bool _cancelationToken;
+
+        object _lock = new object();
+        int _pendingRequests;
+
         public MapUpdater(int numThreads)
         {
-            _queue = new Queue<MapUpdateRequest>();
+            _workerThreads = new Thread[numThreads];
-
-            autoResetEvent = new AutoResetEvent[numThreads];
             for (var i = 0; i < numThreads; ++i)
             {
-                autoResetEvent[i] = new AutoResetEvent(false);
+                _workerThreads[i] = new Thread(WorkerThread);
-                ThreadPool.QueueUserWorkItem(new WaitCallback(OnEnqueue), autoResetEvent[i]);
+                _workerThreads[i].Start();
             }
+
         }
 
-        public void Enqueue(Map map, uint diff)
+        public void Deactivate()
         {
-            lock (_syncLock)
+            _cancelationToken = true;
-            {
-                _queue.Enqueue(new MapUpdateRequest(map, diff));
-                Monitor.PulseAll(_syncLock);
-            }
-        }
 
-        protected void OnEnqueue(object state)
+            Wait();
-        {
-            while (true)
-            {
-                lock (_syncLock)
-                {
-                    if (_queue.Count == 0)
-                    {
-                        ((AutoResetEvent)state).Set();
-                        Monitor.Wait(_syncLock);
-                    }
 
-                    if (_queue.Count > 0)
+            _queue.Cancel();
-                    {
+
-                        _queue.Dequeue().Call();
+            foreach (var thread in _workerThreads)
-                    }
+            {
-                }
+                thread.Join();
             }
         }
 
         public void Wait()
         {
-            WaitHandle.WaitAll(autoResetEvent);
+            lock (_lock)
-        }
-
-        public void Dispose()
-        {
-            lock (_syncLock)
             {
-                Monitor.PulseAll(_syncLock);
+                while (_pendingRequests > 0)
+                    Monitor.Wait(_lock);
             }
         }
 
-        private Queue<MapUpdateRequest> _queue;
+        public void ScheduleUpdate(Map map, uint diff)
-        private object _syncLock = new object();
+        {
-        private WaitHandle[] autoResetEvent;
+            lock (_lock)
+            {
+                ++_pendingRequests;
+
+                _queue.Push(new MapUpdateRequest(map, this, diff));
+            }
+        }
+
+        public void UpdateFinished()
+        {
+            lock (_lock)
+            {
+                --_pendingRequests;
+
+                Monitor.PulseAll(_lock);
+            }
+        }
+
+        void WorkerThread()
+        {
+            while (true)
+            {
+                MapUpdateRequest request;
+
+                _queue.WaitAndPop(out request);
+
+                if (_cancelationToken)
+                    return;
+
+                request.Call();
+                UpdateFinished();
+            }
+        }
     }
 
     public class MapUpdateRequest
     {
         Map m_map;
+        MapUpdater m_updater;
         uint m_diff;
 
         public MapUpdateRequest(Map m, uint d)
@@ -93,6 +113,13 @@ namespace Game.Maps
             m_diff = d;
         }
 
+        public MapUpdateRequest(Map m, MapUpdater u, uint d)
+        {
+            m_map = m;
+            m_updater = u;
+            m_diff = d;
+        }
+
         public void Call()
         {
             m_map.Update(m_diff);