Made more single-creation caches thread safe

IPA.Loader/Config/ConfigRuntime.cs

@@ -64,19 +64,19 @@ namespace IPA.Config
             => ShutdownRuntime();
         internal static void ShutdownRuntime()
         {
-            try
-            {
-                watcherTrackConfigs.Clear();
-                var watchList = watchers.ToArray();
-                watchers.Clear();
-
-                foreach (var pair in watchList)
-                    pair.Value.EnableRaisingEvents = false;
-
-                loadScheduler.Join(); // we can wait for the loads to finish
-                saveThread.Abort(); // eww, but i don't like any of the other potential solutions
-
-                SaveAll();
+            try
+            {
+                watcherTrackConfigs.Clear();
+                var watchList = watchers.ToArray();
+                watchers.Clear();
+
+                foreach (var pair in watchList)
+                    pair.Value.EnableRaisingEvents = false;
+
+                loadScheduler.Join(); // we can wait for the loads to finish
+                saveThread.Abort(); // eww, but i don't like any of the other potential solutions
+
+                SaveAll();
             }
             catch 
             {

IPA.Loader/Config/Stores/CustomObjectConverter.cs

@@ -85,56 +85,56 @@ namespace IPA.Config.Stores.Converters
             => Serialize(obj, parent);
     }
 
-    /// <summary>
-    /// A <see cref="ValueConverter{T}"/> for custom value types, serialized identically to the reference types serialized with
-    /// <see cref="GeneratedStore.Generated{T}(Config, bool)"/>.
-    /// </summary>
+    /// <summary>
+    /// A <see cref="ValueConverter{T}"/> for custom value types, serialized identically to the reference types serialized with
+    /// <see cref="GeneratedStore.Generated{T}(Config, bool)"/>.
+    /// </summary>
     /// <typeparam name="T">the type of the value to convert</typeparam>
-    public class CustomValueTypeConverter<T> : ValueConverter<T> where T : struct
-    {
-        private static readonly GeneratedStoreImpl.SerializeObject<T> serialize
-            = GeneratedStoreImpl.GetSerializerDelegate<T>();
-        private static readonly GeneratedStoreImpl.DeserializeObject<T> deserialize
-            = GeneratedStoreImpl.GetDeserializerDelegate<T>();
-
+    public class CustomValueTypeConverter<T> : ValueConverter<T> where T : struct
+    {
+        private static readonly GeneratedStoreImpl.SerializeObject<T> serialize
+            = GeneratedStoreImpl.GetSerializerDelegate<T>();
+        private static readonly GeneratedStoreImpl.DeserializeObject<T> deserialize
+            = GeneratedStoreImpl.GetDeserializerDelegate<T>();
+
         /// <summary>
         /// Deserializes <paramref name="value"/> into a <typeparamref name="T"/> with the given <paramref name="parent"/>.
         /// </summary>
         /// <param name="value">the <see cref="Value"/> to deserialize</param>
         /// <param name="parent">the parent object that will own the deserialized value</param>
         /// <returns>the deserialized value</returns>
-        /// <seealso cref="ValueConverter{T}.FromValue(Value, object)"/>
-        public static T Deserialize(Value value, object parent)
-            => deserialize(value, parent);
-
+        /// <seealso cref="ValueConverter{T}.FromValue(Value, object)"/>
+        public static T Deserialize(Value value, object parent)
+            => deserialize(value, parent);
+
         /// <summary>
         /// Serializes <paramref name="obj"/> into a corresponding <see cref="Value"/> structure.
         /// </summary>
         /// <param name="obj">the object to serialize</param>
         /// <returns>the <see cref="Value"/> tree that represents <paramref name="obj"/></returns>
-        /// <seealso cref="ValueConverter{T}.ToValue(T, object)"/>
-        public static Value Serialize(T obj)
-            => serialize(obj);
-
+        /// <seealso cref="ValueConverter{T}.ToValue(T, object)"/>
+        public static Value Serialize(T obj)
+            => serialize(obj);
+
         /// <summary>
         /// Deserializes <paramref name="value"/> into a <typeparamref name="T"/> with the given <paramref name="parent"/>.
         /// </summary>
         /// <param name="value">the <see cref="Value"/> to deserialize</param>
         /// <param name="parent">the parent object that will own the deserialized value</param>
         /// <returns>the deserialized value</returns>
-        /// <seealso cref="ValueConverter{T}.FromValue(Value, object)"/>
-        public override T FromValue(Value value, object parent)
-            => Deserialize(value, parent);
-
+        /// <seealso cref="ValueConverter{T}.FromValue(Value, object)"/>
+        public override T FromValue(Value value, object parent)
+            => Deserialize(value, parent);
+
         /// <summary>
         /// Serializes <paramref name="obj"/> into a <see cref="Value"/> structure, given <paramref name="parent"/>.
         /// </summary>
         /// <param name="obj">the object to serialize</param>
         /// <param name="parent">the parent object that owns <paramref name="obj"/></param>
         /// <returns>the <see cref="Value"/> tree that represents <paramref name="obj"/></returns>
-        /// <seealso cref="ValueConverter{T}.ToValue(T, object)"/>
-        public override Value ToValue(T obj, object parent)
-            => Serialize(obj);
+        /// <seealso cref="ValueConverter{T}.ToValue(T, object)"/>
+        public override Value ToValue(T obj, object parent)
+            => Serialize(obj);
     }
 
 }

IPA.Loader/Config/Stores/GeneratedStoreImpl/GeneratedStoreImpl.cs

@@ -16,7 +16,8 @@ using Boolean = IPA.Config.Data.Boolean;
 using System.Collections;
 using IPA.Utilities;
 using System.ComponentModel;
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
+using IPA.Utilities.Async;
 #if NET3
 using Net3_Proxy;
 using Array = Net3_Proxy.Array;
@@ -38,38 +39,13 @@ namespace IPA.Config.Stores
         internal static T Create<T>(IGeneratedStore parent) where T : class => (T)Create(typeof(T), parent);
 
         private static IConfigStore Create(Type type, IGeneratedStore parent)
-            => GetCreator(type)(parent);
-
-        private static readonly ConcurrentDictionary<Type, (ManualResetEventSlim wh, GeneratedStoreCreator ctor, Type type)> generatedCreators 
-            = new ConcurrentDictionary<Type, (ManualResetEventSlim wh, GeneratedStoreCreator ctor, Type type)>();
+            => GetCreator(type)(parent);
+
+        private static readonly SingleCreationValueCache<Type, (GeneratedStoreCreator ctor, Type type)> generatedCreators
+            = new SingleCreationValueCache<Type, (GeneratedStoreCreator ctor, Type type)>();
 
         private static (GeneratedStoreCreator ctor, Type type) GetCreatorAndGeneratedType(Type t)
-        {
-            retry:
-            if (generatedCreators.TryGetValue(t, out var gen))
-            {
-                if (gen.wh != null)
-                {
-                    gen.wh.Wait();
-                    goto retry; // this isn't really a good candidate for a loop
-                    // the loop condition will never be hit, and this should only
-                    //   jump back to the beginning in exceptional situations
-                }
-                return (gen.ctor, gen.type);
-            }
-            else
-            {
-                var wh = new ManualResetEventSlim(false);
-                var cmp = (wh, (GeneratedStoreCreator)null, (Type)null);
-                if (!generatedCreators.TryAdd(t, cmp))
-                    goto retry; // someone else beat us to the punch, retry getting their value and wait for them
-                var (ctor, type) = MakeCreator(t);
-                while (!generatedCreators.TryUpdate(t, (null, ctor, type), cmp))
-                    throw new InvalidOperationException("Somehow, multiple MakeCreators started running for the same target type!");
-                wh.Set();
-                return (ctor, type);
-            }
-        }
+            => generatedCreators.GetOrAdd(t, MakeCreator);
 
         internal static GeneratedStoreCreator GetCreator(Type t)
             => GetCreatorAndGeneratedType(t).ctor;
@@ -111,6 +87,7 @@ namespace IPA.Config.Stores
             }
         }
 
