Method preprocess_linear_weight

cake-core/src/backends/vulkan/mod.rs:1345–1380

(&self, weight: &Tensor)

    }

    fn preprocess_linear_weight(&self, weight: &Tensor) -> Result<Tensor> {
        // Pre-upload F32 version to GPU cache (tensor_matmul will find it via get_or_upload).
        // Return original dtype weight so linear_forward's x.matmul(&w) has matching dtypes.
        let w = weight.to_dtype(DType::F32)?.contiguous()?;
        let _ = self.get_or_upload(&w)?;

        // Also pre-upload the TRANSPOSED F16 data for GEMV (halves bandwidth).
        if weight.dtype() == DType::F16 {
            let wt_f16 = weight.t()?.contiguous()?;
            let f16_data: Vec<f32> = wt_f16.to_dtype(DType::F32)?.flatten_all()?.to_vec1()?;
            let n = wt_f16.elem_count();
            let f16_vals: Vec<half::f16> = f16_data.iter().map(|&v| half::f16::from_f32(v)).collect();
            let f16_bytes: &[u8] = bytemuck::cast_slice(&f16_vals);
            let buf_bytes = (f16_bytes.len()) as u64;
            let mut alloc_guard = self.allocator.lock().unwrap();
            let alloc = alloc_guard.as_mut().unwrap();
            let buf = Self::alloc_mapped_buffer(
                &self.vk_device, alloc, buf_bytes,
                vk::BufferUsageFlags::STORAGE_BUFFER, self.uma_memory_type,
            ).map_err(candle_core::Error::Msg)?;
            unsafe {
                std::ptr::copy_nonoverlapping(f16_bytes.as_ptr(), buf.mapped_ptr, f16_bytes.len());
            }
            let wt_f32 = w.t()?;
            if let Some(key) = Self::view_key(&wt_f32) {
                let mut cache = self.weight_cache.lock().unwrap();
                cache.f16_views.insert(key, Arc::new(buf));
                log::debug!("pre-uploaded F16 GEMV weight: {} elements", n);
            }
            drop(alloc_guard);
        }

        // Return original dtype — don't break linear_forward's dtype assumptions
        let w_orig = if weight.is_contiguous() { weight.clone() } else { weight.contiguous()? };
        Ok(w_orig)
    }

    fn matmul(&self, a: &Tensor, b: &Tensor) -> Result<Tensor> {
        let a_dims = a.dims();