Function startUpscalingThreads

scaling.go:146–195

(maxScaledThreads int, scale chan *frankenPHPContext, done chan struct{}, mstate *state.ThreadState)

}

func startUpscalingThreads(maxScaledThreads int, scale chan *frankenPHPContext, done chan struct{}, mstate *state.ThreadState) {
	for {
		scalingMu.Lock()
		scaledThreadCount := len(autoScaledThreads)
		scalingMu.Unlock()
		if scaledThreadCount >= maxScaledThreads {
			// we have reached max_threads, check again later
			select {
			case <-done:
				return
			case <-time.After(downScaleCheckTime):
				continue
			}
		}

		select {
		case fc := <-scale:
			timeSinceStalled := time.Since(fc.startedAt)

			// if the request has not been stalled long enough, wait and repeat
			if timeSinceStalled < minStallTime {
				select {
				case <-done:
					return
				case <-time.After(minStallTime - timeSinceStalled):
					continue
				}
			}

			// if the request has been stalled long enough, scale
			if fc.worker == nil {
				scaleRegularThread(done, mstate)
				continue
			}

			// check for max worker threads here again in case requests overflowed while waiting
			if fc.worker.isAtThreadLimit() {
				if globalLogger.Enabled(globalCtx, slog.LevelInfo) {
					globalLogger.LogAttrs(globalCtx, slog.LevelInfo, "cannot scale worker thread, max threads reached for worker", slog.String("worker", fc.worker.name))
				}

				continue
			}

			scaleWorkerThread(fc.worker, done, mstate)
		case <-done:
			return
		}
	}
}

func startDownScalingThreads(done chan struct{}) {
	for {