Cache StringNames and NodePaths when casting from string in C#

[Joy-less]

In C#, StringNames and NodePaths can be a footgun for garbage collection issues which cause performance spikes.

This can be a very insidious issue because of implicit casting:

Input.IsActionPressed("action"); // Created a StringName.
GetNode("path/to/node"); // Created a NodePath.

To test the extent of the issue, I wrote the following code:

using Godot;
using ZiggyCreatures.Caching.Fusion;

public partial class StringNameSpammer : Node {
    public int Test = 10;
    public bool UseCache = true;

    private readonly FusionCache Cache = new(new FusionCacheOptions());

    public override void _PhysicsProcess(double Delta) {
        for (int Counter = 0; Counter < 10_000; Counter++) {
            if (UseCache) {
                Get(Cache.GetOrSet("Test", _ => (StringName)"Test"));
            }
            else {
                Get("Test");
            }
        }
    }
}

It creates, uses and discards 10,000 StringNames per physics frame, to be garbage collected. This uses FusionCache, but any capped-size dictionary could be used.

When UseCache is false, I get consistent 30ms spikes:

When UseCache is true, I get a steady 17ms:

Ideally, the C# API would exclusively use strings rather than StringNames. But until this is implemented, there should be a better StringName/NodePath API.

In my code, I've been doing this:

using ZiggyCreatures.Caching.Fusion;

public static class RecycleExtensions {
    private static readonly FusionCache StringNameCache = new(new FusionCacheOptions());
    private static readonly FusionCache NodePathCache = new(new FusionCacheOptions());

    /// <summary>
    /// Convert the string to a StringName, recycling if possible.
    /// </summary>
    public static StringName ToStringName(this string String) {
        return StringNameCache.GetOrSet(String, _ => (StringName)String)!;
    }
    /// <summary>
    /// Convert the string to a NodePath, recycling if possible.
    /// </summary>
    public static NodePath ToNodePath(this string String) {
        return NodePathCache.GetOrSet(String, _ => (NodePath)String)!;
    }
}

Then I can do:

Input.IsActionPressed("action".ToStringName());
GetNode("path/to/node".ToNodePath());

However, I think this would be better implemented in the API itself, because of reduced footguns and simpler syntax.

Here's the StringName cast according to the reflector:

public static implicit operator StringName(string from)
{
    return new StringName(from);
}

This could be changed to this:

using ZiggyCreatures.Caching.Fusion;

private static readonly FusionCache StringNameCache = new(new FusionCacheOptions());

public static implicit operator StringName(string from)
{
    return StringNameCache.GetOrSet(from, _ => new StringName(from))!;
}

Here's the project I used for profiling: stringnamestest.zip

[Joy-less]

See the pull request for this at godotengine/godot#100452.

[jodydonetti]

Hi, I wrote my 2 cents in the PR.

Hope this helps.