Propagate invalid matrix layout errors in production paths

diskann-benchmark-core/src/search/api.rs

@@ -517,7 +517,7 @@ where
     T: Search,
 {
     let mut lengths = Vec::with_capacity(range.len());
-    let mut ids = Matrix::new(views::Init(T::Id::default), range.len(), num_ids.into());
+    let mut ids = Matrix::try_new(views::Init(T::Id::default), range.len(), num_ids.into())?;
 
     let mut latencies = Vec::<MicroSeconds>::with_capacity(range.len());
     let mut outputs = Vec::<T::Output>::with_capacity(range.len());

diskann-benchmark/src/exhaustive/minmax.rs

@@ -389,7 +389,7 @@ mod imp {
             // The APIs below should correctly handle these variables.
             let output_dim = quantizer.output_dim();
             let bytes = Data::<NBITS>::canonical_bytes(output_dim);
-            let mut data = diskann_utils::views::Matrix::new(0, input.nrows(), bytes);
+            let mut data = diskann_utils::views::Matrix::try_new(0, input.nrows(), bytes)?;
 
             // Compress the data.
             //

diskann-benchmark/src/exhaustive/product.rs

@@ -332,8 +332,11 @@ mod imp {
             quantizer: diskann_providers::model::pq::FixedChunkPQTable,
             progress: &ProgressBar,
         ) -> anyhow::Result<Self> {
-            let mut data =
-                diskann_utils::views::Matrix::new(0, input.nrows(), quantizer.get_num_chunks());
+            let mut data = diskann_utils::views::Matrix::try_new(
+                0,
+                input.nrows(),
+                quantizer.get_num_chunks(),
+            )?;
 
             // Compress the data.
             #[expect(clippy::disallowed_methods)]

diskann-benchmark/src/exhaustive/spherical.rs

@@ -416,7 +416,7 @@ mod imp {
             let output_dim = plan.quantizer().output_dim();
             let bytes =
                 diskann_quantization::spherical::DataRef::<NBITS>::canonical_bytes(output_dim);
-            let mut data = diskann_utils::views::Matrix::new(0, input.nrows(), bytes);
+            let mut data = diskann_utils::views::Matrix::try_new(0, input.nrows(), bytes)?;
 
             // Compress the data.
             #[expect(clippy::disallowed_methods)]

diskann-benchmark/src/utils/datafiles.rs

@@ -71,21 +71,21 @@ impl ConvertingLoad for f32 {
     ))]
     fn converting_load(path: BinFile<'_>, data_type: DataType) -> anyhow::Result<Matrix<f32>> {
         #[inline(never)]
-        fn convert<T, U>(from: diskann_utils::views::MatrixView<T>) -> Matrix<U>
+        fn convert<T, U>(from: diskann_utils::views::MatrixView<T>) -> anyhow::Result<Matrix<U>>
         where
             U: Default + Clone + From<T>,
             T: Copy,
         {
-            let mut to = Matrix::new(U::default(), from.nrows(), from.ncols());
+            let mut to = Matrix::try_new(U::default(), from.nrows(), from.ncols())?;
             std::iter::zip(to.as_mut_slice().iter_mut(), from.as_slice().iter())
                 .for_each(|(t, f)| *t = (*f).into());
-            to
+            Ok(to)
         }
         match data_type {
             DataType::Float32 => load_dataset::<f32>(path),
-            DataType::Float16 => Ok(convert(load_dataset::<half::f16>(path)?.as_view())),
-            DataType::UInt8 => Ok(convert(load_dataset::<u8>(path)?.as_view())),
-            DataType::Int8 => Ok(convert(load_dataset::<i8>(path)?.as_view())),
+            DataType::Float16 => convert(load_dataset::<half::f16>(path)?.as_view()),
+            DataType::UInt8 => convert(load_dataset::<u8>(path)?.as_view()),
+            DataType::Int8 => convert(load_dataset::<i8>(path)?.as_view()),
             _ => Err(anyhow::anyhow!(
                 "data type {:?} is not supported for loading `f32` data",
                 data_type

diskann-disk/src/search/provider/disk_provider.rs

@@ -555,7 +555,7 @@ where
 
         ensure_vertex_loaded(&mut accessor.scratch.vertex_provider, &candidate_ids)?;
 
-        let mut candidate_vectors = Matrix::new(0.0f32, candidate_ids.len(), query_f32.len());
+        let mut candidate_vectors = Matrix::try_new(0.0f32, candidate_ids.len(), query_f32.len())?;
         let mut candidate_distances = Vec::with_capacity(candidate_ids.len());
         let mut associated_data = Vec::with_capacity(candidate_ids.len());
 

diskann-providers/src/model/graph/provider/async_/inmem/full_precision.rs

@@ -434,7 +434,10 @@ where
         let candidates: Vec<Neighbor<A::Id>> = candidates.collect();
         let candidate_count = candidates.len();
         let store: &FullPrecisionStore<f32> = accessor.as_full_precision();
-        let mut vectors = Matrix::new(0.0f32, candidate_count, query.len());
+        let mut vectors = match Matrix::try_new(0.0f32, candidate_count, query.len()) {
+            Ok(vectors) => vectors,
+            Err(error) => return std::future::ready(Err(error.into())),
+        };
         let mut ids = Vec::with_capacity(candidate_count);
         let mut distances = Vec::with_capacity(candidate_count);
 

diskann-quantization/src/product/train.rs

@@ -169,7 +169,15 @@ impl TrainQuantizer for LightPQTrainingParameters {
                 // Allocate scratch data structures.
                 let norms: Vec<f32> = view.rows().map(square_norm).collect();
                 let transpose = BlockTransposed::<f32, 16>::from_strided(view);
-                let mut centers = Matrix::new(0.0, trainer.ncenters, range.len());
+                let mut centers =
+                    Matrix::try_new(0.0, trainer.ncenters, range.len()).map_err(|err| {
+                        PQTrainingError {
+                            chunk: i,
+                            of: schema.len(),
+                            dim: range.len(),
+                            kind: PQTrainingErrorKind::InternalError(Box::new(err)),
+                        }
+                    })?;
 
                 // Construct the random number generator seeded by the PQ chunk.
                 let mut rng = rng_builder.build_boxed_rng(i);

diskann/src/error/ann_error.rs

@@ -262,6 +262,7 @@ convert_error!(TryFromIntError);
 convert_error!(TryFromSliceError);
 convert_error!(diskann_utils::io::ReadBinError);
 convert_error!(diskann_utils::io::SaveBinError);
+convert_error!(diskann_utils::views::LayoutError);
 convert_error!(diskann_utils::views::TryFromErrorLight);
 
 // Convert from `mpsc::SendError` to `ANNError`

diskann/src/graph/start_point.rs

@@ -67,6 +67,9 @@ pub enum StartPointError {
 
     #[error("Error getting row_id {} from training data matrix view", row_id)]
     MatrixRowError { row_id: usize },
+
+    #[error(transparent)]
+    MatrixLayout(#[from] diskann_utils::views::LayoutError),
 }
 
 impl StartPointStrategy {
@@ -98,7 +101,7 @@ impl StartPointStrategy {
                 let indices =
                     rand::seq::index::sample(&mut rng, train_data.nrows(), nsamples.get());
 
-                let mut points = Matrix::new(T::default(), nsamples.get(), train_data.ncols());
+                let mut points = Matrix::try_new(T::default(), nsamples.get(), train_data.ncols())?;
                 std::iter::zip(points.row_iter_mut(), indices).for_each(|(dst, src)| {
                     dst.copy_from_slice(train_data.row(src));
                 });
@@ -115,7 +118,7 @@ impl StartPointStrategy {
             } => {
                 let mut rng = StdRng::seed_from_u64(*seed);
                 let dim = train_data.ncols();
-                let mut points = Matrix::new(T::default(), nsamples.get(), dim);
+                let mut points = Matrix::try_new(T::default(), nsamples.get(), dim)?;
                 points.row_iter_mut().for_each(|row| {
                     row.copy_from_slice(&WithApproximateNorm::with_approximate_norm(
                         dim, *norm, &mut rng,