Lazy<> Implementation suggestion

[odewdney]

Currently the System.Lazy implementation has three member fields, and the hot path of getting the value after it has been created involves 1 or 2 conditionals ( including the .net framework implementation ).

My suggestion is to have only one field that references an object that can supply the value, and the state/mode is represented by the type of object referenced. So initially it references a object that will construct the required value, while when it is in the value set state it references an object that just returns the store value, and for the error state, throws the captured exception.

So it replaces conditions(s) with a virtual call.

My suggested implementation can be seen here:
https://gist.github.com/odewdney/3835c52528295d0d39e76e6e31bb6fa3

BenchmarkDotNet suggest a 10% saving in cpu and memory against the .net framework implementation - could be more depending on usage modelling - on a tight loop calling Lazy.Value

[dotnet-policy-service]

Tagging subscribers to this area: @dotnet/area-system-runtime
See info in area-owners.md if you want to be subscribed.

[timcassell]

It seems your proposal regresses the common case. My results:

Method	Mean	Error	StdDev	Allocated
System	191.2 us	0.51 us	0.48 us	-
Proposed	232.2 us	0.91 us	0.85 us	-
Mine	191.1 us	0.29 us	0.25 us	-

Mine is taking your suggestion to reduce the fields, by moving the delegate to the helper, but still leaving the value field for fast access. There is no change in speed here, but it does reduce the size of the lazy object a bit. The tradeoff is there are more runtime types created, compared to the singular LazyHelper. (Btw, I did implement AsyncLazy<T> in this way.)

Benchmark Code

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;
using System.Runtime.ExceptionServices;
using System.Threading;

namespace Benchmarks
{
    internal class Program
    {
        static void Main(string[] args)
        {
            BenchmarkRunner.Run<LazyBenchmarks>();
        }
    }

    [MemoryDiagnoser(false)]
    public class LazyBenchmarks
    {
        private readonly Lazy<int> _lazy = new(() => 42);
        private readonly ProposedLazy<int> _proposedLazy = new(() => 42);
        private readonly MyLazy<int> _myLazy = new(() => 42);

        private const int RepeatCount = 1_000_000;

        [Benchmark]
        public int _System()
        {
            int value = 0;
            for (int i = 0; i < RepeatCount; i++)
            {
                value += _lazy.Value;
            }
            return value;
        }

        [Benchmark]
        public int Proposed()
        {
            int value = 0;
            for (int i = 0; i < RepeatCount; i++)
            {
                value += _proposedLazy.Value;
            }
            return value;
        }

        [Benchmark]
        public int Mine()
        {
            int value = 0;
            for (int i = 0; i < RepeatCount; i++)
            {
                value += _myLazy.Value;
            }
            return value;
        }
    }

    class ProposedLazy<T>
    {
        interface IValueGetter
        {
            T GetValue();
        }

        abstract class CreatorGetter : IValueGetter
        {
            private readonly ProposedLazy<T> lazy;
            private Func<T> valueFactory;

            public CreatorGetter(ProposedLazy<T> lazy, Func<T> valueFactory)
            {
                this.lazy = lazy;
                this.valueFactory = valueFactory;
            }

            static Func<T> invalidOperationFactory = () => throw new System.InvalidOperationException();

            protected T CreateValue(bool errorRecursive = true)
            {
                var vf = valueFactory;
                if (vf == null)
                {
                    return Activator.CreateInstance<T>();
                }
                if (errorRecursive)
                    valueFactory = invalidOperationFactory;
                return vf();
            }

            public abstract T GetValue();

            protected IValueGetter SetValue(T value)
            {
                return Interlocked.CompareExchange(ref lazy.getter, new ValueGetter(value), this);
            }

            protected void SetException(Exception ex)
            {
                lazy.getter = new ExceptionGetter(ex);
            }

            protected T GetLazyValue()
            {
                return lazy.getter.GetValue();
            }

