6831463354

Committed 11 Nov 2023 02:19AM UTC coverage: 98.253% (-0.3%) from 98.554%

Build # 6831463354

Build Type

push

github

Committed by

web-flow

Commit Message

Cache LFU drain buffers delegate (#461)

Run Details

861 of 894 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

12 existing lines in 3 files now uncovered.

3694 of 3742 relevant lines covered (98.72%)

20988884.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.81

/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs

﻿using System;
using System.Diagnostics;
using System.Threading;

namespace BitFaster.Caching.Atomic
{
    /// <summary>
    /// A class that provides simple, lightweight exactly once initialization for scoped values
    /// stored in a cache.
    /// </summary>
    /// <typeparam name="K">The type of the key.</typeparam>
    /// <typeparam name="V">The type of the value.</typeparam>
    /// <remarks>
    /// Requirements:
    /// <list type="number">
    ///    <item>
    ///        <description>Exactly once disposal.</description>
    ///    </item>
    ///    <item>
    ///        <term>Exactly once invocation of value factory</term>
    ///        <description>Values are created atomically.</description>
    ///    </item>
    ///    <item>
    ///        <term>Resolve race between create dispose init</term>
    ///        <description>If disposed is called before value is created, scoped value is disposed for life.</description>
    ///    </item>
    ///</list>
    /// </remarks>
    [DebuggerDisplay("IsScopeCreated={initializer == null}, Value={ScopeIfCreated}")]
    public sealed class ScopedAtomicFactory<K, V> : IScoped<V>, IDisposable where V : IDisposable
    {
        private Scoped<V> scope;
        private Initializer initializer;

        /// <summary>
        /// Initializes a new instance of the <see cref="ScopedAtomicFactory{K, V}"/> class.
        /// </summary>
        public ScopedAtomicFactory()
        {
            initializer = new Initializer();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ScopedAtomicFactory{K, V}"/> class with the
        /// specified value.
        /// </summary>
        /// <param name="value">The value.</param>
        public ScopedAtomicFactory(V value)
        {
            scope = new Scoped<V>(value);
        }

        /// <summary>
        /// Gets a value indicating whether the scope has been initialized.
        /// </summary>
        public bool IsScopeCreated => initializer == null;

        /// <summary>
        /// Gets the scope if it has been initialized, else default.
        /// </summary>
        public Scoped<V> ScopeIfCreated
        {
            get
            {
                if (initializer != null)
                {
                    return default;
                }

                return scope;
            }
        }

        /// <summary>
        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
        /// the lifetime is disposed.
        /// </summary>
        /// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
        /// <returns>true if the Lifetime was created; otherwise false.</returns>
        public bool TryCreateLifetime(out Lifetime<V> lifetime)
        {
            if (scope?.IsDisposed ?? false || initializer != null)
            {
                lifetime = default;
                return false;
            }

            return scope.TryCreateLifetime(out lifetime);
        }

        /// <summary>
        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
        /// the lifetime is disposed.
        /// </summary>
        /// <param name="key">The key associated with the scoped value.</param>
        /// <param name="valueFactory">The value factory to use to create the scoped value when it is not initialized.</param>
        /// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
        /// <returns>true if the Lifetime was created; otherwise false.</returns>
        // backcompat: remove
        public bool TryCreateLifetime(K key, Func<K, Scoped<V>> valueFactory, out Lifetime<V> lifetime)
        {
            // backcompat
            return TryCreateLifetime(key, new ValueFactory<K, Scoped<V>>(valueFactory), out lifetime);
        }

        /// <summary>
        /// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until 
        /// the lifetime is disposed.
        /// </summary>
        /// <typeparam name="TFactory">The type of the value factory.</typeparam>
        /// <param name="key">The key associated with the scoped value.</param>
        /// <param name="valueFactory">The value factory to use to create the scoped value when it is not initialized.</param>
        /// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
        /// <returns>true if the Lifetime was created; otherwise false.</returns>
        public bool TryCreateLifetime<TFactory>(K key, TFactory valueFactory, out Lifetime<V> lifetime) where TFactory : struct, IValueFactory<K, Scoped<V>>
        {
            if (scope?.IsDisposed ?? false)
            {
                lifetime = default;
                return false;
            }

            // Create scope EXACTLY once, ref count cas operates over same scope
            if (initializer != null)
            {
                InitializeScope(key, valueFactory);
            }

            return scope.TryCreateLifetime(out lifetime);
        }

        private void InitializeScope<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, Scoped<V>>
        {
            var init = initializer;

            if (init != null)
            {
                scope = init.CreateScope(key, valueFactory);
                Volatile.Write(ref initializer, null); // volatile write must occur after setting value
            }
        }

        /// <summary>
        /// Terminates the scope and disposes the value. Once the scope is terminated, it is no longer
        /// possible to create new lifetimes for the value.
        /// </summary>
        public void Dispose()
        {
            var init = initializer;

            if (init != null)
            {
                scope = init.TryCreateDisposedScope();
            }

            scope.Dispose();
        }

#pragma warning disable CA2002 // Do not lock on objects with weak identity
        private class Initializer
        {
            private bool isInitialized;
            private Scoped<V> value;

            public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, Scoped<V>>
            {
                lock (this)
                {
                    if (isInitialized)
                    {
                        return value;
                    }

                    value = valueFactory.Create(key);
                    isInitialized = true;

                    return value;
                }
            }

            public Scoped<V> TryCreateDisposedScope()
            {
                lock (this)
                {
                    if (isInitialized)
                    {
                        return value;
                    }

                    // don't expose to other threads until disposed (else they may use the invalid default value)
                    var temp = new Scoped<V>(default);
                    temp.Dispose();
                    value = temp;
                    isInitialized = true;

                    return value;
                }
            }
        }
#pragma warning restore CA2002 // Do not lock on objects with weak identity
    }
}

1	using System;
2	using System.Diagnostics;
3	using System.Threading;
4
5	namespace BitFaster.Caching.Atomic
6	{
7	/// <summary>
8	/// A class that provides simple, lightweight exactly once initialization for scoped values
9	/// stored in a cache.
10	/// </summary>
11	/// <typeparam name="K">The type of the key.</typeparam>
12	/// <typeparam name="V">The type of the value.</typeparam>
13	/// <remarks>
14	/// Requirements:
15	/// <list type="number">
16	/// <item>
17	/// <description>Exactly once disposal.</description>
18	/// </item>
19	/// <item>
20	/// <term>Exactly once invocation of value factory</term>
21	/// <description>Values are created atomically.</description>
22	/// </item>
23	/// <item>
24	/// <term>Resolve race between create dispose init</term>
25	/// <description>If disposed is called before value is created, scoped value is disposed for life.</description>
26	/// </item>
27	///</list>
28	/// </remarks>
29	[DebuggerDisplay("IsScopeCreated={initializer == null}, Value={ScopeIfCreated}")]
30	public sealed class ScopedAtomicFactory<K, V> : IScoped<V>, IDisposable where V : IDisposable
31	{
32	private Scoped<V> scope;
33	private Initializer initializer;
34
35	/// <summary>
36	/// Initializes a new instance of the <see cref="ScopedAtomicFactory{K, V}"/> class.
37	/// </summary>
38	public ScopedAtomicFactory()	15,457✔
39	{	15,457✔
40	initializer = new Initializer();	15,457✔
41	}	15,457✔
42
43	/// <summary>
44	/// Initializes a new instance of the <see cref="ScopedAtomicFactory{K, V}"/> class with the
45	/// specified value.
46	/// </summary>
47	/// <param name="value">The value.</param>
48	public ScopedAtomicFactory(V value)	96✔
49	{	96✔
50	scope = new Scoped<V>(value);	96✔
51	}	96✔
52
53	/// <summary>
54	/// Gets a value indicating whether the scope has been initialized.
55	/// </summary>
56	public bool IsScopeCreated => initializer == null;	30✔
57
58	/// <summary>
59	/// Gets the scope if it has been initialized, else default.
60	/// </summary>
61	public Scoped<V> ScopeIfCreated
62	{
63	get
64	{	33✔
65	if (initializer != null)	33✔
66	{	3✔
67	return default;	3✔
68	}
69
70	return scope;	30✔
71	}	33✔
72	}
73
74	/// <summary>
75	/// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until
76	/// the lifetime is disposed.
77	/// </summary>
78	/// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
79	/// <returns>true if the Lifetime was created; otherwise false.</returns>
80	public bool TryCreateLifetime(out Lifetime<V> lifetime)
81	{	36✔
82	if (scope?.IsDisposed ?? false \|\| initializer != null)	36✔
83	{	9✔
84	lifetime = default;	9✔
85	return false;	9✔
86	}
87
88	return scope.TryCreateLifetime(out lifetime);	27✔
89	}	36✔
90
91	/// <summary>
92	/// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until
93	/// the lifetime is disposed.
94	/// </summary>
95	/// <param name="key">The key associated with the scoped value.</param>
96	/// <param name="valueFactory">The value factory to use to create the scoped value when it is not initialized.</param>
97	/// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
98	/// <returns>true if the Lifetime was created; otherwise false.</returns>
99	// backcompat: remove
100	public bool TryCreateLifetime(K key, Func<K, Scoped<V>> valueFactory, out Lifetime<V> lifetime)
101	{	24,600✔
102	// backcompat
103	return TryCreateLifetime(key, new ValueFactory<K, Scoped<V>>(valueFactory), out lifetime);	24,600✔
104	}	24,600✔
105
106	/// <summary>
107	/// Attempts to create a lifetime for the scoped value. The lifetime guarantees the value is alive until
108	/// the lifetime is disposed.
109	/// </summary>
110	/// <typeparam name="TFactory">The type of the value factory.</typeparam>
111	/// <param name="key">The key associated with the scoped value.</param>
112	/// <param name="valueFactory">The value factory to use to create the scoped value when it is not initialized.</param>
113	/// <param name="lifetime">When this method returns, contains the Lifetime that was created, or the default value of the type if the operation failed.</param>
114	/// <returns>true if the Lifetime was created; otherwise false.</returns>
115	public bool TryCreateLifetime<TFactory>(K key, TFactory valueFactory, out Lifetime<V> lifetime) where TFactory : struct, IValueFactory<K, Scoped<V>>
116	{	24,822✔
117	if (scope?.IsDisposed ?? false)	24,822✔
118	{	201✔
119	lifetime = default;	201✔
120	return false;	201✔
121	}
122
123	// Create scope EXACTLY once, ref count cas operates over same scope
124	if (initializer != null)	24,621✔
125	{	16,372✔
126	InitializeScope(key, valueFactory);	16,372✔
127	}	16,363✔
128
129	return scope.TryCreateLifetime(out lifetime);	24,612✔
130	}	24,813✔
131
132	private void InitializeScope<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, Scoped<V>>
133	{	16,372✔
134	var init = initializer;	16,372✔
135
136	if (init != null)	16,372✔
137	{	16,324✔
138	scope = init.CreateScope(key, valueFactory);	16,324✔
139	Volatile.Write(ref initializer, null); // volatile write must occur after setting value	16,315✔
140	}	16,315✔
141	}	16,363✔
142
143	/// <summary>
144	/// Terminates the scope and disposes the value. Once the scope is terminated, it is no longer
145	/// possible to create new lifetimes for the value.
146	/// </summary>
147	public void Dispose()
148	{	9,248✔
149	var init = initializer;	9,248✔
150
151	if (init != null)	9,248✔
152	{	6✔
153	scope = init.TryCreateDisposedScope();	6✔
154	}	6✔
155
156	scope.Dispose();	9,248✔
157	}	9,248✔
158
159	#pragma warning disable CA2002 // Do not lock on objects with weak identity
160	private class Initializer
161	{
162	private bool isInitialized;
163	private Scoped<V> value;
164
165	public Scoped<V> CreateScope<TFactory>(K key, TFactory valueFactory) where TFactory : struct, IValueFactory<K, Scoped<V>>
166	{	16,324✔
167	lock (this)	16,324✔
168	{	16,324✔
169	if (isInitialized)	16,324✔
170	{	941✔
171	return value;	941✔
172	}
173
174	value = valueFactory.Create(key);	15,383✔
175	isInitialized = true;	15,374✔
176
177	return value;	15,374✔
178	}
179	}	16,315✔
180
181	public Scoped<V> TryCreateDisposedScope()
182	{	6✔
183	lock (this)	6✔
184	{	6✔
185	if (isInitialized)	6!
UNCOV 186	{	×
UNCOV 187	return value;	×
188	}
189
190	// don't expose to other threads until disposed (else they may use the invalid default value)
191	var temp = new Scoped<V>(default);	6✔
192	temp.Dispose();	6✔
193	value = temp;	6✔
194	isInitialized = true;	6✔
195
196	return value;	6✔
197	}
198	}	6✔
199	}
200	#pragma warning restore CA2002 // Do not lock on objects with weak identity
201	}
202	}

bitfaster / BitFaster.Caching / 6831463354

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous