< Summary - FSharp.Interop.Dlr

Information
Class: FSharp.Interop.Dlr.NamedOfCache
Assembly: FSharp.Interop.Dlr
File(s): /home/runner/work/FSharp.Interop.Dlr/FSharp.Interop.Dlr/FSharp.Interop.Dlr/SiteCaches.fs
Line coverage
98%
Covered lines: 70
Uncovered lines: 1
Coverable lines: 71
Total lines: 198
Line coverage: 98.5%
Branch coverage
91%
Covered branches: 77
Total branches: 84
Branch coverage: 91.6%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
get_Count()100%210%
HashOf(...)100%66100%
Matches(...)100%2020100%
Find(...)80%1010100%
Get(...)92.3%2626100%
Values(...)100%44100%
At(...)100%11100%

File(s)

/home/runner/work/FSharp.Interop.Dlr/FSharp.Interop.Dlr/FSharp.Interop.Dlr/SiteCaches.fs

#LineLine coverage
 1namespace FSharp.Interop.Dlr
 2
 3open System
 4open System.Dynamic
 5open System.Linq.Expressions
 6open System.Reflection
 7open System.Runtime.CompilerServices
 8open Microsoft.CSharp.RuntimeBinder
 9open FSharp.Quotations
 10
 11/// The call sites of an operation whose binder inputs are only known at run time (`(?) x name`
 12/// with `name` a variable): one set of sites per distinct key, created on first use from a
 13/// quotation template the translator built for the operation, and read back out of it. The
 14/// delegate that invokes them is compiled once, at translation time, with the sites as
 15/// parameters — so a new key costs the binders and sites (~µs, a few hundred bytes), not a
 16/// `LambdaExpression.Compile()`, and a repeated key costs one dictionary lookup. Bounded: at
 17/// `Capacity` entries the cache is cleared and refills, a miss being cheap.
 18/// Not part of the supported API: public only because compiled blocks call it, and it may change in any release.
 19[<System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)>]
 20type SiteCache<'Key when 'Key: equality>(template: 'Key -> Expr) =
 21    let entries = System.Collections.Concurrent.ConcurrentDictionary<'Key, CallSite[]>()
 22
 23    /// The `CallSite` constants in a template's expression, one per distinct site, in traversal
 24    /// order — the order the translator's parameters follow.
 25    static member Sites(e: Expr) : CallSite list =
 26        let found = System.Collections.Generic.List<CallSite>()
 27        let rec walk (e: Expr) =
 28            match e with
 29            | Patterns.Value(v, _) ->
 30                match v with
 31                | :? CallSite as site when not (found |> Seq.exists (fun s -> obj.ReferenceEquals(s, site))) -> found.Ad
 32                | _ -> ()
 33            | ExprShape.ShapeVar _ -> ()
 34            | ExprShape.ShapeLambda(_, body) -> walk body
 35            | ExprShape.ShapeCombination(_, args) -> List.iter walk args
 36        walk e
 37        List.ofSeq found
 38
 39    /// Entries kept per cache before it is cleared.
 40    static member val Capacity = 256 with get, set
 41
 42    member _.Count = entries.Count
 43
 44    member _.Get(key: 'Key) : CallSite[] =
 45        match entries.TryGetValue key with
 46        | true, sites -> sites
 47        | _ ->
 48            // Misses only: the admission (clear at capacity, then add) is one critical section,
 49            // so concurrent misses cannot each pass the check and push the count past the bound.
 50            lock entries (fun () ->
 51                match entries.TryGetValue key with
 52                | true, sites -> sites
 53                | _ ->
 54                    // A key from data: a null name or type is an argument error here, not a
 55                    // NullReferenceException from inside the binder.
 56                    match box key with
 57                    | :? (string * Type list) as k ->
 58                        let name, types = k
 59                        if isNull name then nullArg "a computed member name is null"
 60                        if isNull (box types) then nullArg "Dlr.typeArgsOf: the list is null"
 61                        if types |> List.exists isNull then invalidArg "types" "Dlr.typeArgsOf: a type in the list is nu
 62                    | _ -> ()
 63                    if entries.Count >= SiteCache<'Key>.Capacity then entries.Clear()
 64                    let sites = Array.ofList (SiteCache<'Key>.Sites(template key))
 65                    entries.[key] <- sites
 66                    sites)
 67
 68    /// `sites.[i]`, for the quotation (array indexing has no direct quotation form the converter takes).
 69    static member At(sites: CallSite[], i: int) : CallSite = sites.[i]
 70
 71/// One compiled `NamedOfCache` shape: its names (an empty name per positional), their hash, the delegate.
 72/// Not part of the supported API: public only because compiled blocks call it, and it may change in any release.
 73[<AllowNullLiteral; System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)>]
 74type NamedOfEntry(names: string[], hash: int, d: Delegate) =
 75    member _.Names = names
 76    member _.Hash = hash
 77    member _.Delegate = d
 78
 79/// For `Dlr.argsOf` / `Dlr.namedOf`: the site's operation compiled once per distinct argument
 80/// shape — the ordered names, an empty name standing for a positional argument (`argsOf`
 81/// values first, then `namedOf` names) — since the shape changes the site's arity, so the
 82/// whole delegate is per key, not only its sites; bounded like `SiteCache`. The delegate takes
 83/// the target, the fixed arguments and the splatted values as one `obj[]` (positional, then
 84/// named).
 85/// Not part of the supported API: public only because compiled blocks call it, and it may change in any release.
 86[<System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)>]
 87type NamedOfCache(compile: string list -> Delegate) =
 88    /// The entries by the hash of their names, an immutable snapshot replaced whole under the
 89    /// lock on a miss, so a lookup reads it without locking; the hash is computed in place from
 90    /// the argument lists, so a lookup allocates nothing.
 18891    let mutable entries : System.Collections.Generic.Dictionary<int, NamedOfEntry list> = System.Collections.Generic.Dic
 18892    let mutable count = 0
 93    /// The last two shapes served: a site that repeats or alternates shapes hits here in one or
 94    /// two name compares, whatever the capacity.
 18895    let mutable last : NamedOfEntry = null
 18896    let mutable previous : NamedOfEntry = null
 97
 98    /// Entries kept per cache before it is cleared: a miss is a `Compile()`. The lookup is a
 99    /// hash, so hits cost the same at any size; the bound is memory on a site that fills it
 100    /// (a shape is ~13 KB at one arity: 256 is ~3.5 MB), the same 256 as `SiteCache`.
 101    static member val Capacity = 256 with get, set
 102
 103    /// The most positional arguments `Dlr.argsOf` accepts. Each distinct count is a new call-site
 104    /// arity — a delegate type (past Func's 17 type parameters, one emitted into a non-collectible dynamic
 105    /// assembly), a binder Microsoft.CSharp interns for the life of the process, a `Compile()` —
 106    /// so a count from data must not be unbounded, as a C# call site's arity is fixed by its
 107    /// source. A collection that could be long is one argument, not many.
 108    static member val MaxPositional = 64 with get, set
 109
 0110    member _.Count = count
 111
 112    /// The hash of a shape: the positional count, then each name in order.
 113    static member private HashOf(positional: obj list, pairs: (string * obj) list) =
 1394114        let mutable h = 17
 7018115        for _ in positional do h <- h * 31
 8858116        for (n, _) in pairs do h <- h * 31 + (if isNull n then 0 else n.GetHashCode())
 1394117        h
 118
 119    /// Whether an entry's names are the shape of these arguments: `positional.Length` empty
 120    /// names, then the pairs' names in order. Loops, no closures: the hit path allocates nothing.
 121    static member private Matches(names: string[], positional: obj list, pairs: (string * obj) list) =
 3646122        let mutable i = 0
 3646123        let mutable ok = true
 3646124        let mutable ps = positional
 16434125        while ok && not ps.IsEmpty do
 8988126            if i < names.Length && names.[i].Length = 0 then i <- i + 1; ps <- ps.Tail
 132127            else ok <- false
 3646128        let mutable rest = pairs
 19114129        while ok && not rest.IsEmpty do
 3602130            let (n, _) = rest.Head
 131            // An empty name is the positional marker in `names`: a pair never matches one.
 16612132            if i < names.Length && not (String.IsNullOrEmpty n) && String.Equals(n, names.[i]) then i <- i + 1; rest <- 
 2498133            else ok <- false
 4662134        ok && i = names.Length
 135
 136    /// The entry of this shape in a bucket, or null: a loop, no closure, no option, so the hash
 137    /// path allocates nothing.
 138    static member private Find(bucket: NamedOfEntry list, hash: int, positional: obj list, pairs: (string * obj) list) :
 108139        let mutable rest = bucket
 108140        let mutable found : NamedOfEntry = null
 540141        while isNull found && not rest.IsEmpty do
 108142            let e = rest.Head
 432143            if e.Hash = hash && NamedOfCache.Matches(e.Names, positional, pairs) then found <- e
 108144            rest <- rest.Tail
 108145        found
 146
 147    /// The delegate for these arguments' shape.
 148    member this.Get(positional: obj list, pairs: (string * obj) list) : Delegate =
 2194149        if isNull (box positional) then nullArg "Dlr.argsOf: the list is null"
 2198150        if isNull (box pairs) then nullArg "Dlr.namedOf: the list is null"
 151        // The last two shapes served, compared by name first: cheaper than hashing the names.
 2190152        let l = last
 5671153        if not (isNull l) && NamedOfCache.Matches(l.Names, positional, pairs) then l.Delegate
 154        else
 1794155        let p = previous
 5439156        if not (isNull p) && NamedOfCache.Matches(p.Names, positional, pairs) then previous <- l; last <- p; p.Delegate
 157        else
 1394158        let hash = NamedOfCache.HashOf(positional, pairs)
 1394159        let mutable bucket = Unchecked.defaultof<NamedOfEntry list>   // out parameter: no tuple
 2788160        let hit = if entries.TryGetValue(hash, &bucket) then NamedOfCache.Find(bucket, hash, positional, pairs) else nul
 1718161        if not (isNull hit) then previous <- last; last <- hit; hit.Delegate
 162        else
 1286163            lock this (fun () ->
 1286164                let current = entries
 2572165                let again = match current.TryGetValue hash with | true, b -> NamedOfCache.Find(b, hash, positional, pair
 1286166                if not (isNull again) then previous <- last; last <- again; again.Delegate
 1286167                else
 1286168                    // Names from data: a null or empty one would be taken for a positional slot.
 4972169                    for (n, _) in pairs do
 1210170                        if isNull n then nullArg "Dlr.namedOf: an argument name is null"
 1210171                        if n.Length = 0 then invalidArg "pairs" "Dlr.namedOf: an argument name is empty (positional argu
 1274172                    let positionalCount = List.length positional
 1274173                    if positionalCount > NamedOfCache.MaxPositional then
 4174                        invalidArg "positional" (sprintf "Dlr.argsOf: %d positional arguments; at most %d. Each distinct
 4744175                    let names = (positional |> List.map (fun _ -> "")) @ (pairs |> List.map fst)
 1270176                    let e = NamedOfEntry(Array.ofList names, hash, compile names)
 1286177                    let next =
 1278178                        if count >= NamedOfCache.Capacity then (count <- 0; System.Collections.Generic.Dictionary())
 1266179                        else System.Collections.Generic.Dictionary(current)
 3810180                    next.[hash] <- e :: (match next.TryGetValue hash with | true, b -> b | _ -> [])
 1270181                    count <- count + 1
 1270182                    entries <- next
 1270183                    previous <- last
 1270184                    last <- e
 2556185                    e.Delegate)
 186
 187    /// The splatted values, positional then named, for the quotation.
 188    static member Values(positional: obj list, pairs: (string * obj) list) : obj[] =
 2174189        let values = Array.zeroCreate (List.length positional + List.length pairs)
 2174190        let mutable i = 0
 8752191        for v in positional do
 2202192            values.[i] <- v
 2202193            i <- i + 1
 8936194        for (_, v) in pairs do
 2294195            values.[i] <- v
 2294196            i <- i + 1
 2174197        values
 4836198    static member At(values: obj[], i: int) : obj = values.[i]
Generated by: ReportGenerator 5.5.11.0
10/09/2026 - 10:41:48
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.FSharp.Core.FSharpFunc`2<Microsoft.FSharp.Collections.FSharpList`1<System.String>,System.Delegate>)
get_Count()
HashOf(Microsoft.FSharp.Collections.FSharpList`1<System.Object>,Microsoft.FSharp.Collections.FSharpList`1<System.Tuple`2<System.String,System.Object>>)
Matches(System.String[],Microsoft.FSharp.Collections.FSharpList`1<System.Object>,Microsoft.FSharp.Collections.FSharpList`1<System.Tuple`2<System.String,System.Object>>)
Find(Microsoft.FSharp.Collections.FSharpList`1<FSharp.Interop.Dlr.NamedOfEntry>,System.Int32,Microsoft.FSharp.Collections.FSharpList`1<System.Object>,Microsoft.FSharp.Collections.FSharpList`1<System.Tuple`2<System.String,System.Object>>)
Get(Microsoft.FSharp.Collections.FSharpList`1<System.Object>,Microsoft.FSharp.Collections.FSharpList`1<System.Tuple`2<System.String,System.Object>>)
Values(Microsoft.FSharp.Collections.FSharpList`1<System.Object>,Microsoft.FSharp.Collections.FSharpList`1<System.Tuple`2<System.String,System.Object>>)
At(System.Object[],System.Int32)