correctness, performance, clarity in naming

Perksey · Feb 15, 2025 · Feb 22, 2025 · Mar 15, 2025 · Apr 5, 2025 · May 25, 2025
commit 326c67197b4b0bbc4fde91bcd6b43f3889c2e40b
@@ -138,26 +138,35 @@ private void HandleBackendAddition(IInputBackend backend)
 
     void IInputHandler<ConnectionEvent>.Handle(ConnectionEvent e) => HandleDeviceConnectionChanged(e);
 
-    private void HandleDeviceConnectionChanged(ConnectionEvent e)
+    private void HandleDeviceConnectionChanged(ConnectionEvent evt)
     {
-        InputLog.Debug($"Input device connection changed: {e}");
-        _pointers?.HandleDeviceConnectionChanged(e);
-        _joysticks?.HandleDeviceConnectionChanged(e);
-        _gamepads?.HandleDeviceConnectionChanged(e);
-        _keyboards?.HandleDeviceConnectionChanged(e);
+        InputLog.Debug($"Input device connection changed: {evt}");
+        _pointers?.HandleDeviceConnectionChanged(evt);
+        _joysticks?.HandleDeviceConnectionChanged(evt);
+        _gamepads?.HandleDeviceConnectionChanged(evt);
+        _keyboards?.HandleDeviceConnectionChanged(evt);
 
-        if (_devices is null)
+
+        if (_devices is not null)
         {
-            return;
+
+            if (evt.IsConnected)
+            {
+                _devices.Add(evt.Device);
+            }
+            else
+            {
+                _devices.Remove(evt.Device);
+            }
         }
 
-        if (e.IsConnected)
+        try
         {
-            _devices.Add(e.Device);
+            ConnectionChanged?.Invoke(evt);
         }
-        else
+        catch (Exception e)
         {
-            _devices.Remove(e.Device);
+            InputLog.Error(e.ToString());
         }
     }
 
@@ -212,7 +221,15 @@ void IKeyboardInputHandler.HandleKeyChar(KeyCharEvent @event) =>
     void IInputHandler.HandleDeviceConnectionChanged(ConnectionEvent @event)
     {
         HandleDeviceConnectionChanged(@event);
-        ConnectionChanged?.Invoke(@event);
+
+        try
+        {
+            ConnectionChanged?.Invoke(@event);
+        }
+        catch (Exception e)
+        {
+            InputLog.Error(e.ToString());
+        }
     }
 
     IEnumerator<IInputBackend> IEnumerable<IInputBackend>.GetEnumerator() =>
@@ -232,6 +249,8 @@ void ICollection<IInputBackend>.Clear()
         {
             HandleBackendRemoval(backend);
         }
+
+        _backends.Clear();
     }
 
     bool ICollection<IInputBackend>.Contains(IInputBackend item) => _backends.Contains(item);

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 
+using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
 namespace Silk.NET.Input;
@@ -44,7 +46,7 @@
     public static readonly Type UnderlyingType = typeof(T).GetEnumUnderlyingType();
 
     private static readonly T[] _allValuesOrdered;
-    private static readonly Dictionary<T, int> _numericallyDistinctIndices;
+    private static readonly ConcurrentDictionary<T, int> _numericallyDistinctIndices;
     private static readonly ulong[] _allEnumValuesDistinctRaw;
     private static readonly bool _unnamedAreIndexable;
 #pragma warning disable CS0414 // Field is assigned but its value is never used
@@ -136,14 +138,19 @@
             throw new InvalidOperationException("Enum provided uses an unknown numeric base??");
         }
 
