Scaling Fundamentals

// How many vCPUs does the API tier need at peak, and what does that look like as one box vs many?
const dau = 20_000_000;          // daily active users
const requestsPerUser = 50;      // API calls per user per day
const peakFactor = 3;            // busiest minute vs the daily average
const cpuMsPerRequest = 4;       // measured CPU time per request (an assumption here)
const targetUtilisation = 0.6;   // leave headroom for spikes and GC

const avgQps = (dau * requestsPerUser) / 86_400;
const peakQps = avgQps * peakFactor;
const busyVcpus = (peakQps * cpuMsPerRequest) / 1000; // CPU-seconds needed per second
const vcpus = busyVcpus / targetUtilisation;
console.log(`average ${Math.round(avgQps).toLocaleString("en-US")} req/s, peak ${Math.round(peakQps).toLocaleString("en-US")} req/s`);
console.log(`busy vCPUs at peak ${busyVcpus.toFixed(0)}, provisioned at 60%: ${Math.ceil(vcpus)} vCPUs`);

// Horizontal: 8-vCPU instances spread over 3 availability zones, surviving the loss of one zone.
const perInstance = 8, zones = 3;
const needed = Math.ceil(vcpus / perInstance);
const perZone = Math.ceil(needed / (zones - 1)); // any 2 zones must carry the whole peak
console.log(`horizontal: ${needed} × ${perInstance}-vCPU instances, ${perZone} per zone × ${zones} zones = ${perZone * zones} instances`);

// Vertical: one big machine, plus a standby of the same size for failover.
console.log(`vertical: one ${Math.ceil(vcpus)}-vCPU machine + an identical standby = ${2 * Math.ceil(vcpus)} vCPUs bought`);

// Ten times the users later:
const later = Math.ceil((vcpus * 10) / perInstance);
console.log(`at 10× users: ${later} instances (${Math.ceil(later / (zones - 1)) * zones} with zone headroom), or a ${Math.ceil(vcpus * 10)}-vCPU box`);

average 11,574 req/s, peak 34,722 req/s
busy vCPUs at peak 139, provisioned at 60%: 232 vCPUs
horizontal: 29 × 8-vCPU instances, 15 per zone × 3 zones = 45 instances
vertical: one 232-vCPU machine + an identical standby = 464 vCPUs bought
at 10× users: 290 instances (435 with zone headroom), or a 2315-vCPU box

// 30,000 logged-in users, sticky routing by user id. Sessions live either in each server's
// memory or in one shared store. Who has to log in again after a crash or a scale-out?
const hash = (s) => {
  let h = 0x811c9dc5; // FNV-1a, then a murmur3-style finaliser to spread similar strings
  for (const c of s) h = Math.imul(h ^ c.charCodeAt(0), 0x01000193);
  h = Math.imul(h ^ (h >>> 16), 0x85ebca6b);
  h = Math.imul(h ^ (h >>> 13), 0xc2b2ae35);
  return (h ^ (h >>> 16)) >>> 0;
};
const users = Array.from({ length: 30_000 }, (_, i) => `user-${i}`);

const modRoute = (servers) => (u) => servers[hash(u) % servers.length];
const ringRoute = (servers) => {
  const ring = servers.flatMap((s) => Array.from({ length: 100 }, (_, v) => [hash(`${s}#${v}`), s])).sort((a, b) => a[0] - b[0]);
  return (u) => (ring.find(([p]) => p >= hash(u)) ?? ring[0])[1];
};

// Log everyone in through `before`, then send every user's next request through `after`.
function loggedOut(before, after, { shared = false, dead = null } = {}) {
  const memory = new Map(); // server -> Set of user ids it holds sessions for
  const store = new Set();  // the shared session store
  for (const u of users) {
    if (shared) store.add(u);
    else (memory.get(before(u)) ?? memory.set(before(u), new Set()).get(before(u))).add(u);
  }
  if (dead) memory.delete(dead); // a crash loses that server's memory
  const lost = users.filter((u) => !(shared ? store.has(u) : memory.get(after(u))?.has(u))).length;
  return `${((lost / users.length) * 100).toFixed(1)}%`.padStart(6);
}

