Cache delegates

[cmeeren]

Consider this code:

open System.Collections.Concurrent

let d = ConcurrentDictionary<string, int>()

let getOrAdd key = d.GetOrAdd(key, fun _ -> 0)

for _ = 0 to 1_000_000 do
  getOrAdd "" |> ignore

When memory profiling (using dotMemory, targeting .NET 7), I see that this allocates 1 million Func<String, Int32> objects:

Allocated type : System.Func<String, Int32>
  Objects : 1000001
  Bytes   : 64000064

Allocated by
   100%  getOrAdd • 61,04 MB / 61,04 MB • global::Program.getOrAdd(String)
     100%  main@ • 61,04 MB / - • <StartupCode$AllocTest>.$Program.main@()
      ►  100%  [AllThreadsRoot] • 61,04 MB / - • [AllThreadsRoot]

This is very surprising to me. (Although I'm no expert in esoteric subjects like compiler optimizations, I consider myself a fairly experienced F# developer.)

I propose that F# caches these delegates. (Note: I am unsure if "delegates" is the right term.)

Possibly related: #910, dotnet/runtime#80430

[T-Gro]

I think this would be the way to reduce the allocation:

https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA0AbEAzAzmgExAGoAfCABxgDsACAZQE9cAXGAWwDoBhCDDGGBYBLCNVw8xYAK5RY1FgFgAUCoEtaBWgF5avajLk0WAEWFDR1AIZRGAHlZRh1AOZpazlgD4AFAEoVNRgNMCswAAsYAgAxaQMdBmY2LliDOwB9NHTfbDjadNo4L1oABgDVZXVaF2CAeSgAQQItAGsYRgSCTgBxOsbmnzbGd1CIqNSwcpVsaHyEktoWCFoARnSSjfWNzQgVWmq+pq0AImPaUmLhF2poGCA=

I wonder if there is any other situation besides Action<> and Func<,> family where similar thing is needed, or if this optimization would be targeting them only.

[vzarytovskii]

Might be a good idea to look into caching functions when we can.

it's quite big language/compiler feature, please, create a suggestion over at https://github.com/fsharp/fslang-suggestions/issues (or maybe look if there's existing one).

Here are some semi-related issuess for reference:
fsharp/fslang-suggestions#1131
fsharp/fslang-suggestions#1083

[vzarytovskii]

I wonder if there is any other situation besides Action<> and Func<,> family where similar thing is needed, or if this optimization would be targeting them only.

@T-Gro I think it's mainly Func<> and Action<>, but still might be a good thing to have (ASP.NET APIs come to mind, though I think that JIT can optimize it for us :D)

[kerams]

fsharp/fslang-suggestions#1083

[jl0pd]

C# always cache delegates created in this way, implementation can be taken from here https://sharplab.io/#v2:EYLgxg9gTgpgtADwGwBYA+ABATARgLABQGADAAQY4B0AwhADZ0xgAuAlhAHYDONnYArlFgdmAbkIYAzOSylqpAN6FSK0gAcorAG4BDZjDl9Bw5gBFWLdhx1QAngB4KxADSlWIgHykA+gBMLzKQAvKQcMADuABQAlOIEquTS7oEAsjGkyqpK8QmqGADsPv4slADiMMwA8lAAgr6+kQBEja7ewV7EsZkqAL6EPUA==

[cmeeren]

C# always cache delegates created in this way

I'm not clear on the details/differences, but note that there are delegates or similar that C# does not cache, as demonstrated in dotnet/runtime#80430.

[jl0pd]

I'm not clear on the details/differences

Essentially Foo(x => Bar(x)) was cached, but Foo(Bar) wasn't