ReleaseFootprintScenario
Reliability scenarios · Implementation: mlsysim/engine/scenario_definitions/reliability.py.
Construct this scenario with keyword inputs. The fields below show the types and defaults declared by this class.
Resident copies of model that release controls hold on device.
A copy is the registry model_size, or the parameters at bytes_per_param when given; it spans accelerators_per_copy devices. A canary, shadow, A/B test, blue-green switch, and hot standby each hold one more copy whatever share of traffic they serve. Optional: the node’s node_accelerators, a retraining run of retrain_accelerators for retrain_time on the same node, the canary_share, and the staged exposure ramp (traffic shares, first stage the canary).
Notes
Equation: A copy occupies the selected model bytes; devices per copy are ceil(copy_bytes/device_capacity); copies reserve that count independently.
Assumptions: A model copy can be partitioned across the counted devices; optional retraining fields are supplied before using retraining properties.
Excludes: Communication, KV cache, allocator reserve, packing efficiencies, and proof that a distributed serving layout executes.
References
Derivation: A copy occupies the selected model bytes; devices per copy are ceil(copy_bytes/device_capacity); copies reserve that count independently. This is declared scenario accounting rather than a fitted empirical law.
Examples
>>> from mlsysim import Scenarios
>>> scenario = Scenarios.DlrmReleaseFootprintH100
>>> value = scenario.copy_bytes
>>> str(value.units)
'GB'Attributes
| Name | Description |
|---|---|
| accelerators_per_copy | Ceiling of copy size over device capacity, ignoring partitioning and runtime overhead. |
| bytes_per_param | |
| canary_share | |
| copy_bytes | Model-copy storage from the registry size or the explicitly selected bytes per |
| copy_fraction | One model copy divided by one device’s capacity, a dimensionless memory share. |
| device | |
| free_during_retrain | Device count left after reserving one serving copy and the retraining allocation. |
| model | |
| node_accelerators | |
| ramp | |
| retrain_accelerator_hours | Device-hours consumed by the declared retraining allocation and duration. |
| retrain_accelerators | |
| retrain_time |
Methods
| Name | Description |
|---|---|
| accelerators_for | Device count for independently resident model copies, without cross-copy packing. |
| free_after | Device count remaining after the specified serving copies, with retraining absent. |
accelerators_for
engine.scenario_types.ReleaseFootprintScenario.accelerators_for(copies)Device count for independently resident model copies, without cross-copy packing.
Equation: copies * accelerators_per_copy.
free_after
engine.scenario_types.ReleaseFootprintScenario.free_after(copies)Device count remaining after the specified serving copies, with retraining absent.
Equation: node_accelerators - accelerators_for(copies).
model
Type: Any.
Declared default: required.
device
Type: HardwareNode.
Declared default: required.
bytes_per_param
Type: Optional[Quantity].
Declared default: None.
node_accelerators
Type: Optional[int].
Declared default: None.
retrain_accelerators
Type: Optional[int].
Declared default: None.
retrain_time
Type: Optional[Quantity].
Declared default: None.
ramp
Type: Optional[List[float]].
Declared default: None.
copy_bytes
engine.scenario_types.ReleaseFootprintScenario.copy_bytes
Model-copy storage from the registry size or the explicitly selected bytes per parameter.
Equation: model.size_in_bytes(bytes_per_param); otherwise model.model_size.
copy_fraction
engine.scenario_types.ReleaseFootprintScenario.copy_fraction
One model copy divided by one device’s capacity, a dimensionless memory share.
Equation: (copy_bytes / device.memory.capacity).to('').magnitude.
accelerators_per_copy
engine.scenario_types.ReleaseFootprintScenario.accelerators_per_copy
Ceiling of copy size over device capacity, ignoring partitioning and runtime overhead.
Equation: _math.ceil(copy_fraction).
retrain_accelerator_hours
engine.scenario_types.ReleaseFootprintScenario.retrain_accelerator_hours
Device-hours consumed by the declared retraining allocation and duration.
Equation: (retrain_accelerators * retrain_time).to('hour').
free_during_retrain
engine.scenario_types.ReleaseFootprintScenario.free_during_retrain
Device count left after reserving one serving copy and the retraining allocation.
Equation: node_accelerators - accelerators_per_copy - retrain_accelerators.