ConvBnReluFusionScenario
Optimization scenarios · Implementation: mlsysim/engine/scenario_definitions/optimization.py.
Construct this scenario with keyword inputs. The fields below show the types and defaults declared by this class.
A convolution, batch norm, and ReLU on one feature map, run as three kernels or one.
Unfused, each kernel reads its input from device memory and writes its output back (six transfers), and the convolution and norm also read their parameters; fused (the norm folded into the convolution’s weights and bias, the ReLU applied before the write), one read and one write remain. A lower bound on time: traffic over hardware’s memory bandwidth, compute ignored.
Notes
Equation: traffic_cut is the worked quantity; each property below states its equation and units.
Assumptions: Batch normalization folds into dense convolution parameters and ReLU fuses before the output write.
Excludes: Compute work, cache hits, workspace, and measured kernel-fusion speedup.
References
Derivation: The equations below follow the stated counts, geometric relations, or accounting definitions; scenario inputs are supplied assumptions or observations, not fitted predictions.
Examples
Execute the registered worked inputs; this is a modeled calculation.
>>> from mlsysim import Scenarios
>>> case = Scenarios.ResNet50Conv256FusionH100
>>> value = case.traffic_cut
>>> round(value, 3)
0.448Attributes
| Name | Description |
|---|---|
| bytes_per_value | |
| channels | |
| conv_traffic | Convolution traffic in MB, one feature-map read/write plus weights. |
| conv_weights | Dense same-width convolution weight footprint in MB. |
| eliminated_activation_traffic | Activation traffic eliminated by fusion, four feature-map transfers in MB. |
| feature_map | One feature-map footprint in KB. |
| fused_time | Fused memory-bandwidth time floor in microseconds. |
| fused_traffic | Fused traffic in MB after folding norm parameters into convolution. |
| fused_trips | Activation-transfer count after folding normalization and fusing ReLU. |
| hardware | |
| height | |
| kernel_size | |
| norm_params | Batch-normalization parameter storage in KB. |
| norm_params_per_channel | |
| norm_traffic | Normalization traffic in MB, one feature-map read/write plus norm parameters. |
| relu_traffic | ReLU traffic in MB, one feature-map read/write. |
| time_ratio | Dimensionless unfused-to-fused memory-time ratio. |
| traffic_cut | Dimensionless fractional traffic reduction from fusion. |
| unfused_time | Unfused memory-bandwidth time floor in microseconds. |
| unfused_traffic | Total unfused traffic in MB across the three kernels. |
| unfused_trips | Activation-transfer count for separate convolution, normalization, and ReLU kernels. |
| width |
channels
Type: int.
Declared default: required.
height
Type: int.
Declared default: required.
width
Type: int.
Declared default: required.
kernel_size
Type: int.
Declared default: required.
bytes_per_value
Type: Quantity.
Declared default: required.
norm_params_per_channel
Type: int.
Declared default: required.
hardware
Type: HardwareNode.
Declared default: required.
feature_map
engine.scenario_types.ConvBnReluFusionScenario.feature_map
One feature-map footprint in KB.
Equation: return (self.channels * self.height * self.width * self.bytes_per_value).to(‘KB’)
conv_weights
engine.scenario_types.ConvBnReluFusionScenario.conv_weights
Dense same-width convolution weight footprint in MB.
Equation: return (self.channels * self.channels * self.kernel_size ** 2 * self.bytes_per_value).to(‘MB’)
norm_params
engine.scenario_types.ConvBnReluFusionScenario.norm_params
Batch-normalization parameter storage in KB.
Equation: return (self.channels * self.norm_params_per_channel * self.bytes_per_value).to(‘KB’)
conv_traffic
engine.scenario_types.ConvBnReluFusionScenario.conv_traffic
Convolution traffic in MB, one feature-map read/write plus weights.
Equation: return (2 * self.feature_map + self.conv_weights).to(‘MB’)
norm_traffic
engine.scenario_types.ConvBnReluFusionScenario.norm_traffic
Normalization traffic in MB, one feature-map read/write plus norm parameters.
Equation: return (2 * self.feature_map + self.norm_params).to(‘MB’)
relu_traffic
engine.scenario_types.ConvBnReluFusionScenario.relu_traffic
ReLU traffic in MB, one feature-map read/write.
Equation: return (2 * self.feature_map).to(‘MB’)
unfused_trips
engine.scenario_types.ConvBnReluFusionScenario.unfused_trips
Activation-transfer count for separate convolution, normalization, and ReLU kernels.
Equation: return 6
fused_trips
engine.scenario_types.ConvBnReluFusionScenario.fused_trips
Activation-transfer count after folding normalization and fusing ReLU.
Equation: return 2
unfused_traffic
engine.scenario_types.ConvBnReluFusionScenario.unfused_traffic
Total unfused traffic in MB across the three kernels.
Equation: return (self.conv_traffic + self.norm_traffic + self.relu_traffic).to(‘MB’)
fused_traffic
engine.scenario_types.ConvBnReluFusionScenario.fused_traffic
Fused traffic in MB after folding norm parameters into convolution.
Equation: return self.conv_traffic
eliminated_activation_traffic
engine.scenario_types.ConvBnReluFusionScenario.eliminated_activation_traffic
Activation traffic eliminated by fusion, four feature-map transfers in MB.
Activation transfers fusion removes (four feature-map trips).
Equation: return ((self.unfused_trips - self.fused_trips) * self.feature_map).to(‘MB’)
traffic_cut
engine.scenario_types.ConvBnReluFusionScenario.traffic_cut
Dimensionless fractional traffic reduction from fusion.
Equation: return 1 - (self.fused_traffic / self.unfused_traffic).to(’’).magnitude
unfused_time
engine.scenario_types.ConvBnReluFusionScenario.unfused_time
Unfused memory-bandwidth time floor in microseconds.
Equation: return (self.unfused_traffic / self.hardware.memory.bandwidth).to(‘microsecond’)
fused_time
engine.scenario_types.ConvBnReluFusionScenario.fused_time
Fused memory-bandwidth time floor in microseconds.
Equation: return (self.fused_traffic / self.hardware.memory.bandwidth).to(‘microsecond’)
time_ratio
engine.scenario_types.ConvBnReluFusionScenario.time_ratio
Dimensionless unfused-to-fused memory-time ratio.
Equation: return (self.unfused_time / self.fused_time).to(’’).magnitude