Optimization Scenarios

Execution bottlenecks, hardware utilization, and resource placement.

All domains · Classes A–Z

Source locations

• Inputs and calculations: mlsysim/engine/scenario_definitions/optimization.py.
• Named configurations: mlsysim/engine/scenario_catalog/optimization/.
• Result schemas: mlsysim/engine/result_types/optimization.py.

Public imports and existing class reference URLs remain stable.

Scenario contracts

• AcceleratedFractionScenario: Amdahl’s law with a path gain set by two rates: fraction of the baseline time runs accelerated_rate / baseline_rate times faster.
• AcceleratorComparison: candidate against baseline: peak, power, and peak per watt.
• AcceleratorGenerationsScenario: Peak compute against memory bandwidth across accelerators, first to last.
• AcceleratorPodScenario: A pod envelope of pod.chips copies of accelerator: aggregate peak and memory.
• AmdahlScenario: A sequential request path whose stage is made speedup times faster.
• ClusterExpansionScenario: A synchronous job grown from n_devices to factor times as many on the same checkpoint tier.
• ClusterTrainingTimeScenario: Training workload on n_devices x hardware at one end-to-end utilization (compute-bound).
• CompileBreakevenScenario: Eager against compiled execution: the work that repays compile_time.
• ConvBnReluFusionScenario: A convolution, batch norm, and ReLU on one feature map, run as three kernels or one.
• DailyUploadScenario: A site’s daily captures sent over its uplink inside a working window, against compact summaries.
• DiurnalLendingScenario: A fleet split between a serving reservation and a training base, static against lent.
• DominantShareScenario: Dominant-resource fairness by progressive filling of indivisible bundles on capacity.
• ElasticResizeScenario: Three ways to run one job over window: start small, wait for the full size, or step up.
• ElementwiseOpScenario: An element-wise or normalization kernel over elements values, run unfused.
• ExpertWeightTrafficScenario: Weight bytes of the mixture-of-experts workload, resident and read per token, against a dense model of dense_parameters that reads every weight each step.
• FrameCompressionScenario: A per-frame model against a camera frame rate: the full model and a channel-pruned variant, run in floating point on the CPU and in integers on the accelerator.
• GrowthGapScenario: Compute doubling every compute_doubling_period against bandwidth growing bandwidth_growth a year.
• HostDispatchScenario: The host’s work to issue one eager step against device_time of accelerator work.
• HostInputPipelineScenario: A data loader feeding one accelerator over its host link.
• InputSpaceScenario: Every possible input of dataset’s image shape: levels values per channel element.
• IronLawScenario: The iron law’s three terms for one task, and an upgrade to the memory or compute term.
• IterationBudgetScenario: Two teams in one development window: a slow cycle against a fast one, with assumed gains per run.
• JacobianScenario: The full Jacobian of one layer from input_width inputs to output_width outputs.
• KernelFusionScenario: A chain of chain_length element-wise operations, run as one kernel each or fused into one.
• LateConstraintScenario: A model built without its deployment limit, the day the limit surfaces, and the repair it forces.
• MatmulTileScenario: C = A B with A m x k and B k x n, computed one tile_m x tile_n output tile at a time, stepping through the reduction tile_k elements per step.
• MemoryRoundTripScenario: A tensor of tensor_bytes crossing to and from memory trips times at energy_per_byte (a layer boundary writes it and the next layer reads it back).
• MlpTrainingStepScenario: One eager training step of a one-hidden-layer MLP, operator by operator.
• NodePackingScenario: Jobs of job_gpus GPUs packed on nodes nodes of gpus_per_node.
• OffloadDeadlineScenario: One input sent over an uplink to a remote model, against a per-frame deadline (lower bound).
• OperationEnergyComparisonScenario: A wide and a narrow format’s energy per add, multiply, and multiply-accumulate, and one memory read against the narrow multiply-accumulate. The narrow MAC accumulates in a wider integer, so its add is accumulate_add.
• ParameterBandwidthGrowthScenario: Dense-model parameter growth against per-device memory-bandwidth growth.
• PeakRatioRangeScenario: One peak rate against a baseline stated as a range, baseline_low to baseline_high.
• PipelineSpeedupScenario: Serial pipeline stages; one stage is made speedup times faster (Amdahl’s law).
• PreemptionTaxScenario: Forced preemptions of an n_devices job whose checkpoint is checkpoint_bytes.
• QuantizationGridScenario: Values stored on a bits-bit integer grid over a clipping range.
• QuantizedDeploymentProfileScenario: A float model and its INT8 version on one accelerator, judged against acceptance limits.
• QuotaLendingScenario: A team guaranteed guarantee GPUs that uses used_share of them; the rest can be lent.
• RooflinePointScenario: A workload of intensity on hardware’s roofline: attainable rate and share of peak.
• ScreeningRequirementsScenario: A screener’s release floors and device budget, with measured slices checked against the floor.
• SelfContainedReplicaScenario: The smallest model replica of workload whose training state fits without sharding.
• ServingConsolidationScenario: Small and large serving models on whole devices, exclusive against shared in pairs.
• SingleNodeInferenceScenario: One inference of workload on hardware (roofline profile from SingleNodeModel).
• SparseFlashFitScenario: workload pruned until its surviving values total surviving_bytes, stored with one index_bytes position index per value, against a flash_budget.
• SpeedupCompositionScenario: Independent paper speedups multiplied together, against the measured speedup.
• StagedCompressionScenario: A teacher pruned and distilled into a compact student, then quantized, with the task accuracy after each stage and the loss when quantization comes first.
• SystolicReuseEnergyScenario: Energy per MAC with every operand from off-chip memory, against a systolic array.
• WakeWordFleetScenario: Wake-word detection for a device fleet: stream everything to the cloud, or detect on device.
• WeightReadScenario: Every weight of workload read once from hardware’s memory at bytes_per_weight.
• WorkLatencyGapScenario: A cut in work (parameters or FLOPs) against the latency cut it delivered.