Basic prototype string interning

From my extremely rough and unscientific tests, this saves like 15 MB of client memory on the main menu. Probably also just improves load speed on startup too.

It's per file to keep the implementation simple.

Author: PJB3005

Robust.Shared/Prototypes/PrototypeManager.YamlLoad.cs

@@ -53,7 +53,7 @@ public void LoadDirectory(ResPath path, bool overwrite = false,
 
                     var extractedList = new List<ExtractedMappingData>();
                     var i = 0;
-                    foreach (var document in DataNodeParser.ParseYamlStream(reader))
+                    foreach (var document in DataNodeParser.ParseYamlStream(reader, internStrings: true))
                     {
                         i += 1;
                         LoadedData?.Invoke(document);
@@ -152,7 +152,7 @@ public void LoadFile(ResPath file, bool overwrite = false, Dictionary<Type, Hash
                 return;
 
             var i = 0;
-            foreach (var document in DataNodeParser.ParseYamlStream(reader))
+            foreach (var document in DataNodeParser.ParseYamlStream(reader, internStrings: true))
             {
                 LoadedData?.Invoke(document);
 
@@ -254,7 +254,7 @@ public void LoadFromStream(TextReader stream, bool overwrite = false,
         _hasEverBeenReloaded = true;
 
         var i = 0;
-        foreach (var document in DataNodeParser.ParseYamlStream(stream))
+        foreach (var document in DataNodeParser.ParseYamlStream(stream, internStrings: true))
         {
             LoadedData?.Invoke(document);
 

Robust.Shared/Serialization/Markdown/DataNodeParser.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using Robust.Shared.Collections;
 using Robust.Shared.Serialization.Markdown.Mapping;
@@ -17,22 +18,31 @@ public static class DataNodeParser
 {
     public static IEnumerable<DataNodeDocument> ParseYamlStream(TextReader reader)
     {
-        return ParseYamlStream(new Parser(reader));
+        return ParseYamlStream(reader, internStrings: false);
     }
 
-    internal static IEnumerable<DataNodeDocument> ParseYamlStream(Parser parser)
+    internal static IEnumerable<DataNodeDocument> ParseYamlStream(TextReader reader, bool internStrings)
     {
+        return ParseYamlStream(new Parser(reader), internStrings);
+    }
+
+    internal static IEnumerable<DataNodeDocument> ParseYamlStream(Parser parser, bool internStrings = false)
+    {
+        var state = new ParserState(internStrings);
+
         parser.Consume<StreamStart>();
 
         while (!parser.TryConsume<StreamEnd>(out _))
         {
-            yield return ParseDocument(parser);
+            yield return ParseDocument(parser, state);
         }
+
+        // System.Console.WriteLine(state.TotalStringsSaved);
     }
 
-    private static DataNodeDocument ParseDocument(Parser parser)
+    private static DataNodeDocument ParseDocument(Parser parser, ParserState parserState)
     {
-        var state = new DocumentState();
+        var state = new DocumentState(parserState);
 
         parser.Consume<DocumentStart>();
 
@@ -78,7 +88,11 @@ private static DataNode ParseAlias(Parser parser, DocumentState state)
     private static ValueDataNode ParseValue(Parser parser, DocumentState state)
     {
         var ev = parser.Consume<Scalar>();
-        var node = new ValueDataNode(ev){Tag = ConvertTag(ev.Tag)};
+        var node = new ValueDataNode(ev)
+        {
+            Tag = ConvertTag(ev.Tag, state.ParserState),
+            Value = state.ParserState.InternString(ev.Value)
+        };
 
         NodeParsed(node, ev, false, state);
 
@@ -100,7 +114,7 @@ private static SequenceDataNode ParseSequence(Parser parser, DocumentState state
         var ev = parser.Consume<SequenceStart>();
 
         var node = new SequenceDataNode();
-        node.Tag = ConvertTag(ev.Tag);
+        node.Tag = ConvertTag(ev.Tag, state.ParserState);
         node.Start = ev.Start;
 
         var unresolvedAlias = false;
@@ -127,14 +141,14 @@ private static MappingDataNode ParseMapping(Parser parser, DocumentState state)
         var ev = parser.Consume<MappingStart>();
 
         var node = new MappingDataNode();
-        node.Tag = ConvertTag(ev.Tag);
+        node.Tag = ConvertTag(ev.Tag, state.ParserState);
 
         var unresolvedAlias = false;
 
         MappingEnd mapEnd;
         while (!parser.TryConsume(out mapEnd))
         {
-            var key = ParseKey(parser);
+            var key = state.ParserState.InternString(ParseKey(parser));
             var value = Parse(parser, state);
 
             node.Add(key, value);
@@ -218,13 +232,14 @@ private static DataNode ResolveAlias(DataNodeAlias alias, DocumentState state)
         return node;
     }
 
-    private static string ConvertTag(TagName tag)
+    private static string ConvertTag(TagName tag, ParserState state)
     {
-        return (tag.IsNonSpecific || tag.IsEmpty) ? null : tag.Value;
+        return (tag.IsNonSpecific || tag.IsEmpty) ? null : state.InternString(tag.Value);
     }
 
-    private sealed class DocumentState
+    private sealed class DocumentState(ParserState parserState)
     {
+        public readonly ParserState ParserState = parserState;
         public readonly Dictionary<AnchorName, DataNode> Anchors = new();
         public ValueList<DataNode> UnresolvedAliasOwners;
     }
@@ -256,6 +271,37 @@ public override DataNode PushInheritance(DataNode parent)
             throw new NotSupportedException();
         }
     }
+
+#nullable enable
+
+    private sealed class ParserState(bool internStrings)
+    {
+        public readonly HashSet<string>? StringInternIndex = internStrings ? [] : null;
+        //public int TotalStringsSaved = 0;
+
+        [return: NotNullIfNotNull(nameof(str))]
+        public string? InternString(string? str)
+        {
+            if (StringInternIndex == null)
+                return str;
+
+            if (str == null)
+                return null;
+
+            // Use a basic string interning system to avoid releasing a bunch of equivalent strings.
+            // This avoids having thousands of identical strings for stuff like "type" in prototypes stored in memory.
+            if (StringInternIndex.TryGetValue(str, out var indexedString))
+            {
+                // if (!ReferenceEquals(str, indexedString))
+                //     TotalStringsSaved += 1;
+
+                return indexedString;
+            }
+
+            StringInternIndex.Add(str);
+            return str;
+        }
+    }
 }
 
 public sealed class DataParseException : Exception