const abc = ["A", "B", "C"], abcd = ["A", "B", "C", "D"];
const crashMod = (u) => modRoute(["A", "C"])(u); // after B dies, the balancer only knows A and C
console.log("event                        in-memory  shared store");
console.log(`B crashes (mod N)            ${loggedOut(modRoute(abc), crashMod, { dead: "B" })}      ${loggedOut(modRoute(abc), crashMod, { shared: true, dead: "B" })}`);
console.log(`B crashes (ring)             ${loggedOut(ringRoute(abc), ringRoute(["A", "C"]), { dead: "B" })}      ${loggedOut(ringRoute(abc), ringRoute(["A", "C"]), { shared: true, dead: "B" })}`);
console.log(`scale 3 → 4 (mod N)          ${loggedOut(modRoute(abc), modRoute(abcd))}      ${loggedOut(modRoute(abc), modRoute(abcd), { shared: true })}`);
console.log(`scale 3 → 4 (ring)           ${loggedOut(ringRoute(abc), ringRoute(abcd))}      ${loggedOut(ringRoute(abc), ringRoute(abcd), { shared: true })}`);

event                        in-memory  shared store
B crashes (mod N)             66.8%        0.0%
B crashes (ring)              32.6%        0.0%
scale 3 → 4 (mod N)           74.7%        0.0%
scale 3 → 4 (ring)            25.3%        0.0%

// Six clients keep one long-lived HTTP/2 (or gRPC) connection each and send many requests over it.
// An L4 balancer picks a backend per *connection*; an L7 balancer picks one per *request*.
const clients = [
  { name: "batch-job", rps: 600 }, { name: "web-bff", rps: 120 }, { name: "mobile-bff", rps: 90 },
  { name: "admin", rps: 10 }, { name: "reports", rps: 60 }, { name: "search", rps: 120 },
];
const show = (label, load) =>
  console.log(label.padEnd(30) + load.map((r) => `${r}`.padStart(6)).join("") + `   max/avg ${(Math.max(...load) / (load.reduce((a, b) => a + b) / load.length)).toFixed(2)}`);

function l4(backends) {
  const load = new Array(backends).fill(0);
  clients.forEach((c, i) => (load[i % backends] += c.rps)); // connection i → backend i mod N, for its whole life
  return load;
}
function l7(backends) {
  const load = new Array(backends).fill(0);
  let next = 0;
  for (const c of clients) for (let r = 0; r < c.rps; r++) load[next++ % backends]++; // every request picked afresh
  return load;
}

console.log("req/s per backend".padEnd(30) + ["b1", "b2", "b3", "b4"].map((b) => b.padStart(6)).join(""));
show("L4, 3 backends", l4(3));
show("L7, 3 backends", l7(3));

// Autoscaling adds b4. L4: existing connections stay where they are, so b4 gets nothing until clients reconnect.
const scaledL4 = [...l4(3), 0];
show("L4, b4 added (no reconnects)", scaledL4);
show("L7, b4 added", l7(4));

req/s per backend                 b1    b2    b3    b4
L4, 3 backends                   610   180   210   max/avg 1.83
L7, 3 backends                   334   333   333   max/avg 1.00
L4, b4 added (no reconnects)     610   180   210     0   max/avg 2.44
L7, b4 added                     250   250   250   250   max/avg 1.00

