DType 与 Device

#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum DType {
    // Unsigned 8 bits integer.
    U8,
    // Unsigned 32 bits integer.
    U32,
    // Signed 16 bits integer.
    I16,
    // Signed 32 bits integer.
    I32,
    // Signed 64 bits integer.
    I64,
    // Brain floating-point using half precision (16 bits).
    BF16,
    // Floating-point using half precision (16 bits).
    F16,
    // Floating-point using single precision (32 bits).
    F32,
    // Floating-point using double precision (64 bits).
    F64,
    // 8-bit floating point with 4-bit exponent and 3-bit mantissa.
    F8E4M3,
    /// 6-bit float with 2 exponent bits and 3 mantissa bits (MX6 format)
    F6E2M3,
    /// 6-bit float with 3 exponent bits and 2 mantissa bits (MX6 format)
    F6E3M2,
    /// 4-bit float (MX4 format)
    F4,
    /// 8-bit float with 8 exponent bits and 0 mantissa bits
    F8E8M0,
}

F6E2M3 size_in_bytes=0 zeros=Err("unsupported dtype F6E2M3 for op zeros") add=Err("unsupported dtype F6E2M3 for op zeros") to_f32=Err("unsupported dtype F6E2M3 for op zeros") from_f32=Err("unsupported dtype F6E2M3 for op to_dtype")
...
F8E8M0 size_in_bytes=1 zeros=Err("unsupported dtype F8E8M0 for op zeros") add=Err("unsupported dtype F8E8M0 for op zeros") to_f32=Err("unsupported dtype F8E8M0 for op zeros") from_f32=Err("unsupported dtype F8E8M0 for op to_dtype")

"bf16".parse() = Ok(BF16), "float".parse() = Err("cannot parse 'float' as a dtype")

pub trait WithDType:
    Sized
    + Copy
    + num_traits::NumAssign
    + std::cmp::PartialOrd
    + std::fmt::Display
    + 'static
    + Send
    + Sync
    + std::any::Any
    + crate::cpu::kernels::VecOps
{
    const DTYPE: DType;

    fn from_f64(v: f64) -> Self;
    fn to_f64(self) -> f64;
    fn to_scalar(self) -> crate::scalar::Scalar;
    fn cpu_storage_ref(data: &[Self]) -> CpuStorageRef<'_>;
    fn to_cpu_storage_owned(data: Vec<Self>) -> CpuStorage;
    // ...
    fn cpu_storage_as_slice(s: &CpuStorage) -> Result<&[Self]>;
    fn cpu_storage_data(s: CpuStorage) -> Result<Vec<Self>>;
}

to_vec2::<f64> on f32: unexpected dtype, expected: F64, got: F32

/// A `DeviceLocation` represents a physical device whereas multiple `Device`
/// can live on the same location (typically for cuda devices).
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum DeviceLocation {
    Cpu,
    Cuda { gpu_id: usize },
    Metal { gpu_id: usize },
}

/// Cpu, Cuda, or Metal
#[derive(Debug, Clone)]
pub enum Device {
    Cpu,
    Cuda(crate::CudaDevice),
    Metal(crate::MetalDevice),
}

metal == metal2? same_device=false location Metal { gpu_id: 4294968354 } Metal { gpu_id: 4294968354 }

        let same_device = if self.device().is_metal() {
            // On metal, we require the device to be exactly the same rather than
            // having the same location. In cuda this is not necessary as all CudaDevice on the
            // same GPU will use the same cuda stream.
            lhs_device.same_device(&rhs_device)
        } else {
            lhs == rhs
        };

thread 'main' (3704777) panicked at /rustc/b940084d7eb6a299eb4bfeb8e34901bc051e7ac4/library/alloc/src/vec/mod.rs:2258:13:
swap_remove index (is 1) should be < len (is 1)

            let storage = match (&*self.storage(), device) {
                (Storage::Cpu(storage), Device::Cuda(cuda)) => {
                    Storage::Cuda(cuda.storage_from_cpu_storage(storage)?)
                }
                (Storage::Cpu(storage), Device::Metal(metal)) => {
                    Storage::Metal(metal.storage_from_cpu_storage(storage)?)
                }
                (Storage::Cuda(storage), Device::Cpu) => Storage::Cpu(storage.to_cpu_storage()?),
                (Storage::Metal(storage), Device::Cpu) => Storage::Cpu(storage.to_cpu_storage()?),
                (Storage::Cuda(storage), Device::Cuda(cuda)) => {
                    // can't clone storage if it's the same device because of the underlying device ptr
                    let dst_storage = storage.transfer_to_device(cuda)?;
                    Storage::Cuda(dst_storage)
                }
                (Storage::Cpu(storage), Device::Cpu) => Storage::Cpu(storage.clone()),
                _ => {
                    bail!(
                        "not implemented yet, self.device: {:?}, device: {:?}",
                        self.device(),
                        device
                    )
                }
            };

f32 + f16: dtype mismatch in add, lhs: F32, rhs: F16
f32.matmul(f16): dtype mismatch in matmul, lhs: F32, rhs: F16
cpu + metal: device mismatch in add, lhs: Cpu, rhs: Metal { gpu_id: 4294968354 }
cpu.matmul(metal): device mismatch in matmul, lhs: Cpu, rhs: Metal { gpu_id: 4294968354 }
index_select f32 ids: unsupported dtype F32 for op index-select
scalar add a + 1.0: [[2.0, 2.0], [2.0, 2.0]]

U8: ... exp=PANIC(not yet implemented: no unary function for u8) ...

metal + metal2: device mismatch in add, lhs: Metal { gpu_id: 4294968354 }, rhs: Metal { gpu_id: 4294968354 }