use std::io::{self, Read};
use rusttorch_core::{Result, RustTorchError};
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceLimits {
pub max_encoded_bytes: usize,
pub max_decoded_bytes: usize,
pub max_tensor_elements: usize,
pub max_image_dimension: usize,
pub max_records: usize,
pub max_columns: usize,
pub max_string_bytes: usize,
pub max_tokens: usize,
pub max_columnar_bytes: usize,
pub max_media_seconds: u64,
pub max_streams: usize,
}
impl Default for ResourceLimits {
fn default() -> Self {
Self {
max_encoded_bytes: 64 * 1024 * 1024,
max_decoded_bytes: 256 * 1024 * 1024,
max_tensor_elements: 64 * 1024 * 1024,
max_image_dimension: 16_384,
max_records: 1_000_000,
max_columns: 4_096,
max_string_bytes: 1024 * 1024,
max_tokens: 1_000_000,
max_columnar_bytes: 256 * 1024 * 1024,
max_media_seconds: 3_600,
max_streams: 32,
}
}
}
impl ResourceLimits {
pub const fn unlimited() -> Self {
Self {
max_encoded_bytes: usize::MAX,
max_decoded_bytes: usize::MAX,
max_tensor_elements: usize::MAX,
max_image_dimension: usize::MAX,
max_records: usize::MAX,
max_columns: usize::MAX,
max_string_bytes: usize::MAX,
max_tokens: usize::MAX,
max_columnar_bytes: usize::MAX,
max_media_seconds: u64::MAX,
max_streams: usize::MAX,
}
}
pub fn check(&self, field: &'static str, actual: usize, maximum: usize) -> Result<()> {
if actual > maximum {
return Err(RustTorchError::InvalidConfiguration {
field,
reason: format!("{actual} exceeds resource limit {maximum}"),
});
}
Ok(())
}
pub fn tensor_elements(&self, dimensions: &[usize]) -> Result<usize> {
for &dimension in dimensions {
self.check("tensor dimension", dimension, i64::MAX as usize)?;
}
let elements = dimensions
.iter()
.try_fold(1usize, |n, &d| n.checked_mul(d))
.ok_or_else(|| RustTorchError::InvalidConfiguration {
field: "tensor elements",
reason: "shape product overflows usize".into(),
})?;
self.check(
"tensor elements",
elements,
self.max_tensor_elements.min(i64::MAX as usize),
)?;
Ok(elements)
}
pub fn read_encoded(&self, reader: impl Read) -> io::Result<Vec<u8>> {
let mut bytes = Vec::new();
reader
.take((self.max_encoded_bytes as u64).saturating_add(1))
.read_to_end(&mut bytes)?;
if bytes.len() > self.max_encoded_bytes {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"encoded resource limit exceeded",
));
}
Ok(bytes)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_oversize_inputs_and_shape_overflow() {
let limits = ResourceLimits {
max_encoded_bytes: 2,
max_tensor_elements: 8,
..Default::default()
};
assert_eq!(limits.read_encoded(&b"ab"[..]).unwrap(), b"ab");
assert!(limits.read_encoded(&b"abc"[..]).is_err());
assert!(limits.tensor_elements(&[3, 3]).is_err());
assert!(
ResourceLimits::unlimited()
.tensor_elements(&[usize::MAX, 2])
.is_err()
);
}
}