            protected bool isThisGetter()
            {
                return lazy.getter == this;
            }

            protected bool isDefaultFactory()
            {
                return valueFactory == null;
            }
        }

        class CreatorGetterNone : CreatorGetter
        {
            public CreatorGetterNone(ProposedLazy<T> lazy, Func<T> valueFactory)
                : base(lazy, valueFactory)
            { }

            public override T GetValue()
            {
                try
                {
                    var value = CreateValue();
                    SetValue(value);
                    return value;
                }
                catch (Exception ex)
                {
                    if (!isDefaultFactory() || ex is MissingMethodException)
                        SetException(ex);
                    throw;
                }
            }
        }

        class CreatorGetterPublicationOnly : CreatorGetter
        {
            public CreatorGetterPublicationOnly(ProposedLazy<T> lazy, Func<T> valueFactory) : base(lazy, valueFactory)
            {
            }

            public override T GetValue()
            {
                var value = CreateValue(false);
                var oldValue = SetValue(value);
                if (oldValue == this)
                {
                    return value;
                }
                return GetLazyValue();
            }
        }

        class CreatorGetterExecutionAndPublication : CreatorGetter
        {
            public CreatorGetterExecutionAndPublication(ProposedLazy<T> lazy, Func<T> valueFactory)
                : base(lazy, valueFactory)
            {
            }

            public override T GetValue()
            {
                lock (this)
                {
                    if (isThisGetter())
                    {
                        try
                        {
                            var value = CreateValue();
                            SetValue(value);
                            return value;
                        }
                        catch (Exception ex)
                        {
                            if (!isDefaultFactory() || ex is MissingMethodException)
                                SetException(ex);
                            throw;
                        }
                    }
                }
                return GetLazyValue();
            }
        }

        class ValueGetter : IValueGetter
        {
            private readonly T value;

            public ValueGetter(T value)
            {
                this.value = value;
            }
            public T GetValue()
            {
                return value;
            }
        }

        class ExceptionGetter : IValueGetter
        {
            ExceptionDispatchInfo edi;
            public ExceptionGetter(Exception e)
            {
                edi = ExceptionDispatchInfo.Capture(e);
            }

            public T GetValue()
            {
                edi.Throw();
                throw new Exception("failed to throw captured exception");
            }
        }

        IValueGetter getter;

        public ProposedLazy(Func<T> valueFactory, LazyThreadSafetyMode mode = LazyThreadSafetyMode.ExecutionAndPublication)
        {
            switch (mode)
            {
                case LazyThreadSafetyMode.None:
                    getter = new CreatorGetterNone(this, valueFactory);
                    break;
                case LazyThreadSafetyMode.PublicationOnly:
                    getter = new CreatorGetterPublicationOnly(this, valueFactory);
                    break;
                case LazyThreadSafetyMode.ExecutionAndPublication:
                    getter = new CreatorGetterExecutionAndPublication(this, valueFactory);
                    break;
                default:
                    throw new Exception("unknown mode");
            }
        }

        public bool IsValueCreated()
        {
            return !(getter is CreatorGetter);
        }

        public T Value
        {
            get
            {
                return getter.GetValue();
            }
        }

        internal T GetValueForDebug
        {
            get
            {
                return IsValueCreated() ? getter.GetValue() : default(T);
            }
        }
    }

    class MyLazy<T>
    {
        abstract class ValueGetterBase
        {
            public abstract T GetValue();
        }

        abstract class CreatorGetter : ValueGetterBase
        {
            protected readonly MyLazy<T> lazy;
            private Func<T> valueFactory;

            public CreatorGetter(MyLazy<T> lazy, Func<T> valueFactory)
            {
                this.lazy = lazy;
                this.valueFactory = valueFactory;
            }

            static Func<T> invalidOperationFactory = () => throw new System.InvalidOperationException();

