Throughput = Requests / Time

Performance Engineering

Meaning

Throughput measures the number of requests processed per unit of time, providing a simple performance metric for systems under load.

Primary Function

Performance measurement

Communicative Purpose

Quantify how many requests a system can handle in a given time interval.

Pattern

throughput = requests / time

Core Structure

... = ... / ...

Função primária

Performance measurement

Propósito comunicativo

Quantify how many requests a system can handle in a given time interval.

Situações de gatilho

Load testing a web service, benchmarking API endpoints, monitoring server capacity.

Contextos

Web applications, microservices, distributed systems, networking equipment.

Padrão

throughput = requests / time

Estrutura central

... = ... / ...

Slots de substituição

throughput: float (requests per unit time), requests: int or float (number of requests), time: float (duration in same unit, e.g. seconds)

Colocados típicos

latency
response time
benchmarking
load testing

Substituições comuns

requests_per_second = request_count / elapsed_seconds

Erros comuns

Using integer division (e.g., Python 2) leading to zero; forgetting to ensure time > 0; mixing units (milliseconds vs seconds).

Similar / contraste

latency = time / requests (average time per request); requests_per_second = 1 / latency

Interferências

Coming from mathematics: may confuse throughput with utilization ratio; ensure correct units are used.

Família do chunk

Performance metrics
latency
requests per second
utilization

Nuance

Assumes a constant rate; for bursty traffic use a moving average; avoid division by zero.

Efeito pragmático

Provides a quick performance indicator for capacity planning and scaling decisions.

Dica de memória

Think 'Requests over Time'.

Nota

Ensure the time measurement uses the same unit as the request count to avoid unit mismatches.

Upgrade path

Use sliding window throughput: sum(requests in window) / window_duration

Frequência: MediumFormulaicidade: Semi-fixedTipo de construção: conceptPrioridade de aquisição: Active recallPrioridade de output: BothTag de espaçamento: Medium-term

Examples

def compute_throughput(requests, seconds): """Calculate throughput as requests per second.""" if seconds == 0: raise ValueError("Duration must be greater than zero") return requests / seconds print(compute_throughput(1500, 30)) # 50.0 requests per second

import time start = time.time() request_count = 0 while request_count < 1000: request_count += 1 time.sleep(0.001) # simulate 1 ms handling time per request elapsed = time.time() - start throughput = request_count / elapsed print(f"Throughput: {throughput:.2f} req/s")

import time from collections import deque window = deque() window_duration = 10.0 # seconds def record_request(timestamp): window.append(timestamp) while window and timestamp - window[0] > window_duration: window.popleft() return len(window) / window_duration for _ in range(500): ts = time.time() print(f"Current throughput: {record_request(ts):.2f} req/s") time.sleep(0.05)