4 files changed, 471 insertions, 0 deletions
diff --git a/Ryujinx.Graphics.OpenGL/Queries/BufferedQuery.cs b/Ryujinx.Graphics.OpenGL/Queries/BufferedQuery.cs
new file mode 100644
index 00000000..9750ec92
--- /dev/null
+++ b/Ryujinx.Graphics.OpenGL/Queries/BufferedQuery.cs
@@ -0,0 +1,105 @@
+using OpenTK.Graphics.OpenGL;
+using Ryujinx.Common.Logging;
+using System;
+using System.Runtime.InteropServices;
+using System.Threading;
+
+namespace Ryujinx.Graphics.OpenGL.Queries
+{
+    class BufferedQuery : IDisposable
+    {
+        private const int MaxQueryRetries = 5000;
+        private const long DefaultValue = -1;
+
+        public int Query { get; }
+
+        private int _buffer;
+        private IntPtr _bufferMap;
+        private QueryTarget _type;
+
+        public BufferedQuery(QueryTarget type)
+        {
+            _buffer = GL.GenBuffer();
+            Query = GL.GenQuery();
+            _type = type;
+
+            GL.BindBuffer(BufferTarget.QueryBuffer, _buffer);
+
+            unsafe
+            {
+                long defaultValue = DefaultValue;
+                GL.BufferStorage(BufferTarget.QueryBuffer, sizeof(long), (IntPtr)(&defaultValue), BufferStorageFlags.MapReadBit | BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit);
+            }
+            _bufferMap = GL.MapBufferRange(BufferTarget.QueryBuffer, IntPtr.Zero, sizeof(long), BufferAccessMask.MapReadBit | BufferAccessMask.MapWriteBit | BufferAccessMask.MapPersistentBit);
+        }
+
+        public void Reset()
+        {
+            GL.EndQuery(_type);
+            GL.BeginQuery(_type, Query);
+        }
+
+        public void Begin()
+        {
+            GL.BeginQuery(_type, Query);
+        }
+
+        public unsafe void End()
+        {
+            GL.Flush();
+            GL.EndQuery(_type);
+
+            GL.BindBuffer(BufferTarget.QueryBuffer, _buffer);
+
+            Marshal.WriteInt64(_bufferMap, -1L);
+            GL.GetQueryObject(Query, GetQueryObjectParam.QueryResult, (long*)0);
+        }
+
+        public bool TryGetResult(out long result)
+        {
+            result = Marshal.ReadInt64(_bufferMap);
+
+            return result != DefaultValue;
+        }
+
+        public long AwaitResult(AutoResetEvent wakeSignal = null)
+        {
+            long data = DefaultValue;
+
+            if (wakeSignal == null)
+            {
+                while (data == DefaultValue)
+                {
+                    data = Marshal.ReadInt64(_bufferMap);
+                }
+            }
+            else
+            {
+                int iterations = 0;
+                while (data == DefaultValue && iterations++ < MaxQueryRetries)
+                {
+                    data = Marshal.ReadInt64(_bufferMap);
+                    if (data == DefaultValue)
+                    {
+                        wakeSignal.WaitOne(1);
+                    }
+                }
+
+                if (iterations >= MaxQueryRetries)
+                {
+                    Logger.PrintError(LogClass.Gpu, $"Error: Query result timed out. Took more than {MaxQueryRetries} tries.");
+                }
+            }
+
+            return data;
+        }
+
+        public void Dispose()
+        {
+            GL.BindBuffer(BufferTarget.QueryBuffer, _buffer);
+            GL.UnmapBuffer(BufferTarget.QueryBuffer);
+            GL.DeleteBuffer(_buffer);
+            GL.DeleteQuery(Query);
+        }
+    }
+}
diff --git a/Ryujinx.Graphics.OpenGL/Queries/CounterQueue.cs b/Ryujinx.Graphics.OpenGL/Queries/CounterQueue.cs
new file mode 100644
index 00000000..f34bc86d
--- /dev/null
+++ b/Ryujinx.Graphics.OpenGL/Queries/CounterQueue.cs
@@ -0,0 +1,209 @@
+using OpenTK.Graphics.OpenGL;
+using Ryujinx.Graphics.GAL;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+namespace Ryujinx.Graphics.OpenGL.Queries
+{
+    class CounterQueue : IDisposable
+    {
+        private const int QueryPoolInitialSize = 100;
+
+        public CounterType Type { get; }
+        public bool Disposed { get; private set; }
+
+        private Queue<CounterQueueEvent> _events = new Queue<CounterQueueEvent>();
+        private CounterQueueEvent _current;
+
+        private ulong _accumulatedCounter;
+
+        private object _lock = new object();
+
+        private Queue<BufferedQuery> _queryPool;
+        private AutoResetEvent _queuedEvent = new AutoResetEvent(false);
+        private AutoResetEvent _wakeSignal = new AutoResetEvent(false);
+
+        private Thread _consumerThread;
+
+        internal CounterQueue(CounterType type)
+        {
+            Type = type;
+
+            QueryTarget glType = GetTarget(Type);
+
+            _queryPool = new Queue<BufferedQuery>(QueryPoolInitialSize);
+            for (int i = 0; i < QueryPoolInitialSize; i++)
+            {
+                _queryPool.Enqueue(new BufferedQuery(glType));
+            }
+
+            _current = new CounterQueueEvent(this, glType);
+
+            _consumerThread = new Thread(EventConsumer);
+            _consumerThread.Start();
+        }
+
+        private void EventConsumer()
+        {
+            while (!Disposed)
+            {
+                CounterQueueEvent evt = null;
+                lock (_lock)
+                {
+                    if (_events.Count > 0)
+                    {
+                        evt = _events.Dequeue();
+                    }
+                }
+
+                if (evt == null)
+                {
+                    _queuedEvent.WaitOne(); // No more events to go through, wait for more.
+                }
+                else
+                {
+                    evt.TryConsume(ref _accumulatedCounter, true, _wakeSignal);
+                }
+            }
+        }
+
+        internal BufferedQuery GetQueryObject()
+        {
+            // Creating/disposing query objects on a context we're sharing with will cause issues.
+            // So instead, make a lot of query objects on the main thread and reuse them.
+
+            lock (_lock)
+            {
+                if (_queryPool.Count > 0)
+                {
+                    BufferedQuery result = _queryPool.Dequeue();
+                    return result;
+                }
+                else
+                {
+                    return new BufferedQuery(GetTarget(Type));
+                }
+            }
+        }
+
+        internal void ReturnQueryObject(BufferedQuery query)
+        {
+            lock (_lock)
+            {
+                _queryPool.Enqueue(query);
+            }
+        }
+
+        public CounterQueueEvent QueueReport(EventHandler<ulong> resultHandler)
+        {
+            CounterQueueEvent result;
+
+            lock (_lock)
+            {
+                _current.Complete();
+                _events.Enqueue(_current);
+
+                result = _current;
+                result.OnResult += resultHandler;
+
+                _current = new CounterQueueEvent(this, GetTarget(Type));
+            }
+
+            _queuedEvent.Set();
+
+            return result;
+        }
+
+        public void QueueReset()
+        {
+            lock (_lock)
+            {
+                _current.Clear();
+            }
+        }
+
+        private static QueryTarget GetTarget(CounterType type)
+        {
+            switch (type)
+            {
+                case CounterType.SamplesPassed: return QueryTarget.SamplesPassed;
+                case CounterType.PrimitivesGenerated: return QueryTarget.PrimitivesGenerated;
+                case CounterType.TransformFeedbackPrimitivesWritten: return QueryTarget.TransformFeedbackPrimitivesWritten;
+            }
+
+            return QueryTarget.SamplesPassed;
+        }
+
+        public void Flush(bool blocking)
+        {
+            if (!blocking)
+            {
+                // Just wake the consumer thread - it will update the queries.
+                _wakeSignal.Set();
+                return;
+            }
+
+            lock (_lock)
+            {
+                // Tell the queue to process all events.
+                while (_events.Count > 0)
+                {
+                    CounterQueueEvent flush = _events.Peek();
+                    if (!flush.TryConsume(ref _accumulatedCounter, true))
+                    {
+                        return; // If not blocking, then return when we encounter an event that is not ready yet.
+                    }
+                    _events.Dequeue();
+                }
+            }
+        }
+
+        public void FlushTo(CounterQueueEvent evt)
+        {
+            lock (_lock)
+            {
+                if (evt.Disposed)
+                {
+                    return;
+                }
+
+                // Tell the queue to process all events up to this one.
+                while (_events.Count > 0)
+                {
+                    CounterQueueEvent flush = _events.Dequeue();
+                    flush.TryConsume(ref _accumulatedCounter, true);
+
+                    if (flush == evt)
+                    {
+                        return;
+                    }
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            lock (_lock)
+            {
+                while (_events.Count > 0)
+                {
+                    CounterQueueEvent evt = _events.Dequeue();
+
+                    evt.Dispose();
+                }
+
+                Disposed = true;
+            }
+
+            _queuedEvent.Set();
+
+            _consumerThread.Join();
+
+            foreach (BufferedQuery query in _queryPool)
+            {
+                query.Dispose();
+            }
+        }
+    }
+}
diff --git a/Ryujinx.Graphics.OpenGL/Queries/CounterQueueEvent.cs b/Ryujinx.Graphics.OpenGL/Queries/CounterQueueEvent.cs
new file mode 100644
index 00000000..0fba24a1
--- /dev/null
+++ b/Ryujinx.Graphics.OpenGL/Queries/CounterQueueEvent.cs
@@ -0,0 +1,100 @@
+using OpenTK.Graphics.OpenGL;
+using Ryujinx.Graphics.GAL;
+using System;
+using System.Threading;
+
+namespace Ryujinx.Graphics.OpenGL.Queries
+{
+    class CounterQueueEvent : ICounterEvent
+    {
+        public event EventHandler<ulong> OnResult;
+
+        public QueryTarget Type { get; }
+        public bool ClearCounter { get; private set; }
+        public int Query => _counter.Query;
+
+        public bool Disposed { get; private set; }
+        public bool Invalid { get; set; }
+
+        private CounterQueue _queue;
+        private BufferedQuery _counter;
+
+        private object _lock = new object();
+
+        public CounterQueueEvent(CounterQueue queue, QueryTarget type)
+        {
+            _queue = queue;
+
+            _counter = queue.GetQueryObject();
+            Type = type;
+
+            _counter.Begin();
+        }
+
+        internal void Clear()
+        {
+            _counter.Reset();
+            ClearCounter = true;
+        }
+
+        internal void Complete()
+        {
+            _counter.End();
+        }
+
+        internal bool TryConsume(ref ulong result, bool block, AutoResetEvent wakeSignal = null)
+        {
+            lock (_lock)
+            {
+                if (Disposed)
+                {
+                    return true;
+                }
+
+                if (ClearCounter || Type == QueryTarget.Timestamp)
+                {
+                    result = 0;
+                }
+
+                long queryResult;
+
+                if (block)
+                {
+                    queryResult = _counter.AwaitResult(wakeSignal);
+                }
+                else
+                {
+                    if (!_counter.TryGetResult(out queryResult))
+                    {
+                        return false;
+                    }
+                }
+
+                result += (ulong)queryResult;
+
+                OnResult?.Invoke(this, result);
+
+                Dispose(); // Return the our resources to the pool.
+
+                return true;
+            }
+        }
+
+        public void Flush()
+        {
+            if (Disposed)
+            {
+                return;
+            }
+
+            // Tell the queue to process all events up to this one.
+            _queue.FlushTo(this);
+        }
+
+        public void Dispose()
+        {
+            Disposed = true;
+            _queue.ReturnQueryObject(_counter);
+        }
+    }
+}
diff --git a/Ryujinx.Graphics.OpenGL/Queries/Counters.cs b/Ryujinx.Graphics.OpenGL/Queries/Counters.cs
new file mode 100644
index 00000000..7560fb17
--- /dev/null
+++ b/Ryujinx.Graphics.OpenGL/Queries/Counters.cs
@@ -0,0 +1,57 @@
+using Ryujinx.Graphics.GAL;
+using System;
+
+namespace Ryujinx.Graphics.OpenGL.Queries
+{
+    class Counters : IDisposable
+    {
+        private CounterQueue[] _counterQueues;
+
+        public Counters()
+        {
+            int count = Enum.GetNames(typeof(CounterType)).Length;
+
+            _counterQueues = new CounterQueue[count];
+        }
+
+        public void Initialize()
+        {
+            for (int index = 0; index < _counterQueues.Length; index++)
+            {
+                CounterType type = (CounterType)index;
+                _counterQueues[index] = new CounterQueue(type);
+            }
+        }
+
+        public CounterQueueEvent QueueReport(CounterType type, EventHandler<ulong> resultHandler)
+        {
+            return _counterQueues[(int)type].QueueReport(resultHandler);
+        }
+
+        public void QueueReset(CounterType type)
+        {
+            _counterQueues[(int)type].QueueReset();
+        }
+
+        public void Update()
+        {
+            foreach (var queue in _counterQueues)
+            {
+                queue.Flush(false);
+            }
+        }
+
+        public void Flush(CounterType type)
+        {
+            _counterQueues[(int)type].Flush(true);
+        }
+
+        public void Dispose()
+        {
+            foreach (var queue in _counterQueues)
+            {
+                queue.Dispose();
+            }
+        }
+    }
+}