Add serialization manager shutdown method and initialize benchmark (#1728)

Robust.Benchmarks/Serialization/Initialize/SerializationInitializeBenchmark.cs

@@ -0,0 +1,21 @@
+using BenchmarkDotNet.Attributes;
+using Robust.Shared.Serialization.Manager;
+
+namespace Robust.Benchmarks.Serialization.Initialize
+{
+    public class SerializationInitializeBenchmark : SerializationBenchmark
+    {
+        [IterationCleanup]
+        public void IterationCleanup()
+        {
+            SerializationManager.Shutdown();
+        }
+
+        [Benchmark]
+        public ISerializationManager Initialize()
+        {
+            InitializeSerialization();
+            return SerializationManager;
+        }
+    }
+}

Robust.Benchmarks/Serialization/Read/SerializationReadBenchmark.cs

@@ -1,41 +1,15 @@
-using System;
-using System.IO;
+using System.IO;
 using BenchmarkDotNet.Attributes;
-using Robust.Server;
-using Robust.Shared.Configuration;
-using Robust.Shared.ContentPack;
-using Robust.Shared.IoC;
-using Robust.Shared.Reflection;
-using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
 using YamlDotNet.RepresentationModel;
 
 namespace Robust.Benchmarks.Serialization.Read
 {
-    public class SerializationReadBenchmark
+    public class SerializationReadBenchmark : SerializationBenchmark
     {
         public SerializationReadBenchmark()
         {
-            IoCManager.InitThread();
-            ServerIoC.RegisterIoC();
-            IoCManager.BuildGraph();
-
-            var assemblies = new[]
-            {
-                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Shared"),
-                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Server"),
-                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Benchmarks")
-            };
-
-            foreach (var assembly in assemblies)
-            {
-                IoCManager.Resolve<IConfigurationManagerInternal>().LoadCVarsFromAssembly(assembly);
-            }
-
-            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
-
-            SerializationManager = IoCManager.Resolve<ISerializationManager>();
-            SerializationManager.Initialize();
+            InitializeSerialization();
 
             StringDataDefNode = new MappingDataNode();
             StringDataDefNode.AddNode(new ValueDataNode("string"), new ValueDataNode("ABC"));
@@ -46,8 +20,6 @@ namespace Robust.Benchmarks.Serialization.Read
             SeedNode = yamlStream.Documents[0].RootNode.ToDataNodeCast<SequenceDataNode>().Cast<MappingDataNode>(0);
         }
 
-        private ISerializationManager SerializationManager { get; }
-
         private ValueDataNode StringNode { get; } = new("ABC");
 
         private ValueDataNode IntNode { get; } = new("1");

Robust.Benchmarks/Serialization/SerializationBenchmark.cs

@@ -0,0 +1,43 @@
+using System;
+using Robust.Server;
+using Robust.Shared.Configuration;
+using Robust.Shared.ContentPack;
+using Robust.Shared.IoC;
+using Robust.Shared.Reflection;
+using Robust.Shared.Serialization.Manager;
+
+namespace Robust.Benchmarks.Serialization
+{
+    public abstract class SerializationBenchmark
+    {
+        public SerializationBenchmark()
+        {
+            IoCManager.InitThread();
+            ServerIoC.RegisterIoC();
+            IoCManager.BuildGraph();
+
+            var assemblies = new[]
+            {
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Shared"),
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Server"),
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Benchmarks")
+            };
+
+            foreach (var assembly in assemblies)
+            {
+                IoCManager.Resolve<IConfigurationManagerInternal>().LoadCVarsFromAssembly(assembly);
+            }
+
+            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
+
+            SerializationManager = IoCManager.Resolve<ISerializationManager>();
+        }
+
+        protected ISerializationManager SerializationManager { get; }
+
+        public void InitializeSerialization()
+        {
+            SerializationManager.Initialize();
+        }
+    }
+}

Robust.Shared/Serialization/Manager/ISerializationManager.cs

@@ -14,6 +14,11 @@ namespace Robust.Shared.Serialization.Manager
         /// </summary>
         void Initialize();
 
+        /// <summary>
+        ///     Shuts down the serialization manager.
+        /// </summary>
+        void Shutdown();
+
         /// <summary>
         ///     Checks if a type has a data definition defined for it.
         /// </summary>

Robust.Shared/Serialization/Manager/SerializationManager.cs

@@ -114,6 +114,30 @@ namespace Robust.Shared.Serialization.Manager
             _initializing = false;
         }
 
+        public void Shutdown()
+        {
+            DependencyCollection = null!;
+
+            _constantsMapping.Clear();
+            _flagsMapping.Clear();
+
+            _genericWriterTypes.Clear();
+            _genericReaderTypes.Clear();
+            _genericCopierTypes.Clear();
+            _genericValidatorTypes.Clear();
+
+            _typeWriters.Clear();
+            _typeReaders.Clear();
+            _typeCopiers.Clear();
+            _typeValidators.Clear();
+
+            _dataDefinitions.Clear();
+
+            _copyByRefRegistrations.Clear();
+
+            _initialized = false;
+        }
+
         public bool HasDataDefinition(Type type)
         {
             if (type.IsGenericTypeDefinition) throw new NotImplementedException($"Cannot yet check data definitions for generic types. ({type})");