Akka.Streams.Implementation.Fusing.GraphInterpreter.Execute C# (CSharp) Method

        public void Execute(int eventLimit)
        {
            if (IsDebug) Console.WriteLine($"{Name} ---------------- EXECUTE {QueueStatus()} (running={RunningStagesCount}, shutdown={ShutdownCounters()})");
            var currentInterpreterHolder = CurrentInterpreter.Value;
            var previousInterpreter = currentInterpreterHolder[0];
            currentInterpreterHolder[0] = this;
            try
            {
                var eventsRemaining = eventLimit;
                while (eventsRemaining > 0 && _queueTail != _queueHead)
                {
                    var connection = Dequeue();
                    try
                    {
                        ProcessEvent(connection);
                    }
                    catch (Exception e)
                    {
                        if (ActiveStage == null)
                            throw;

                        var stage = Assembly.Stages[ActiveStage.StageId];
                        if (Log.IsErrorEnabled)
                            Log.Error(e, $"Error in stage [{stage}]: {e.Message}");

                        ActiveStage.FailStage(e);
                    }
                    AfterStageHasRun(ActiveStage);
                    eventsRemaining--;
                }
            }
            finally
            {
                currentInterpreterHolder[0] = previousInterpreter;
            }
            if (IsDebug) Console.WriteLine($"{Name} ---------------- {QueueStatus()} (running={RunningStagesCount}, shutdown={ShutdownCounters()})");
            // TODO: deadlock detection
        }

        private int RunBatch(int actorEventLimit)
        {
            try
            {
                var usingShellLimit = _shellEventLimit < actorEventLimit;
                var remainingQuota  = _interpreter.Execute(Math.Min(actorEventLimit, _shellEventLimit));

                if (Interpreter.IsCompleted)
                {
                    // Cannot stop right away if not completely subscribed
                    if (CanShutdown)
                    {
                        _interpreterCompleted = true;
                    }
                    else
                    {
                        _waitingForShutdown = true;
                        Materializer.ScheduleOnce(_settings.SubscriptionTimeoutSettings.Timeout,
                                                  () => Self.Tell(new ActorGraphInterpreter.Abort(this)));
                    }
                }
                else if (Interpreter.IsSuspended && !_resumeScheduled)
                {
                    SendResume(!usingShellLimit);
                }

                return(usingShellLimit ? actorEventLimit - _shellEventLimit + remainingQuota : remainingQuota);
            }
            catch (Exception reason)
            {
                TryAbort(reason);
                return(actorEventLimit - 1);
            }
        }