-        var dict = new Dictionary<T, int>(numericallyDistinct.Length);
+        var dict = new ConcurrentDictionary<T, int>(
+            concurrencyLevel: -1, // defaults to Environment.ProcessorCount at time of writing
+            capacity: numericallyDistinct.Length);
+
         for (var index = 0; index < numericallyDistinct.Length; index++)
         {
             var enumVal = numericallyDistinct[index];
+#if DEBUG
+            Debug.Assert(dict.TryAdd(enumVal, index));
+#else
+            _ = dict.TryAdd(enumVal, index);
+#endif
 
-            // get attribute and check for ignore
-
-            dict.Add(enumVal, index);
         }
 
         _allValuesOrdered = all;
@@ -171,7 +178,7 @@
            });
    }

 #pragma warning disable ST0006 ST0007 ST0008 ST0009
    /// <summary>
    /// Gets the ordered index of the unnamed enum value provided. This index is calculated by:
    /// (the number of named members in this enum type) + (the raw value of the number if unnamed)
@@ -207,7 +214,7 @@
         if (_numericallyDistinctIndices.Count < _maxCapacity)
         {
 #if DEBUG
-            System.Diagnostics.Debug.Assert(_numericallyDistinctIndices.TryAdd(value, idx));
+            Debug.Assert(_numericallyDistinctIndices.TryAdd(value, idx));
 #else
             _ = _numericallyDistinctIndices.TryAdd(value, idx);
 #endif
@@ -217,7 +224,7 @@
    }


 #pragma warning restore ST0006 ST0007 ST0008 ST0009

    public static unsafe T ValueOfIndex(int index)
    {

@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Runtime.CompilerServices;
+
+namespace Silk.NET.Input.SDL3.DataStructures;
+
+internal readonly record struct GenericEvent(nint EventPtr, Type Type)
+{
+    public unsafe ref T Value<T>() => ref Unsafe.AsRef<T>((void*)EventPtr);
+}
diff --git a/sources/Input/Input/Implementations/SDL3/DataStructures/GenericEventQueueSdl.cs b/sources/Input/Input/Implementations/SDL3/DataStructures/GenericEventQueueSdl.cs
@@ -0,0 +1,77 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using Silk.NET.Input.SDL3.Devices.Pointers;
+
+namespace Silk.NET.Input.SDL3.DataStructures;
+
+internal sealed class GenericEventQueueSdl : SdlInputEventQueue<GenericEvent>
+{
+    private readonly SdlTimestampCalculator.TimeBasis _basis;
+    public GenericEventQueueSdl(SdlTimestampCalculator.TimeBasis basis) => _basis = basis;
+
+    /// <summary>
+    /// Populates this instance's buffer with events from another <see cref="SdlInputEventQueue{T}"/> <see cref="queueSdl"/>
+    /// of any kind by calling <see cref="SdlInputEventQueue{T}.ConsumeWithoutClearing"/> on it.<br/><br/>
+    ///
+    /// It is <b>imperative</b> that you do not allow any writes to the provided <see cref="SdlInputEventQueue{T}"/>
+    /// until you are done processing the sorted data returned by <see cref="ConsumeAndSortSelf"/>. Changes to the
+    /// provided <see cref="SdlInputEventQueue{T}"/> will invalidate the data this class stores and can lead to confusing
+    /// bugs, or even memory access violations.<br/><br/>
+    /// </summary>
+    /// <param name="queueSdl">The queue whose data to reference</param>
+    /// <param name="consume">If true (default), <see cref="queueSdl"/> will be "consumed" -
+    /// the equivalent of calling <see cref="List{T}.Clear()"/></param>
+    /// <typeparam name="T"></typeparam>
+    public unsafe void StoreReferencesTo<T>(in SdlInputEventQueue<T> queueSdl, bool consume = true) where T : struct
+    {
+        var q = consume ? queueSdl.ConsumeWithoutClearing() : queueSdl.AsSpanPair();
+        var values = q.Values;
+        var timestamps = q.SdlTimestamps;
+        for (var i = 0; i < q.Length; i++)
+        {
+            var genericEvent = new GenericEvent(
+                EventPtr: values.PointerAt(i),
+                Type: typeof(T));
+
+            Enqueue(genericEvent, timestamps.Ptr[i]);
+        }
+    }
+
+    /// <summary>
+    /// This method is the final method that should be called to consume our events in-order.
+    /// After this is call, our memory will appear unused, so any additional writes will overwrite data in the
+    /// returned span.<br/><br/>
+    /// Therefore, it is <b>imperative</b> that you do not allow any writes to this
+    /// <see cref="GenericEventQueueSdl"/> until you are done processing the sorted data.
+    /// consuming.<br/><br/>
+    /// </summary>
+    /// <returns></returns>
+    public unsafe NativeMemory<GenericEvent>.UnsafeView ConsumeAndSortSelf()
+    {
+        var pair = ConsumeWithoutClearing();
+        var valuesToSort = pair.Values;
+        var sdlTimestamps = pair.SdlTimestamps;
+
+        var length = valuesToSort.Length;
+        var heap = length > 512 ? ArrayPool<FractionalTimestamp>.Shared.Rent(length) : null;
+        var sortKeys = heap ?? stackalloc FractionalTimestamp[length];
+        for (var i = 0; i < length; i++)
+        {
+            sortKeys[i] = SdlTimestampCalculator.ToTimestamp(sdlTimestamps.Ptr[i], _basis);
+        }
+
+        sortKeys.StableSortWith(valuesToSort, _timestampComparer);
+
+        if (heap is not null)
+        {
+            ArrayPool<FractionalTimestamp>.Shared.Return(heap);
+        }
+
+        return valuesToSort;
+    }
+
+    private static readonly Comparison<FractionalTimestamp> _timestampComparer = (timeA, timeB) => timeA.CompareTo(timeB);
+}
diff --git a/sources/Input/Input/Implementations/SDL3/DataStructures/ISdlInputEventQueue.cs b/sources/Input/Input/Implementations/SDL3/DataStructures/ISdlInputEventQueue.cs
@@ -0,0 +1,9 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Silk.NET.Input.SDL3.DataStructures;
+
+internal interface ISdlInputEventQueue<T> where T : struct
+{
+    public void Enqueue(in T item, ulong sdlTimestamp);
+}
@@ -1,18 +1,22 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using Silk.NET.SDL;
 
-namespace Silk.NET.Input.SDL3;
+namespace Silk.NET.Input.SDL3.DataStructures;
 
-// note - this probably doesn't need to be a ref struct, but is bc that's the extents
+// note - this probably doesn't need to be a ref struct, but is bc that's the extent
 // of the struct's current use cases
 // LONG-TERM DOM-SPECIFIC TO-DO - can this struct be represented as a NativeArray<T, TBackend> where TBackend has a
 //  Free(void*) or Free(void*, int) method?
-internal readonly unsafe ref struct SdlArray<T> : IDisposable, IEquatable<SdlArray<T>>, IReadOnlyList<T> where T : unmanaged
+/// <summary>
+/// Represents an array of values produced by SDL. For .NET-allocated native memory, see
+/// <seealso cref="NativeMemory{T}"/>.
+/// </summary>
+/// <typeparam name="T">The type of values in the array - usually SDL struct types.</typeparam>
+internal readonly unsafe ref struct SdlArray<T> : IDisposable, IEquatable<SdlArray<T>> where T : unmanaged
 {
     private readonly Ptr<T> _ptr;
     public int Count { get; }
@@ -76,8 +80,6 @@ public void Dispose()
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public ReadOnlySpan<T> AsReadOnlySpan() => _ptr.Native == null ? default : new ReadOnlySpan<T>(_ptr.Native, Count);
 
-    T IReadOnlyList<T>.this[int index] => this[index];
-
     public ref T this[int index]
     {
         get
@@ -106,17 +108,6 @@ public ref T this[uint index]
 
     public bool Equals(SdlArray<T> other) => this == other;
 
-    public IEnumerator<T> GetEnumerator()
-    {
-        if (_ptr == nullptr)
-        {
-            throw new NullReferenceException();
-        }
-
-        return (IEnumerator<T>)AsReadOnlySpan().ToArray().GetEnumerator();
-    }
-
     public override bool Equals(object? obj) => obj == null && _ptr.Native == null;
     public override int GetHashCode() => HashCode.Combine(_ptr, Count, _sdl);
-    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 }
@@ -0,0 +1,92 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+
+namespace Silk.NET.Input.SDL3.DataStructures;
+
+internal class SdlInputEventQueue<T> : ISdlInputEventQueue<T>, IDisposable where T : struct
+{
+    // Currently unused, so just commenting this out
+    /*public int Count
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get
+        {
+            Debug.Assert(_sdlTimestamps.Count == _events.Count);
+            return _sdlTimestamps.Count;
+        }
+    }*/
+
+
+    public void Enqueue(in T item, ulong sdlTimestamp)
+    {
+        if (_disposed)
+        {
+            GC.ReRegisterForFinalize(this);
+            _disposed = false;
+        }
+
+        _events.Add(item);
+        _sdlTimestamps.Add(sdlTimestamp);
+    }
+
+
+    internal readonly ref struct SdlTimestampedValues<TValue>(NativeMemory<TValue>.UnsafeView values, NativeMemory<ulong>.UnsafeView sdlTimestamps) where TValue : struct
+    {
+        public readonly NativeMemory<TValue>.UnsafeView Values = values;
+        public readonly NativeMemory<ulong>.UnsafeView SdlTimestamps = sdlTimestamps;
+
+        public int Length
+        {
+            get
+            {
+                Debug.Assert(Values.Length == SdlTimestamps.Length);
+                return Values.Length;
+            }
+        }
+    }
+
+    /// <Summary>
+    /// Returns a reference to our data as two spans and clears the inner count of our buffers
+    /// (the functional equivalent of calling <see cref="List{T}.Clear()"/>)
+    /// </summary>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    internal SdlTimestampedValues<T> ConsumeWithoutClearing() => new(_events.ConsumeWithoutClearing(), _sdlTimestamps.ConsumeWithoutClearing());
+
+    public void Clear(bool entireCapacity, int startIndex = 0)
+    {
+        _events.ClearValues(entireCapacity, (uint)startIndex);
+        _sdlTimestamps.ClearValues(entireCapacity, (uint)startIndex);
+    }
+
+    public void Dispose()
+    {
+        if(_disposed)
+        {
+            throw new ObjectDisposedException(nameof(SdlInputEventQueue<>));
+        }
+
+        _disposed = true;
+        _sdlTimestamps.Dispose();
+        _events.Dispose();
+        GC.SuppressFinalize(this);
+    }
+
+    ~SdlInputEventQueue()
+    {
+        if (_disposed)
+            return;
+
+        _sdlTimestamps.Dispose();
+        _events.Dispose();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public SdlTimestampedValues<T> AsSpanPair() => new(_events.AsSpan(), _sdlTimestamps.AsSpan());
+
+    private bool _disposed;
+    private NativeMemory<T> _events;
+    private NativeMemory<ulong> _sdlTimestamps;
+}
@@ -9,7 +9,7 @@ namespace Silk.NET.Input.SDL3;
 /// <typeparam name="T"></typeparam>
 internal interface ISdlDevice<out T> : IInputDevice where T : SdlDevice
 {
-    public static abstract T? CreateDevice(ulong sdlDeviceId, long timestamp, ulong sdlTimestamp, bool isSimulated, SdlInputBackend backend, SilkEventContext context);
+    public static abstract T? CreateDevice(ulong sdlDeviceId, long timestamp, ulong sdlTimestamp, bool isSimulated, SdlInputBackend backend, SdlInputEventContext context);
 }
 
 internal interface INeedFinalizationEachFrame