use burn::{
module::Module,
tensor::{
Device,
FloatDType,
},
};
use crate::{
burner::{
dtypes::{
DTypeUsage,
dtype_usage,
},
module::{
DTypeMapper,
module_float_dtype,
},
tensor::float_width,
},
errors::{
BunsenError,
BunsenResult,
},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct LoadPolicy {
at_least: Option<FloatDType>,
half_needs: DTypeUsage,
}
impl LoadPolicy {
pub fn performance() -> Self {
Self {
at_least: None,
half_needs: DTypeUsage::Accelerated,
}
}
pub fn load_as_stored() -> Self {
Self {
at_least: None,
half_needs: DTypeUsage::Arithmetic,
}
}
pub fn at_least(dtype: FloatDType) -> Self {
Self {
at_least: Some(dtype),
half_needs: DTypeUsage::Arithmetic,
}
}
pub fn floor(&self) -> Option<FloatDType> {
self.at_least
}
pub fn resolve(
&self,
stored: FloatDType,
device: &Device,
accepts: impl Fn(FloatDType) -> bool,
) -> BunsenResult<FloatDType> {
let candidates = [stored, FloatDType::F32, FloatDType::F64];
let floor = self.at_least.map_or(0, float_width);
let mut tried = Vec::new();
for dtype in candidates {
if float_width(dtype) < floor || tried.contains(&dtype) {
continue;
}
tried.push(dtype);
if self.device_allows(dtype, device) && accepts(dtype) {
return Ok(dtype);
}
}
Err(BunsenError::unsupported(format!(
"no dtype to load {stored:?} into on {device:?} under {self:?}: tried {tried:?}"
)))
}
pub fn place<M: Module>(
&self,
module: M,
device: &Device,
accepts: impl Fn(FloatDType) -> bool,
) -> BunsenResult<M> {
let Some(stored) = module_float_dtype(&module) else {
return Ok(module);
};
let dtype = self.resolve(stored, device, accepts)?;
Ok(if dtype == stored {
module
} else {
module.map(&mut DTypeMapper::new(dtype.into()))
})
}
fn device_allows(
&self,
dtype: FloatDType,
device: &Device,
) -> bool {
let needs = if float_width(dtype) == 16 {
self.half_needs
} else {
DTypeUsage::Arithmetic
};
let usage = dtype_usage(device, dtype);
usage.contains(needs) && usage.contains(DTypeUsage::Arithmetic)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::support::testing::cpu_device;
fn any(_: FloatDType) -> bool {
true
}
#[test]
fn test_resolve_on_the_cpu() {
let device = cpu_device();
let bf16 = FloatDType::BF16;
assert_eq!(
LoadPolicy::performance()
.resolve(bf16, &device, any)
.unwrap(),
FloatDType::F32
);
assert_eq!(
LoadPolicy::load_as_stored()
.resolve(bf16, &device, any)
.unwrap(),
bf16
);
assert_eq!(
LoadPolicy::at_least(FloatDType::F32)
.resolve(bf16, &device, any)
.unwrap(),
FloatDType::F32
);
assert_eq!(
LoadPolicy::at_least(FloatDType::F64)
.resolve(bf16, &device, any)
.unwrap(),
FloatDType::F64
);
assert_eq!(
LoadPolicy::load_as_stored()
.resolve(FloatDType::F32, &device, any)
.unwrap(),
FloatDType::F32
);
}
#[test]
fn test_resolve_under_the_hook() {
let device = cpu_device();
let no_bf16 = |d: FloatDType| d != FloatDType::BF16;
assert_eq!(
LoadPolicy::load_as_stored()
.resolve(FloatDType::BF16, &device, no_bf16)
.unwrap(),
FloatDType::F32
);
let only_f16 = |d: FloatDType| d == FloatDType::F16;
assert!(
LoadPolicy::load_as_stored()
.resolve(FloatDType::BF16, &device, only_f16)
.is_err()
);
assert_eq!(
LoadPolicy::load_as_stored()
.resolve(FloatDType::F16, &device, only_f16)
.unwrap(),
FloatDType::F16
);
}
#[test]
fn test_place() {
use burn::nn::LinearConfig;
let device = cpu_device();
let half = LinearConfig::new(2, 2)
.init(&device)
.map(&mut DTypeMapper::new(FloatDType::BF16.into()));
let kept = LoadPolicy::load_as_stored()
.place(half.clone(), &device, any)
.unwrap();
assert_eq!(module_float_dtype(&kept), Some(FloatDType::BF16));
let widened = LoadPolicy::performance().place(half, &device, any).unwrap();
assert_eq!(module_float_dtype(&widened), Some(FloatDType::F32));
}
#[test]
fn test_resolve_on_the_accelerator() {
let device = crate::support::testing::performance_device();
if format!("{device:?}").contains("Flex") {
return;
}
let bf16 = FloatDType::BF16;
let got = LoadPolicy::performance()
.resolve(bf16, &device, any)
.unwrap();
let accelerated = dtype_usage(&device, bf16).contains(DTypeUsage::Accelerated);
assert_eq!(got == bf16, accelerated, "{device:?}: {got:?}");
}
}