Async / wait, awaiter personnalisé et collecteur d'ordures

j'ai supprimé tous les éléments P/invoke et recréé une version simplifiée de la logique de la machine d'état générée par le compilateur. Il présente le même comportement:awaiter obtient garabage recueillies après la première invocation de l'état de la machine MoveNext méthode.

Microsoft a récemment fait un excellent travail sur la fourniture de L'interface web à leur . net sources de référence, qui a été très utile. Après avoir étudié la mise en œuvre de AsyncTaskMethodBuilder et, la plupart important, AsyncMethodBuilderCore.GetCompletionAction, je le crois maintenant le comportement du GC, je vais voir a le sens parfait. Je vais essayer d'expliquer que ci-dessous.

le code:

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.Runtime.CompilerServices;

namespace ConsoleApplication
{
    public class Program
    {
        // Original version with async/await

        /*
        static async Task TestAsync()
        {
            Console.WriteLine("Enter TestAsync");
            var awaiter = new Awaiter();
            //var hold = GCHandle.Alloc(awaiter);

            var i = 0;
            while (true)
            {
                await awaiter;
                Console.WriteLine("tick: " + i++);
            }
            Console.WriteLine("Exit TestAsync");
        }
        */

        // Manually coded state machine version

        struct StateMachine: IAsyncStateMachine
        {
            public int _state;
            public Awaiter _awaiter;
            public AsyncTaskMethodBuilder _builder;

            public void MoveNext()
            {
                Console.WriteLine("StateMachine.MoveNext, state: " + this._state);
                switch (this._state)
                {
                    case -1:
                        {
                            this._awaiter = new Awaiter();
                            goto case 0;
                        };
                    case 0:
                        {
                            this._state = 0;
                            var awaiter = this._awaiter;
                            this._builder.AwaitOnCompleted(ref awaiter, ref this);
                            return;
                        };

                    default:
                        throw new InvalidOperationException();
                }
            }

            public void SetStateMachine(IAsyncStateMachine stateMachine)
            {
                Console.WriteLine("StateMachine.SetStateMachine, state: " + this._state);
                this._builder.SetStateMachine(stateMachine);
                // s_strongRef = stateMachine;
            }

            static object s_strongRef = null;
        }

        static Task TestAsync()
        {
            StateMachine stateMachine = new StateMachine();
            stateMachine._state = -1;

            stateMachine._builder = AsyncTaskMethodBuilder.Create();
            stateMachine._builder.Start(ref stateMachine);

            return stateMachine._builder.Task;
        }

        public static void Main(string[] args)
        {
            var task = TestAsync();
            Thread.Sleep(1000);
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
            Console.WriteLine("Press Enter to exit...");
            Console.ReadLine();
        }

        // custom awaiter
        public class Awaiter :
            System.Runtime.CompilerServices.INotifyCompletion
        {
            Action _continuation;

            public Awaiter()
            {
                Console.WriteLine("Awaiter()");
            }

            ~Awaiter()
            {
                Console.WriteLine("~Awaiter()");
            }

            // resume after await, called upon external event
            public void Continue()
            {
                var continuation = Interlocked.Exchange(ref _continuation, null);
                if (continuation != null)
                    continuation();
            }

            // custom Awaiter methods
            public Awaiter GetAwaiter()
            {
                return this;
            }

            public bool IsCompleted
            {
                get { return false; }
            }

            public void GetResult()
            {
            }

            // INotifyCompletion
            public void OnCompleted(Action continuation)
            {
                Console.WriteLine("Awaiter.OnCompleted");
                Volatile.Write(ref _continuation, continuation);
            }
        }
    }
}

la machine d'état générée par le compilateur est une structure mutable, étant dépassée par ref. Apparemment, c'est une optimisation pour éviter les affectations supplémentaires.

La partie centrale de ce qui est de prendre place à l'intérieur de AsyncMethodBuilderCore.GetCompletionAction, où la structure de la machine de l'état actuel est la référence à la copie boxée est conservée par le rappel de continuation passé à INotifyCompletion.OnCompleted.

C'est la seule référence à la machine d'état qui a une chance de supporter le GC et de survivre après await. Task objet renvoyé par TestAsync contenir une référence à elle, uniquement de la await poursuite de rappel. Je crois que c'est fait exprès, pour préserver le comportement efficace du GC.

noter le commentaire ligne:

// s_strongRef = stateMachine;

si je le dés-commente, la copie boxée de la machine d'état n'est pas GC'ED, et awaiter reste en vie comme une partie d'elle. Bien sûr, ce n'est pas une solution, mais cela illustre le problème.

donc, j'en suis arrivé à la conclusion suivante. Alors qu'une opération async est en "vol" et qu'aucun des états de la machine d'état (MoveNext) est actuellement en cours d'exécution, c'est la responsabilité de la "gardien" de la poursuite de rappel pour mettre un forte emprise sur le rappel lui-même, pour s'assurer que la copie en boite de la machine d'état ne reçoit pas les ordures.