// 10 identical servers, one worker each, FIFO queue. Seeded, so every run prints the same.
function mulberry32(seed) {
  return () => {
    seed = (seed + 0x6d2b79f5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
const SERVERS = 10, REQUESTS = 200_000;
const MEAN_COST = 0.9 * 5 + 0.1 * 100; // ms: 90% cheap (5 ms), 10% expensive (100 ms)
const RATE = (0.8 * SERVERS) / MEAN_COST; // arrivals per ms for 80% average utilisation

const algorithms = {
  "round robin": (s, i) => i % SERVERS,
  random: (s, i, rnd) => Math.floor(rnd() * SERVERS),
  "least connections": (s, i) => {
    let best = i % SERVERS; // start the scan at a rotating index so ties are shared out
    for (let j = 1; j < SERVERS; j++) {
      const k = (i + j) % SERVERS;
      if (s[k].length < s[best].length) best = k;
    }
    return best;
  },
  "power of two": (s, i, rnd) => {
    const a = Math.floor(rnd() * SERVERS), b = Math.floor(rnd() * SERVERS);
    return s[a].length <= s[b].length ? a : b;
  },
};

const pct = (sorted, p) => sorted[Math.min(sorted.length - 1, Math.floor(p * sorted.length))];

for (const [name, pick] of Object.entries(algorithms)) {
  const rnd = mulberry32(42); // same arrivals and costs for every algorithm
  const queues = Array.from({ length: SERVERS }, () => []); // finish times of requests still on each server
  const busy = new Array(SERVERS).fill(0);
  const latencies = [];
  let now = 0;
  for (let i = 0; i < REQUESTS; i++) {
    now += -Math.log(1 - rnd()) / RATE; // Poisson arrivals
    const cost = rnd() < 0.9 ? 5 : 100;
    for (const q of queues) while (q.length && q[0] <= now) q.shift(); // drop finished requests
    const k = pick(queues, i, rnd);
    const start = Math.max(now, queues[k].at(-1) ?? now);
    queues[k].push(start + cost);
    busy[k] += cost;
    latencies.push(start + cost - now);
  }
  latencies.sort((a, b) => a - b);
  const util = busy.map((b) => b / now);
  console.log(
    `${name.padEnd(17)} util ${(Math.min(...util) * 100).toFixed(0)}–${(Math.max(...util) * 100).toFixed(0)}%` +
      `  p50 ${pct(latencies, 0.5).toFixed(0).padStart(3)} ms  p99 ${pct(latencies, 0.99).toFixed(0).padStart(4)} ms` +
      `  p99.9 ${pct(latencies, 0.999).toFixed(0).padStart(4)} ms`,
  );
}

round robin       util 78–81%  p50  87 ms  p99  669 ms  p99.9 1181 ms
random            util 78–82%  p50 100 ms  p99  718 ms  p99.9  944 ms
least connections util 80–80%  p50   5 ms  p99  184 ms  p99.9  242 ms
power of two      util 79–80%  p50  17 ms  p99  276 ms  p99.9  384 ms

// A primary sends a heartbeat every second; the standby takes over if none arrives for TIMEOUT.
// Seeded model of 30 days on a healthy primary: rare pauses (GC, network blips) delay heartbeats.
function mulberry32(seed) {
  return () => {
    seed = (seed + 0x6d2b79f5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
const rnd = mulberry32(2026);
const DAYS = 30, INTERVAL = 1000; // ms
const gaps = []; // time between consecutive heartbeats arriving at the standby
for (let i = 0; i < DAYS * 86_400; i++) {
  let gap = INTERVAL + (rnd() - 0.5) * 40; // ±20 ms of ordinary jitter
  if (rnd() < 0.0005) gap += 500 / Math.pow(1 - rnd(), 1 / 1.5); // a pause: Pareto, at least 500 ms, long tail
  gaps.push(gap);
}

const PROMOTION = 10_000; // ms to promote the standby and move the address once it decides (an assumption)
console.log("timeout   false failovers/day   real crash: detect + promote");
for (const timeout of [2_000, 3_000, 5_000, 10_000, 30_000]) {
  const falseAlarms = gaps.filter((g) => g > timeout).length / DAYS;
  // A real crash happens at a random moment after the last heartbeat, so on average
  // the standby notices TIMEOUT − INTERVAL/2 after the crash.
  const detect = timeout - INTERVAL / 2;
  console.log(
    `${(timeout / 1000 + " s").padStart(5)}   ${falseAlarms.toFixed(2).padStart(19)}   ` +
      `${(detect / 1000).toFixed(1)} s + ${PROMOTION / 1000} s = ${((detect + PROMOTION) / 1000).toFixed(1)} s down`,
  );
}

timeout   false failovers/day   real crash: detect + promote
  2 s                 15.37   1.5 s + 10 s = 11.5 s down
  3 s                  5.63   2.5 s + 10 s = 12.5 s down
  5 s                  1.80   4.5 s + 10 s = 14.5 s down
 10 s                  0.57   9.5 s + 10 s = 19.5 s down
 30 s                  0.10   29.5 s + 10 s = 39.5 s down

// At t = 0 you change www's A record from the dead region's IP to a healthy one.
// Every resolver cached the old answer at some random moment within the last TTL seconds,
// and a few resolvers or clients ignore short TTLs and keep answers for an hour (an assumption).
const IGNORE_SHARE = 0.03, IGNORE_HOLD = 3600; // 3% hold any answer for 1 h

const stillOld = (ttl, t) => {
  const honest = Math.max(0, 1 - t / ttl);                       // cache age is uniform in [0, ttl)
  const sticky = Math.max(0, 1 - t / Math.max(ttl, IGNORE_HOLD)); // same, but held for an hour
  return (1 - IGNORE_SHARE) * honest + IGNORE_SHARE * sticky;
};

const times = [10, 30, 60, 300, 900, 3600];
console.log("share of users still sent to the old IP");
console.log("TTL      " + times.map((t) => (t < 60 ? `${t}s` : `${t / 60}m`).padStart(7)).join(""));
for (const ttl of [30, 60, 300, 3600]) {
  console.log(`${String(ttl).padStart(4)} s   ` + times.map((t) => `${(stillOld(ttl, t) * 100).toFixed(1)}%`.padStart(7)).join(""));
}

// The price of a short TTL: every resolver asks again once per TTL.
const RESOLVERS = 200_000; // distinct caching resolvers that look up the name (an assumption)
console.log("\nqueries per second reaching your authoritative DNS");
for (const ttl of [30, 60, 300, 3600]) console.log(`${String(ttl).padStart(4)} s   ${Math.round(RESOLVERS / ttl).toLocaleString("en-US").padStart(6)} q/s`);

share of users still sent to the old IP
TTL          10s    30s     1m     5m    15m    60m
  30 s     67.7%   3.0%   2.9%   2.7%   2.3%   0.0%
  60 s     83.8%  51.5%   2.9%   2.7%   2.3%   0.0%
 300 s     96.8%  90.3%  80.5%   2.7%   2.3%   0.0%
3600 s     99.7%  99.2%  98.3%  91.7%  75.0%   0.0%

queries per second reaching your authoritative DNS
  30 s    6,667 q/s
  60 s    3,333 q/s
 300 s      667 q/s
3600 s       56 q/s

// One hour of traffic for 50,000 images through 20 edge PoPs, TTL 10 minutes. Seeded.
// Popularity is Zipf-like (a few images get most views). How many requests reach the origin?
function mulberry32(seed) {
  return () => {
    seed = (seed + 0x6d2b79f5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
const OBJECTS = 50_000, POPS = 20, REQUESTS = 2_000_000, HOUR = 3600, TTL = 600;
const cdf = [];
let sum = 0;
for (let k = 1; k <= OBJECTS; k++) cdf.push((sum += 1 / k)); // weight of rank k is 1/k
const zipf = (u) => {
  let lo = 0, hi = OBJECTS - 1; // binary search for the first rank whose CDF passes u·sum
  while (lo < hi) { const mid = (lo + hi) >> 1; if (cdf[mid] < u * sum) lo = mid + 1; else hi = mid; }
  return lo;
};

function run({ shield, noisyKeys }) {
  const rnd = mulberry32(99);
  const edges = Array.from({ length: POPS }, () => new Map()); // cache key -> expiry time
  const shieldCache = new Map();
  let edgeHits = 0, origin = 0;
  const fresh = (cache, key, t) => (cache.get(key) ?? -1) > t;
  for (let i = 0; i < REQUESTS; i++) {
    const t = (i / REQUESTS) * HOUR, pop = Math.floor(rnd() * POPS), obj = zipf(rnd());
    // Noisy keys: 30% of links carry a tracking parameter that ends up in the cache key.
    const key = noisyKeys && rnd() < 0.3 ? `img${obj}?utm=${Math.floor(rnd() * 50)}` : `img${obj}`;
    if (fresh(edges[pop], key, t)) { edgeHits++; continue; }
    edges[pop].set(key, t + TTL);
    if (shield) {
      if (fresh(shieldCache, key, t)) continue; // the shield answers; origin never sees it
      shieldCache.set(key, t + TTL);
    }
    origin++;
  }
  return `edge hit ratio ${((edgeHits / REQUESTS) * 100).toFixed(1)}%, origin requests ${origin.toLocaleString("en-US").padStart(7)} (${((origin / REQUESTS) * 100).toFixed(1)}%)`;
}

console.log(`no shield            ${run({ shield: false, noisyKeys: false })}`);
console.log(`with origin shield   ${run({ shield: true, noisyKeys: false })}`);
console.log(`shield + noisy keys  ${run({ shield: true, noisyKeys: true })}`);

no shield            edge hit ratio 68.0%, origin requests 639,105 (32.0%)
with origin shield   edge hit ratio 68.0%, origin requests 181,553 (9.1%)
shield + noisy keys  edge hit ratio 52.6%, origin requests 459,582 (23.0%)

// A mobile home screen needs: profile, feed and unread count (independent), then the authors of the
// feed's posts (depends on the feed). Compare the app calling services itself with one BFF call.
function mulberry32(seed) {
  return () => {
    seed = (seed + 0x6d2b79f5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}
const rnd = mulberry32(5);
const MOBILE_RTT = 120, DC_RTT = 1; // ms, assumptions: a phone on a cellular network vs inside one data centre
// Service time: usually ~20 ms, but 2% of calls hit a slow path (cache miss, GC) at ~250 ms.
const service = () => (rnd() < 0.02 ? 250 : 20) * (0.7 + 0.6 * rnd());

const direct = [], viaBff = [];
for (let i = 0; i < 20_000; i++) {
  // Direct: wave 1 is three parallel calls from the phone, wave 2 is the authors call.
  const wave1 = Math.max(MOBILE_RTT + service(), MOBILE_RTT + service(), MOBILE_RTT + service());
  direct.push(wave1 + MOBILE_RTT + service());
  // BFF: one round trip from the phone; the BFF does both waves inside the data centre.
  const inner = Math.max(DC_RTT + service(), DC_RTT + service(), DC_RTT + service()) + DC_RTT + service();
  viaBff.push(MOBILE_RTT + 2 /* BFF's own work */ + inner);
}
const pct = (xs, p) => [...xs].sort((a, b) => a - b)[Math.floor(p * xs.length)].toFixed(0).padStart(4);
console.log("home screen        p50     p95     p99");
console.log(`app → services   ${pct(direct, 0.5)} ms ${pct(direct, 0.95)} ms ${pct(direct, 0.99)} ms`);
console.log(`app → BFF        ${pct(viaBff, 0.5)} ms ${pct(viaBff, 0.95)} ms ${pct(viaBff, 0.99)} ms`);
const slowOne = 1 - 0.98 ** 4;
console.log(`chance at least one of the 4 calls is slow: ${(slowOne * 100).toFixed(1)}%`);

home screen        p50     p95     p99
app → services    284 ms  494 ms  568 ms
app → BFF         168 ms  374 ms  453 ms
chance at least one of the 4 calls is slow: 7.8%

// Target-tracking autoscaler vs a traffic surge, in 10-second steps (no randomness).
// Traffic sits at 3,000 req/s, then a push notification ramps it to 12,000 req/s within 2 minutes.
const CAPACITY = 500;  // req/s one instance serves at 100% CPU
const STEP = 10;       // seconds per simulation step
const traffic = (t) => (t < 300 ? 3000 : Math.min(12_000, 3000 + ((t - 300) / 120) * 9000));

function simulate({ warmup, target, start = 10 }) {
  let running = start;         // instances serving traffic
  const pending = [];          // ready-at times of instances still booting / warming up
  const busyHistory = [];      // instances' worth of CPU in use, as the metric reports it
  let dropped = 0, overloadedSteps = 0, peakCpu = 0;
  for (let t = 0; t < 1800; t += STEP) {
    while (pending.length && pending[0] <= t) pending.shift(), running++;
    const demand = traffic(t);
    const cpu = Math.min(1, demand / (running * CAPACITY)); // CPU can't show more than 100%
    busyHistory.push(cpu * running);
    peakCpu = Math.max(peakCpu, demand / (running * CAPACITY));
    if (demand > running * CAPACITY) (dropped += (demand - running * CAPACITY) * STEP), overloadedSteps++;
    if (t % 60 === 0 && t >= 120) {
      // Once a minute, read the average of the minute before last (metrics arrive about a minute late).
      const window = busyHistory.slice(-12, -6);
      const busy = window.reduce((a, b) => a + b, 0) / window.length;
      const desired = Math.ceil(busy / target);
      const total = running + pending.length; // instances already on the way count too
      for (let k = total; k < desired; k++) pending.push(t + warmup);
    }
  }
  return `overloaded ${((overloadedSteps * STEP) / 60).toFixed(1).padStart(4)} min, ` +
    `peak demand ${(peakCpu * 100).toFixed(0).padStart(3)}% of capacity, ` +
    `${(dropped / 1e6).toFixed(2)}M requests over capacity, ends with ${running} instances`;
}

console.log(`warm-up  60 s, target 60%: ${simulate({ warmup: 60, target: 0.6 })}`);
console.log(`warm-up 300 s, target 60%: ${simulate({ warmup: 300, target: 0.6 })}`);
console.log(`warm-up 300 s, target 40%: ${simulate({ warmup: 300, target: 0.4 })}`);
console.log(`warm-up 300 s, 30 at start: ${simulate({ warmup: 300, target: 0.6, start: 30 })}`);

warm-up  60 s, target 60%: overloaded  5.5 min, peak demand 240% of capacity, 1.31M requests over capacity, ends with 40 instances
warm-up 300 s, target 60%: overloaded 13.5 min, peak demand 240% of capacity, 3.83M requests over capacity, ends with 40 instances
warm-up 300 s, target 40%: overloaded  6.5 min, peak demand 225% of capacity, 1.64M requests over capacity, ends with 60 instances
warm-up 300 s, 30 at start: overloaded  0.0 min, peak demand  80% of capacity, 0.00M requests over capacity, ends with 40 instances

// Users in three regions; where do reads and writes go, and what does each design cost them?
// Round-trip times: Azure's published P50 between East US, West Europe and Southeast Asia (30 days to 30 July 2026).
const rtt = {
  us: { us: 0, eu: 83, asia: 224 },
  eu: { us: 85, eu: 0, asia: 169 },
  asia: { us: 224, eu: 169, asia: 0 },
};
const LOCAL = 2; // ms of work inside the region. The user’s hop to their nearest region is the same in every design, so it’s left out.
const regions = ["us", "eu", "asia"];

const designs = {
  // Everything lives in us.
  "single region (us)": (u) => ({ read: rtt[u].us, write: rtt[u].us }),
  // Read replicas everywhere, one primary in us for writes.
  "active-passive writes": (u) => ({ read: 0, write: rtt[u].us }),
  // Every region takes reads and writes locally; replication to the others is asynchronous.
  "active-active (async)": () => ({ read: 0, write: 0 }),
  // Every write must be acknowledged by a majority (2 of 3 regions) before it commits.
  "majority quorum (sync)": (u) => ({ read: 0, write: Math.min(...regions.filter((r) => r !== u).map((r) => rtt[u][r])) }),
};

console.log("design".padEnd(24) + regions.map((r) => `${r} read/write`.padStart(17)).join(""));
for (const [name, cost] of Object.entries(designs)) {
  const cells = regions.map((u) => {
    const { read, write } = cost(u);
    return `${read + LOCAL}/${write + LOCAL} ms`.padStart(17);
  });
  console.log(name.padEnd(24) + cells.join(""));
}

design                      us read/write    eu read/write  asia read/write
single region (us)                 2/2 ms         87/87 ms       226/226 ms
active-passive writes              2/2 ms          2/87 ms         2/226 ms
active-active (async)              2/2 ms           2/2 ms           2/2 ms
majority quorum (sync)            2/85 ms          2/87 ms         2/171 ms