Erlang C Probability of Wait:

Performance Engineering

Meaning

Technically, the Erlang C formula computes the probability that an arriving job must wait for service in an M/M/c queue, given the number of servers c and traffic intensity ρ. It addresses the pain point of predicting delay probabilities when planning capacity for call centers, cloud services, or any multi‑server system. The formula is applied when arrivals follow a Poisson process and service times are exponentially distributed.

Primary Function

Queueing theory

Communicative Purpose

Enables estimation of the probability that a request will wait for a server in an Erlang C model.

Pattern

estimate wait probability → compute P_wait using Erlang C formula → guide resource provisioning

Core Structure

P_wait = ((c*ρ)**c / factorial(c)) * (c / (c - c*ρ)) / (sum((c*ρ)**k / factorial(k) for k in range(c)) + ((c*ρ)**c / factorial(c)) * (c / (c - c*ρ)))

Função primária

Queueing theory

Propósito comunicativo

Enables estimation of the probability that a request will wait for a server in an Erlang C model.

Situações de gatilho

Call center staffing: estimating probability callers wait for an agent; Cloud autoscaling: assessing wait probability for incoming requests

Contextos

Performance engineering, operations research, capacity planning tools, telecommunication systems

Padrão

estimate wait probability → compute P_wait using Erlang C formula → guide resource provisioning

Estrutura central

P_wait = ((c*ρ)**c / factorial(c)) * (c / (c - c*ρ)) / (sum((c*ρ)**k / factorial(k) for k in range(c)) + ((c*ρ)**c / factorial(c)) * (c / (c - c*ρ)))

Colocados típicos

traffic intensity ρ
number of servers c
service rate μ
utilization
Poisson arrivals

Substituições comuns

Use the Halfin‑Whitt (QED) approximation for large c to avoid heavy factorial calculations – less precise but faster
Replace factorial with gamma function for non‑integer c – more general but uncommon

Erros comuns

Using ρ > 1 leads to division by zero → infinite wait probability; Omitting the summation term in the denominator → underestimates wait probability; Treating cρ as addition instead of multiplication in the exponent → incorrect result

Similar / contraste

Erlang B vs Erlang C: B gives blocking probability without queue, C includes waiting probability; M/M/c vs M/M/1: multi‑server vs single‑server dynamics

Interferências

Coming from Python: using integer division // truncates results → inaccurate probability; Coming from Excel: using COMMA as decimal separator may misinterpret parameters → wrong computation

Família do chunk

Erlang B
Erlang C
M/M/c queue
Queueing theory formulas

Nuance

Do not use when arrivals are not Poisson or service times not exponential → model mismatch; Computing the exact formula for large c is costly → consider approximations for performance; The formula requires 0 ≤ ρ < 1 and integer c > 0 → violating these boundaries causes errors

Efeito pragmático

Correct use enables reliable staffing decisions and prevents over‑ or under‑provisioning of server resources

Dica de memória

Think of a busy coffee shop line: Erlang C tells you how likely you’ll have to wait for a barista.

Nota

Assumes infinite queue capacity and first‑come‑first‑served discipline

Upgrade path

After mastering Erlang C, move to the Halfin‑Whitt (QED) approximation for large‑scale systems

Frequência: MediumFormulaicidade: FixedTipo de construção: mathematical formulaPrioridade de aquisição: Active recallPrioridade de output: BothTag de espaçamento: Medium-term

Examples

import math c = 5 rho = 0.7 numer = (c * rho) ** c / math.factorial(c) * (c / (c - c * rho)) den = sum((c * rho) ** k / math.factorial(k) for k in range(c)) + (c * rho) ** c / math.factorial(c) * (c / (c - c * rho)) p_wait = numer / den print(f"P_wait = {p_wait:.4f}")

import math def erlang_c(c, rho): if not (0 <= rho < 1): raise ValueError("Traffic intensity rho must be in [0,1).") numer = (c * rho) ** c / math.factorial(c) * (c / (c - c * rho)) denom = sum((c * rho) ** k / math.factorial(k) for k in range(c)) + (c * rho) ** c / math.factorial(c) * (c / (c - c * rho)) return numer / denom # Capacity planning example required_wait = 0.05 for servers in range(1, 20): prob = erlang_c(servers, 0.85) if prob < required_wait: print(f"Minimum servers needed: {servers}") break

import math from scipy.special import factorial def erlang_c_scipy(c, rho): numer = (c * rho) ** c / factorial(c) * (c / (c - c * rho)) denom = sum((c * rho) ** k / factorial(k) for k in range(c)) + (c * rho) ** c / factorial(c) * (c / (c - c * rho)) return numer / denom print(erlang_c_scipy(10, 0.9))