UtilizationMonitor Class — netty Architecture

Source Code

common/src/main/java/io/netty/util/concurrent/AutoScalingEventExecutorChooserFactory.java lines 268–419

        private final class UtilizationMonitor implements Runnable {
            private final List<SingleThreadEventExecutor> consistentlyIdleChildren = new ArrayList<>(maxChildren);
            private long lastCheckTimeNanos;

            @Override
            public void run() {
                if (executors.length == 0 || executors[0].isShuttingDown()) {
                    // The group is shutting down, so no scaling decisions should be made.
                    // The lifecycle listener on the terminationFuture will handle the final cancellation.
                    return;
                }

                // Calculate the actual elapsed time since the last run.
                final long now = executors[0].ticker().nanoTime();
                long totalTime;

                if (lastCheckTimeNanos == 0) {
                    // On the first run, use the configured period as a baseline to avoid skipping the cycle.
                    totalTime = utilizationCheckPeriodNanos;
                } else {
                    // On subsequent runs, calculate the actual elapsed time.
                    totalTime = now - lastCheckTimeNanos;
                }

                // Always update the timestamp for the next cycle.
                lastCheckTimeNanos = now;

                if (totalTime <= 0) {
                    // Skip this cycle if the clock has issues or the interval is invalid.
                    return;
                }

                int consistentlyBusyChildren = 0;
                consistentlyIdleChildren.clear();

                final AutoScalingState currentState = state.get();

                for (int i = 0; i < executors.length; i++) {
                    EventExecutor child = executors[i];
                    if (!(child instanceof SingleThreadEventExecutor)) {
                        continue;
                    }

                    SingleThreadEventExecutor eventExecutor = (SingleThreadEventExecutor) child;

                    double utilization = 0.0;
                    if (!eventExecutor.isSuspended()) {
                        long activeTime = eventExecutor.getAndResetAccumulatedActiveTimeNanos();

                        if (activeTime == 0) {
                            long lastActivity = eventExecutor.getLastActivityTimeNanos();
                            long idleTime = now - lastActivity;

                            // If the event loop has been idle for less time than our utilization window,
                            // it means it was active for the remainder of that window.
                            if (idleTime < totalTime) {
                                activeTime = totalTime - idleTime;
                            }
                            // If idleTime >= totalTime, it was idle for the whole window, so activeTime remains 0.
                        }

                        utilization = Math.min(1.0, (double) activeTime / totalTime);

                        if (utilization < scaleDownThreshold) {
                            // Utilization is low, increment idle counter and reset busy counter.
                            int idleCycles = eventExecutor.getAndIncrementIdleCycles();
                            eventExecutor.resetBusyCycles();
                            if (idleCycles >= scalingPatienceCycles &&
                                eventExecutor.getNumOfRegisteredChannels() <= 0) {
                                consistentlyIdleChildren.add(eventExecutor);
                            }
                        } else if (utilization > scaleUpThreshold) {
                            // Utilization is high, increment busy counter and reset idle counter.
                            int busyCycles = eventExecutor.getAndIncrementBusyCycles();
                            eventExecutor.resetIdleCycles();
                            if (busyCycles >= scalingPatienceCycles) {
                                consistentlyBusyChildren++;
                            }
                        } else {
                            // Utilization is in the normal range, reset counters.
                            eventExecutor.resetIdleCycles();