            protected T CreateValue(bool errorRecursive = true)
            {
                var vf = valueFactory;
                if (vf == null)
                {
                    return Activator.CreateInstance<T>();
                }
                if (errorRecursive)
                    valueFactory = invalidOperationFactory;
                return vf();
            }

            protected void SetValue(T value)
            {
                lazy._result = value;
                lazy._getter = null;
            }

            protected void SetException(Exception ex)
            {
                lazy._getter = new ExceptionGetter(ex);
            }

            protected T GetLazyValue()
            {
                return lazy._getter.GetValue();
            }

            protected bool isThisGetter()
            {
                return lazy._getter == this;
            }

            protected bool isDefaultFactory()
            {
                return valueFactory == null;
            }
        }

        class CreatorGetterNone : CreatorGetter
        {
            public CreatorGetterNone(MyLazy<T> lazy, Func<T> valueFactory)
                : base(lazy, valueFactory)
            { }

            public override T GetValue()
            {
                try
                {
                    var value = CreateValue();
                    SetValue(value);
                    return value;
                }
                catch (Exception ex)
                {
                    if (!isDefaultFactory() || ex is MissingMethodException)
                        SetException(ex);
                    throw;
                }
            }
        }

        class CreatorGetterPublicationOnly : CreatorGetter
        {

            public CreatorGetterPublicationOnly(MyLazy<T> lazy, Func<T> valueFactory) : base(lazy, valueFactory)
            {
            }

            public override T GetValue()
            {
                var value = CreateValue(false);
                lock (this)
                {
                    if (lazy._getter != null)
                    {
                        SetValue(value);
                    }
                }
                return lazy._result;
            }
        }

        class CreatorGetterExecutionAndPublication : CreatorGetter
        {
            public CreatorGetterExecutionAndPublication(MyLazy<T> lazy, Func<T> valueFactory)
                : base(lazy, valueFactory)
            {
            }

            public override T GetValue()
            {
                lock (this)
                {
                    if (isThisGetter())
                    {
                        try
                        {
                            var value = CreateValue();
                            SetValue(value);
                            return value;
                        }
                        catch (Exception ex)
                        {
                            if (!isDefaultFactory() || ex is MissingMethodException)
                                SetException(ex);
                            throw;
                        }
                    }
                }
                return GetLazyValue();
            }
        }

        class ExceptionGetter : ValueGetterBase
        {
            ExceptionDispatchInfo edi;
            public ExceptionGetter(Exception e)
            {
                edi = ExceptionDispatchInfo.Capture(e);
            }

            public override T GetValue()
            {
                edi.Throw();
                throw new Exception("failed to throw captured exception");
            }
        }

        private volatile ValueGetterBase _getter;
        private T _result;

        public MyLazy(Func<T> valueFactory, LazyThreadSafetyMode mode = LazyThreadSafetyMode.ExecutionAndPublication)
        {
            switch (mode)
            {
                case LazyThreadSafetyMode.None:
                    _getter = new CreatorGetterNone(this, valueFactory);
                    break;
                case LazyThreadSafetyMode.PublicationOnly:
                    _getter = new CreatorGetterPublicationOnly(this, valueFactory);
                    break;
                case LazyThreadSafetyMode.ExecutionAndPublication:
                    _getter = new CreatorGetterExecutionAndPublication(this, valueFactory);
                    break;
                default:
                    throw new Exception("unknown mode");
            }
        }

        public bool IsValueCreated() => _getter is not null;

        public T Value => _getter is { } g ? g.GetValue() : _result;

        internal T GetValueForDebug
        {
            get
            {
                return IsValueCreated() ? _getter.GetValue() : default(T);
            }
        }
    }
}

[odewdney]

Thank you for reviewing my suggestion. It looks like the .NetCore implementation with the nullable value type is an improvement over the Framework version of a Boxed value class, negating the small improvement of my suggestion.
I prefer my layout of the three modes of operation, but that is no reason for change!