This simulator follows each function invocation into an execution environment: a cold start when a new environment must initialize, a warm reuse when an idle one is available, and a throttle when the pool is full. You set the timings and limits and see the latency and counts respond.
• A 3D scene with the synchronous invocation source, an initialization stage, warm execution environments, a handler execution stage, and a results and throttling counter. • Controls for the invocation interval (0.25 to 3 seconds), cold initialization duration (0.5 to 3 seconds), handler execution duration (0.25 to 2 seconds), concurrency limit (1 to 6) and idle environment lifetime (1 to 8 seconds). • Readouts for invocations, completed, cold starts, throttled invocations, busy environments and mean completed duration. • Experiments for warm reuse, concurrency exhausted and expiry between calls.
A cold invocation pays initialization plus handler time; a warm invocation pays only the handler duration, because a retained environment is already initialized. When invocations arrive faster than handlers finish and every allowed environment is busy, the excess synchronous calls are throttled, and the accounting identity is received equals completed plus busy plus throttled. Idle environments are retired once their idle age exceeds the lifetime setting, so when calls are spaced farther apart than the lifetime, every call becomes a cold start again. Mean completed duration rises as the share of cold starts rises.
This is a generic synchronous function runtime. The deterministic idle lifetime is a user-controlled teaching setting; real providers do not promise such a fixed retention. The model leaves out asynchronous retries, billing, provisioned concurrency and network latency. Serverless does not mean there are no servers — the provider operates them — and the lab concentrates on the behavior visible to the caller.
No. The provider operates the underlying infrastructure; the developer just does not manage it. The lab shows the consequence: execution environments still have to be created, which is what a cold start represents.
No. A warm invocation reuses a retained, initialized environment and pays only the handler duration. Only cold invocations pay initialization plus handler time.
Throttling happens when a synchronous invocation arrives and all environments allowed by the concurrency limit are busy. The call is rejected and counted in the throttled readout. Raising the concurrency limit or spacing out invocations removes it.
If the gap between calls exceeds the idle environment lifetime, the environment is retired before the next call, so the next invocation must initialize a new one. Shorten the interval or lengthen the lifetime to restore reuse.