par exemple, en cas de YieldAwaitable (retournée par Task.Yield), la référence externe au rappel de continuation est conservée par le ThreadPool planificateur de tâches, résultat de ThreadPool.QueueUserWorkItem appel. Dans le cas où Task.GetAwaiter, c'est indirectement référencés par l'objet tâche.

Dans mon cas, le "gardien" de la poursuite le rappel est le Awaiter lui-même.

ainsi, tant qu'il n'y a pas de référence externe à la continuation de l'objet callback que le CLR connaît (en dehors de l'état de l'objet machine), l'awaiter personnalisé devrait prendre des mesures pour garder l'objet callback en vie. Cela, à son tour, maintiendrait en vie toute la machine d'état. Les étapes suivantes seront nécessaires dans ce cas:

1. appelez le GCHandle.Alloc sur le rappel sur INotifyCompletion.OnCompleted.
2. Appel GCHandle.Free quand l'async l'événement s'est réellement produit, avant d'invoquer le rappel de continuation.
3. implémenter IDispose appeler GCHandle.Free si l'événement n'est jamais arrivé.

étant donné que, ci-dessous est une version du code de rappel de minuterie original, qui fonctionne correctement. notez qu'il n'est pas nécessaire de mettre un hold-up important sur le délégué de callback timer (WaitOrTimerCallbackProc callback). Il est maintenu en vie comme une partie de la machine d'état.mise à Jour: comme le souligne @svick, ce déclaration peut être spécifique à la mise en place de la machine d'état (C# 5.0). J'ai ajouté GC.KeepAlive(callback) pour éliminer toute dépendance à ce comportement, au cas où il changerait dans les futures versions du compilateur.

using System;
using System.Runtime.InteropServices;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApplication
{
    class Program
    {
        // Test task
        static async Task TestAsync(CancellationToken token)
        {
            using (var awaiter = new Awaiter())
            {
                WaitOrTimerCallbackProc callback = (a, b) =>
                    awaiter.Continue();
                try
                {
                    IntPtr timerHandle;
                    if (!CreateTimerQueueTimer(out timerHandle,
                            IntPtr.Zero,
                            callback,
                            IntPtr.Zero, 500, 500, 0))
                        throw new System.ComponentModel.Win32Exception(
                            Marshal.GetLastWin32Error());
                    try
                    {
                        var i = 0;
                        while (true)
                        {
                            token.ThrowIfCancellationRequested();
                            await awaiter;
                            Console.WriteLine("tick: " + i++);
                        }
                    }
                    finally
                    {
                        DeleteTimerQueueTimer(IntPtr.Zero, timerHandle, IntPtr.Zero);
                    }
                }
                finally
                {
                    // reference the callback at the end
                    // to avoid a chance for it to be GC'ed
                    GC.KeepAlive(callback);
                }
            }
        }

        // Entry point
        static void Main(string[] args)
        {
            // cancel in 3s
            var testTask = TestAsync(new CancellationTokenSource(10 * 1000).Token);

            Thread.Sleep(1000);
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);

            Thread.Sleep(2000);
            Console.WriteLine("Press Enter to GC...");
            Console.ReadLine();

            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
            Console.WriteLine("Press Enter to exit...");
            Console.ReadLine();
        }

        // Custom awaiter
        public class Awaiter :
            System.Runtime.CompilerServices.INotifyCompletion,
            IDisposable
        {
            Action _continuation;
            GCHandle _hold = new GCHandle();

            public Awaiter()
            {
                Console.WriteLine("Awaiter()");
            }

            ~Awaiter()
            {
                Console.WriteLine("~Awaiter()");
            }

            void ReleaseHold()
            {
                if (_hold.IsAllocated)
                    _hold.Free();
            }

            // resume after await, called upon external event
            public void Continue()
            {
                Action continuation;

                // it's OK to use lock (this)
                // the C# compiler would never do this,
                // because it's slated to work with struct awaiters
                lock (this)
                {
                    continuation = _continuation;
                    _continuation = null;
                    ReleaseHold();
                }

                if (continuation != null)
                    continuation();
            }

            // custom Awaiter methods
            public Awaiter GetAwaiter()
            {
                return this;
            }

            public bool IsCompleted
            {
                get { return false; }
            }

            public void GetResult()
            {
            }

            // INotifyCompletion
            public void OnCompleted(Action continuation)
            {
                lock (this)
                {
                    ReleaseHold();
                    _continuation = continuation;
                    _hold = GCHandle.Alloc(_continuation);
                }
            }

            // IDispose
            public void Dispose()
            {
                lock (this)
                {
                    _continuation = null;
                    ReleaseHold();
                }
            }
        }

        // p/invoke
        delegate void WaitOrTimerCallbackProc(IntPtr lpParameter, bool TimerOrWaitFired);

        [DllImport("kernel32.dll")]
        static extern bool CreateTimerQueueTimer(out IntPtr phNewTimer,
            IntPtr TimerQueue, WaitOrTimerCallbackProc Callback, IntPtr Parameter,
            uint DueTime, uint Period, uint Flags);

        [DllImport("kernel32.dll")]
        static extern bool DeleteTimerQueueTimer(IntPtr TimerQueue, IntPtr Timer,
            IntPtr CompletionEvent);
    }
}