+        // TODO: does this need to be a SingleCreationValueCache or similar?
         private static readonly Dictionary<Type, Dictionary<Type, FieldInfo>> TypeRequiredConverters = new Dictionary<Type, Dictionary<Type, FieldInfo>>();
         private static void CreateAndInitializeConvertersFor(Type type, IEnumerable<SerializedMemberInfo> structure)
         {

IPA.Loader/Config/Stores/GeneratedStoreImpl/ObjectStructure.cs

@@ -2,6 +2,7 @@
 using IPA.Config.Stores.Converters;
 using IPA.Logging;
 using IPA.Utilities;
+using IPA.Utilities.Async;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -127,14 +128,11 @@ namespace IPA.Config.Stores
             return true;
         }
 
-        private static readonly Dictionary<Type, SerializedMemberInfo[]> objectStructureCache = new Dictionary<Type, SerializedMemberInfo[]>();
+        private static readonly SingleCreationValueCache<Type, SerializedMemberInfo[]> objectStructureCache 
+            = new SingleCreationValueCache<Type, SerializedMemberInfo[]>();
 
         private static IEnumerable<SerializedMemberInfo> ReadObjectMembers(Type type)
-        {
-            if (!objectStructureCache.TryGetValue(type, out var structure))
-                objectStructureCache.Add(type, structure = ReadObjectMembersInternal(type).ToArray());
-            return structure;
-        }
+            => objectStructureCache.GetOrAdd(type, t => ReadObjectMembersInternal(type).ToArray());
 
         private static IEnumerable<SerializedMemberInfo> ReadObjectMembersInternal(Type type)
         {

IPA.Loader/IPA.Loader.csproj

@@ -149,6 +149,7 @@
     <Compile Include="JsonConverters\SemverRangeConverter.cs" />
     <Compile Include="JsonConverters\SemverVersionConverter.cs" />
     <Compile Include="Utilities\Async\Coroutines.cs" />
+    <Compile Include="Utilities\Async\SingleCreationValueCache.cs" />
     <Compile Include="Utilities\Async\SingleThreadTaskScheduler.cs" />
     <Compile Include="Utilities\Accessor.cs" />
     <Compile Include="Utilities\Async\UnityMainThreadTaskScheduler.cs" />

IPA.Loader/Loader/Features/Feature.cs

@@ -88,6 +88,8 @@ namespace IPA.Loader.Features
         /// <value><see langword="true"/> if this <see cref="Feature"/> will be stored on the plugin metadata, <see langword="false"/> otherwise</value>
         protected internal virtual bool StoreOnPlugin => true;
 
+        // TODO: rework features to take arguments as JSON objects
+
         static Feature()
         {
             Reset();

IPA.Loader/Loader/PluginComponent.cs

@@ -1,8 +1,8 @@
 using IPA.Config;
 using IPA.Loader.Composite;
-using IPA.Utilities;
-using IPA.Utilities.Async;
-using System.Diagnostics.CodeAnalysis;
+using IPA.Utilities;
+using IPA.Utilities.Async;
+using System.Diagnostics.CodeAnalysis;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 // ReSharper disable UnusedMember.Local
@@ -28,7 +28,7 @@ namespace IPA.Loader
 
             if (!initialized)
             {
-                UnityGame.SetMainThread();
+                UnityGame.SetMainThread();
                 UnityGame.EnsureRuntimeGameVersion();
 
                 PluginManager.Load();
@@ -47,16 +47,16 @@ namespace IPA.Loader
 
                 SceneManager.activeSceneChanged += OnActiveSceneChanged;
                 SceneManager.sceneLoaded += OnSceneLoaded;
-                SceneManager.sceneUnloaded += OnSceneUnloaded;
-
-                var unitySched = UnityMainThreadTaskScheduler.Default as UnityMainThreadTaskScheduler;
-                if (!unitySched.IsRunning)
+                SceneManager.sceneUnloaded += OnSceneUnloaded;
+
+                var unitySched = UnityMainThreadTaskScheduler.Default as UnityMainThreadTaskScheduler;
+                if (!unitySched.IsRunning)
                     StartCoroutine(unitySched.Coroutine());
 
-                initialized = true;
-
-#if DEBUG
-                Config.Stores.GeneratedStoreImpl.DebugSaveAssembly("GeneratedAssembly.dll");
+                initialized = true;
+
+#if DEBUG
+                Config.Stores.GeneratedStoreImpl.DebugSaveAssembly("GeneratedAssembly.dll");
 #endif
             }
         }

IPA.Loader/Utilities/Accessor.cs

@@ -1,8 +1,11 @@
-using System;
+using IPA.Utilities.Async;
+using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
+using System.Threading;
 #if NET3
 using Net3_Proxy;
 using Array = Net3_Proxy.Array;
@@ -25,9 +28,6 @@ namespace IPA.Utilities
         /// <returns>a reference to the field's value</returns>
         public delegate ref U Accessor(ref T obj);
 
-        // field name -> accessor
-        private static readonly Dictionary<string, Accessor> accessors = new Dictionary<string, Accessor>();
-
         private static Accessor MakeAccessor(string fieldName)
         {
             var field = typeof(T).GetField(fieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
@@ -51,6 +51,9 @@ namespace IPA.Utilities
             return (Accessor)dyn.CreateDelegate(typeof(Accessor));
         }
 
+        // field name -> accessor
+        private static readonly SingleCreationValueCache<string, Accessor> accessors = new SingleCreationValueCache<string, Accessor>();
+
         /// <summary>
         /// Gets an <see cref="Accessor"/> for the field named <paramref name="name"/> on <typeparamref name="T"/>.
         /// </summary>
@@ -58,11 +61,7 @@ namespace IPA.Utilities
         /// <returns>an accessor for the field</returns>
         /// <exception cref="MissingFieldException">if the field does not exist on <typeparamref name="T"/></exception>
         public static Accessor GetAccessor(string name)
-        {
-            if (!accessors.TryGetValue(name, out var accessor))
-                accessors.Add(name, accessor = MakeAccessor(name));
-            return accessor;
-        }
+            => accessors.GetOrAdd(name, MakeAccessor);
 
         /// <summary>
         /// Accesses a field for an object by name.
@@ -149,8 +148,6 @@ namespace IPA.Utilities
         /// <param name="val">the new property value</param>
         public delegate void Setter(ref T obj, U val);
 
-        private static readonly Dictionary<string, (Getter get, Setter set)> props = new Dictionary<string, (Getter get, Setter set)>();
-
         private static (Getter, Setter) MakeAccessors(string propName)
         {
             var prop = typeof(T).GetProperty(propName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
@@ -201,12 +198,11 @@ namespace IPA.Utilities
             return (getter, setter);
         }
 
+        private static readonly SingleCreationValueCache<string, (Getter get, Setter set)> props 
+            = new SingleCreationValueCache<string, (Getter get, Setter set)>();
+
         private static (Getter get, Setter set) GetAccessors(string propName)
-        {
-            if (!props.TryGetValue(propName, out var access))
-                props.Add(propName, access = MakeAccessors(propName));
-            return access;
-        }
+            => props.GetOrAdd(propName, MakeAccessors);
 
         /// <summary>
         /// Gets a <see cref="Getter"/> for the property identified by <paramref name="name"/>.
@@ -289,8 +285,6 @@ namespace IPA.Utilities
     /// <typeparam name="TDelegate">the delegate type to create, and to use as a signature to search for</typeparam>
     public static class MethodAccessor<T, TDelegate> where TDelegate : Delegate
     {
-        private static readonly Dictionary<string, TDelegate> methods = new Dictionary<string, TDelegate>();
-
         static MethodAccessor()
         {
             // ensure that first argument of delegate type is valid
@@ -325,6 +319,8 @@ namespace IPA.Utilities
             return (TDelegate)Delegate.CreateDelegate(AccessorDelegateInfo<TDelegate>.Type, method, true);
         }
 
+        private static readonly SingleCreationValueCache<string, TDelegate> methods = new SingleCreationValueCache<string, TDelegate>();
+
         /// <summary>
         /// Gets a delegate to the named method with the signature specified by <typeparamref name="TDelegate"/>.
         /// </summary>
@@ -333,11 +329,7 @@ namespace IPA.Utilities
         /// <exception cref="MissingMethodException">if <paramref name="name"/> does not represent the name of a method with the given signature</exception>
         /// <exception cref="ArgumentException">if the method found returns a type incompatable with the return type of <typeparamref name="TDelegate"/></exception>
         public static TDelegate GetDelegate(string name)
-        {
-            if (!methods.TryGetValue(name, out var del))
-                methods.Add(name, del = MakeDelegate(name));
-            return del;
-        }
+            => methods.GetOrAdd(name, MakeDelegate);
     }
 
 }

IPA.Loader/Utilities/Async/SingleCreationValueCache.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace IPA.Utilities.Async
+{
+    /// <summary>
+    /// A dictionary-like type intended for thread-safe value caches whose values are created only once ever.
+    /// </summary>
+    /// <typeparam name="TKey">the key type of the cache</typeparam>
+    /// <typeparam name="TValue">the value type of the cache</typeparam>
+    /// <remarks>
+    /// This object basically wraps a <see cref="ConcurrentDictionary{TKey, TValue}"/> with some special handling
+    /// to ensure that values are only created once ever, without having multiple parallel constructions.
+    /// </remarks>
+    public class SingleCreationValueCache<TKey, TValue>
+    {
+        private readonly ConcurrentDictionary<TKey, (ManualResetEventSlim wh, TValue val)> dict;
+
+        private static KeyValuePair<TKey, (ManualResetEventSlim, TValue)> ExpandKeyValuePair(KeyValuePair<TKey, TValue> kvp)
+            => new KeyValuePair<TKey, (ManualResetEventSlim, TValue)>(kvp.Key, (null, kvp.Value));
+        private static KeyValuePair<TKey, TValue> CompressKeyValuePair(KeyValuePair<TKey, (ManualResetEventSlim, TValue value)> kvp)
+            => new KeyValuePair<TKey, TValue>(kvp.Key, kvp.Value.value);
+
+        #region Constructors
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SingleCreationValueCache{TKey, TValue}"/>
+        /// class that is empty, has the default concurrency level, has the default initial
+        /// capacity, and uses the default comparer for the key type.
+        /// </summary>
+        public SingleCreationValueCache()
+            => dict = new ConcurrentDictionary<TKey, (ManualResetEventSlim wh, TValue val)>();
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SingleCreationValueCache{TKey, TValue}"/>
+        /// class that contains elements copied from the specified <see cref="IEnumerable{T}"/>,
+        /// has the default concurrency level, has the default initial capacity, and uses
+        /// the default comparer for the key type.
+        /// </summary>
+        /// <param name="collection">the <see cref="IEnumerable{T}"/> whose element are to be used for the new cache</param>
+        /// <exception cref="ArgumentNullException">when any arguments are null</exception>
+        /// <exception cref="ArgumentException"><paramref name="collection"/> contains duplicate keys</exception>
+        public SingleCreationValueCache(IEnumerable<KeyValuePair<TKey, TValue>> collection)
+            => dict = new ConcurrentDictionary<TKey, (ManualResetEventSlim wh, TValue val)>(collection.Select(ExpandKeyValuePair));
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SingleCreationValueCache{TKey, TValue}"/>
+        /// class that is empty, has the default concurrency level and capacity, and uses
+        /// the specified <see cref="IEqualityComparer{T}"/>.
+        /// </summary>
+        /// <param name="comparer">the equality comparer to use when comparing keys</param>
+        /// <exception cref="ArgumentNullException"><paramref name="comparer"/> is null</exception>
+        public SingleCreationValueCache(IEqualityComparer<TKey> comparer)
+            => dict = new ConcurrentDictionary<TKey, (ManualResetEventSlim wh, TValue val)>(comparer);
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SingleCreationValueCache{TKey, TValue}"/>
+        /// class that contains elements copied from the specified <see cref="IEnumerable{T}"/>
+        /// has the default concurrency level, has the default initial capacity, and uses
+        /// the specified <see cref="IEqualityComparer{T}"/>.
+        /// </summary>
+        /// <param name="collection">the <see cref="IEnumerable{T}"/> whose elements are to be used for the new cache</param>
+        /// <param name="comparer">the equality comparer to use when comparing keys</param>
+        /// <exception cref="ArgumentNullException"><paramref name="collection"/> or <paramref name="comparer"/> is null</exception>
+        public SingleCreationValueCache(IEnumerable<KeyValuePair<TKey, TValue>> collection, IEqualityComparer<TKey> comparer)
+            => dict = new ConcurrentDictionary<TKey, (ManualResetEventSlim wh, TValue val)>(collection.Select(ExpandKeyValuePair), comparer);
+        #endregion
+
+        /// <summary>
+        /// Gets a value that indicates whether this cache is empty. 
+        /// </summary>
+        public bool IsEmpty => dict.IsEmpty;
+        /// <summary>
+        /// Gets the number of elements that this cache contains.
+        /// </summary>
+        public int Count => dict.Count;
+
+        /// <summary>
+        /// Clears the cache.
+        /// </summary>
+        public void Clear() => dict.Clear();
+        /// <summary>
+        /// Gets a value indicating whether or not this cache contains <paramref name="key"/>.
+        /// </summary>
+        /// <param name="key">the key to search for</param>
+        /// <returns><see langword="true"/> if the cache contains the key, <see langword="false"/> otherwise</returns>
+        public bool ContainsKey(TKey key) => dict.ContainsKey(key);
+        /// <summary>
+        /// Copies the key-value pairs stored by the cache to a new array, filtering all elements that are currently being
+        /// created.
+        /// </summary>
+        /// <returns>an array containing a snapshot of the key-value pairs contained in this cache</returns>
+        public KeyValuePair<TKey, TValue>[] ToArray()
+            => dict.ToArray().Where(k => k.Value.wh == null).Select(CompressKeyValuePair).ToArray();
+
+        /// <summary>
+        /// Attempts to get the value associated with the specified key from the cache.
+        /// </summary>
+        /// <param name="key">the key to search for</param>
+        /// <param name="value">the value retrieved, if any</param>
+        /// <returns><see langword="true"/> if the value was found, <see langword="false"/> otherwise</returns>
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            if (dict.TryGetValue(key, out var pair) && pair.wh != null)
+            {
+                value = pair.val;
+                return true;
+            }
+            value = default;
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the value associated with the specified key from the cache. If it does not exist, and
+        /// no creators are currently running for this key, then the creator is called to create the value
+        /// and the value is added to the cache. If there is a creator currently running for the key, then
+        /// this waits for the creator to finish and retrieves the value.
+        /// </summary>
+        /// <param name="key">the key to search for</param>
+        /// <param name="creator">the delegate to use to create the value if it does not exist</param>
+        /// <returns>the value that was found, or the result of <paramref name="creator"/></returns>
+        public TValue GetOrAdd(TKey key, Func<TKey, TValue> creator)
+        {
+        retry:
+            if (dict.TryGetValue(key, out var value))
+            {
+                if (value.wh != null)
+                {
+                    value.wh.Wait();
+                    goto retry; // this isn't really a good candidate for a loop
+                    // the loop condition will never be hit, and this should only
+                    //   jump back to the beginning in exceptional situations
+                }
+                return value.val;
+            }
+            else
+            {
+                var wh = new ManualResetEventSlim(false);
+                var cmp = (wh, default(TValue));
+                if (!dict.TryAdd(key, cmp))
+                    goto retry; // someone else beat us to the punch, retry getting their value and wait for them
+                var val = creator(key);
+                while (!dict.TryUpdate(key, (null, val), cmp))
+                    throw new InvalidOperationException();
+                wh.Set();
+                return val;
+            }
+        }
+    }
+}