use crate::{
DType, Error, Matrix, OpAttribute, Result,
runtime::{BufferBinding, ComputeDispatch, KernelId, PushConstant, SemanticDispatch},
};
#[derive(Clone)]
pub struct BarrettParameters {
encoded: Matrix,
status: Matrix,
words: usize,
}
impl BarrettParameters {
pub const fn words(&self) -> usize {
self.words
}
pub const fn status(&self) -> &Matrix {
&self.status
}
}
pub fn add(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::ADD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntAddU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn subtract(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::SUBTRACT;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntSubtractU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn multiply_low(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::MULTIPLY_LOW;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntMultiplyLowU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn multiply_wide(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::MULTIPLY_WIDE;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words * 2)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words * 2], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntMultiplyWideU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn bit_and(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::BIT_AND;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntBitAndU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn bit_or(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::BIT_OR;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntBitOrU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn bit_xor(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::BIT_XOR;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntBitXorU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn compare(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::COMPARE;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntCompareU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn div_rem(left: &Matrix, right: &Matrix) -> Result<(Matrix, Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::DIV_REM;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let quotient_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let quotient_bytes = quotient_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(quotient_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let quotient = Matrix::allocate_output(engine, vec![rows, words], quotient_elements, DType::U32)?;
let remainder_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let remainder_bytes = remainder_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(remainder_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let remainder =
Matrix::allocate_output(engine, vec![rows, words], remainder_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntDivRemU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(quotient.storage()),
BufferBinding::write(remainder.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = ["ient, &remainder, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((quotient, remainder, status))
}
pub fn shift_left(left: &Matrix, shift: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::SHIFT_LEFT;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32 || !(1..=128).contains(&words) {
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntShiftLeftU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(shift),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "shift".into(),
value: u64::from(shift),
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn shift_right(left: &Matrix, shift: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::SHIFT_RIGHT;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32 || !(1..=128).contains(&words) {
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntShiftRightU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(shift),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "shift".into(),
value: u64::from(shift),
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn reduce_mod(left: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::REDUCE_MOD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntReduceModU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn add_mod(left: &Matrix, right: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::ADD_MOD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntAddModU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, right, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn subtract_mod(left: &Matrix, right: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::SUBTRACT_MOD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntSubtractModU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, right, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn multiply_mod(left: &Matrix, right: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::MULTIPLY_MOD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntMultiplyModU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, right, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn square_mod(left: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::SQUARE_MOD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntSquareModU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn inverse_mod(left: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::INVERSE_MOD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntInverseModU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn pow_mod(left: &Matrix, right: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::POW_MOD;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntPowModU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, right, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn to_montgomery(left: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::TO_MONTGOMERY;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntToMontgomeryU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn from_montgomery(left: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::FROM_MONTGOMERY;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntFromMontgomeryU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn montgomery_multiply(
left: &Matrix,
right: &Matrix,
modulus: &Matrix,
) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::MONTGOMERY_MULTIPLY;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntMontgomeryMultiplyU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, right, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn barrett_multiply(
left: &Matrix,
right: &Matrix,
modulus: &Matrix,
) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::BARRETT_MULTIPLY;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
|| modulus.dtype() != DType::U32
|| modulus.shape().len() != 2
|| modulus.shape()[1] != words
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntBarrettMultiplyU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, right, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn multiply_high(left: &Matrix, right: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::MULTIPLY_HIGH;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| right.shape() != left.shape()
|| !left.engine_handle().same_as(right.engine_handle())
{
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntMultiplyHighU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left, right];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn square_wide(left: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::SQUARE_WIDE;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32 || !(1..=128).contains(&words) {
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words * 2)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words * 2], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntSquareWideU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn bit_not(left: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::BIT_NOT;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32 || !(1..=128).contains(&words) {
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntBitNotU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn leading_zeros(left: &Matrix) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::LEADING_ZEROS;
let operation = contract.name();
let [rows, words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two operands"
)));
}
};
if left.dtype() != DType::U32 || !(1..=128).contains(&words) {
return Err(Error::invalid_argument(format!(
"{operation} requires matching-owner U32 limb rows with 1..=128 words"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntLeadingZerosU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let inputs = [left];
let outputs = [&output];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn add_scalar(left: &Matrix, scalar: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::ADD_SCALAR;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = input_words;
if left.dtype() != DType::U32 || !(1..=128).contains(&input_words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntAddScalarU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(scalar),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "scalar".into(),
value: scalar as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn compare_scalar(left: &Matrix, scalar: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::COMPARE_SCALAR;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = input_words;
if left.dtype() != DType::U32 || !(1..=128).contains(&input_words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntCompareScalarU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(scalar),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "scalar".into(),
value: scalar as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn div_rem_mixed(
left: &Matrix,
right: &Matrix,
quotient_words: u32,
) -> Result<(Matrix, Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::DIV_REM_MIXED;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = match right.shape() {
[_, words] => *words,
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two divisors"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=256).contains(&input_words)
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| (right.shape()[0] != 1 && right.shape()[0] != rows)
|| !left.engine_handle().same_as(right.engine_handle())
|| !(1..=256).contains("ient_words)
{
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let quotient_elements = rows
.checked_mul(quotient_words as usize)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let quotient_bytes = quotient_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(quotient_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let quotient = Matrix::allocate_output(
engine,
vec![rows, quotient_words as usize],
quotient_elements,
DType::U32,
)?;
let remainder_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let remainder_bytes = remainder_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(remainder_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let remainder =
Matrix::allocate_output(engine, vec![rows, words], remainder_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntDivRemMixedU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(quotient.storage()),
BufferBinding::write(remainder.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(quotient_words),
PushConstant::U32(right.shape()[0] as u32),
];
let inputs = [left, right];
let outputs = ["ient, &remainder, &status];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "quotient_words".into(),
value: quotient_words as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((quotient, remainder, status))
}
pub fn div_rem_narrow(left: &Matrix, right: &Matrix) -> Result<(Matrix, Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::DIV_REM_NARROW;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = match right.shape() {
[_, words] => *words,
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two divisors"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=256).contains(&input_words)
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| (right.shape()[0] != 1 && right.shape()[0] != rows)
|| !left.engine_handle().same_as(right.engine_handle())
|| input_words != words * 2
{
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let quotient_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let quotient_bytes = quotient_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(quotient_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let quotient = Matrix::allocate_output(engine, vec![rows, words], quotient_elements, DType::U32)?;
let remainder_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let remainder_bytes = remainder_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(remainder_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let remainder =
Matrix::allocate_output(engine, vec![rows, words], remainder_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntDivRemNarrowU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(quotient.storage()),
BufferBinding::write(remainder.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(right.shape()[0] as u32),
];
let inputs = [left, right];
let outputs = ["ient, &remainder, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((quotient, remainder, status))
}
pub fn div_rem_scalar(left: &Matrix, scalar: u32) -> Result<(Matrix, Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::DIV_REM_SCALAR;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = input_words;
if left.dtype() != DType::U32 || !(1..=128).contains(&input_words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let quotient_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let quotient_bytes = quotient_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(quotient_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let quotient = Matrix::allocate_output(engine, vec![rows, words], quotient_elements, DType::U32)?;
let remainder_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let remainder_bytes = remainder_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(remainder_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let remainder = Matrix::allocate_output(engine, vec![rows], remainder_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntDivRemScalarU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(quotient.storage()),
BufferBinding::write(remainder.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(scalar),
];
let inputs = [left];
let outputs = ["ient, &remainder, &status];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "scalar".into(),
value: scalar as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((quotient, remainder, status))
}
pub fn div_rem_wide(left: &Matrix, right: &Matrix) -> Result<(Matrix, Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::DIV_REM_WIDE;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = match right.shape() {
[_, words] => *words,
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two divisors"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=256).contains(&input_words)
|| !(1..=128).contains(&words)
|| right.dtype() != DType::U32
|| (right.shape()[0] != 1 && right.shape()[0] != rows)
|| !left.engine_handle().same_as(right.engine_handle())
|| input_words != words * 2
{
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let quotient_elements = rows
.checked_mul(input_words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let quotient_bytes = quotient_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(quotient_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let quotient = Matrix::allocate_output(
engine,
vec![rows, input_words],
quotient_elements,
DType::U32,
)?;
let remainder_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let remainder_bytes = remainder_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(remainder_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let remainder =
Matrix::allocate_output(engine, vec![rows, words], remainder_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntDivRemWideU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(right.storage()),
BufferBinding::write(quotient.storage()),
BufferBinding::write(remainder.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(right.shape()[0] as u32),
];
let inputs = [left, right];
let outputs = ["ient, &remainder, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((quotient, remainder, status))
}
pub fn from_u32(left: &Matrix, output_words: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::FROM_U32;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = output_words as usize;
if left.dtype() != DType::U32 || input_words != 1 || !(1..=128).contains(&words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntFromU32U32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(output_words),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "output_words".into(),
value: output_words as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn from_u64(left: &Matrix, output_words: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::FROM_U64;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = output_words as usize;
if left.dtype() != DType::U32 || input_words != 2 || !(2..=128).contains(&words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntFromU64U32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(output_words),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "output_words".into(),
value: output_words as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn multiply_scalar(left: &Matrix, scalar: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::MULTIPLY_SCALAR;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = input_words;
if left.dtype() != DType::U32 || !(1..=128).contains(&input_words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntMultiplyScalarU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(scalar),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "scalar".into(),
value: scalar as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn reduce_montgomery(left: &Matrix, modulus: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::REDUCE_MONTGOMERY;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = match modulus.shape() {
[_, words] => *words,
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two divisors"
)));
}
};
if left.dtype() != DType::U32
|| !(1..=256).contains(&input_words)
|| !(1..=128).contains(&words)
|| modulus.dtype() != DType::U32
|| (modulus.shape()[0] != 1 && modulus.shape()[0] != rows)
|| !left.engine_handle().same_as(modulus.engine_handle())
|| input_words != words * 2
{
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntReduceMontgomeryU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(modulus.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(modulus.shape()[0] as u32),
];
let inputs = [left, modulus];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn subtract_scalar(left: &Matrix, scalar: u32) -> Result<Matrix> {
let contract = crate::core::operation::cryptography::bigint::SUBTRACT_SCALAR;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = input_words;
if left.dtype() != DType::U32 || !(1..=128).contains(&input_words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, words], output_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntSubtractScalarU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
PushConstant::U32(scalar),
];
let inputs = [left];
let outputs = [&output];
let attributes = [
OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
},
OpAttribute::UnsignedInteger {
name: "scalar".into(),
value: scalar as u64,
},
];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok(output)
}
pub fn to_u32(left: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::TO_U32;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = input_words;
if left.dtype() != DType::U32 || !(1..=128).contains(&input_words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntToU32U32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
];
let inputs = [left];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn to_u64(left: &Matrix) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::TO_U64;
let operation = contract.name();
let [rows, input_words] = match left.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(format!(
"{operation} requires rank-two U32 rows"
)));
}
};
let words = input_words;
if left.dtype() != DType::U32 || !(1..=128).contains(&input_words) {
return Err(Error::invalid_argument(format!(
"{operation} has invalid dtype, widths, shape or ownership"
)));
}
let count = u32::try_from(rows)
.map_err(|_| Error::invalid_argument(format!("{operation} batch exceeds u32")))?;
let input_bytes = rows
.checked_mul(input_words)
.and_then(|n| n.checked_mul(4))
.ok_or_else(|| {
Error::invalid_argument(format!("{operation} input byte extent overflows usize"))
})?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} input byte extent exceeds u32")))?;
let engine = left.engine_handle();
let output_elements = rows
.checked_mul(2)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let output_bytes = output_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(output_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let output = Matrix::allocate_output(engine, vec![rows, 2], output_elements, DType::U32)?;
let status_elements = rows
.checked_mul(1)
.ok_or_else(|| Error::invalid_argument(format!("{operation} output extent overflows usize")))?;
let status_bytes = status_elements.checked_mul(4).ok_or_else(|| {
Error::invalid_argument(format!("{operation} output byte extent overflows usize"))
})?;
u32::try_from(status_bytes)
.map_err(|_| Error::invalid_argument(format!("{operation} output byte extent exceeds u32")))?;
let status = Matrix::allocate_output(engine, vec![rows], status_elements, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntToU64U32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(input_words as u32),
];
let inputs = [left];
let outputs = [&output, &status];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &inputs,
outputs: &outputs,
attributes: &attributes,
},
)?;
}
Ok((output, status))
}
pub fn setup_barrett(modulus: &Matrix) -> Result<BarrettParameters> {
let contract = crate::core::operation::cryptography::bigint::SETUP_BARRETT;
let [rows, words] = match modulus.shape() {
[rows, words] => [*rows, *words],
_ => {
return Err(Error::invalid_argument(
"setup_barrett requires rank-two modulus rows",
));
}
};
if modulus.dtype() != DType::U32 || !(1..=128).contains(&words) {
return Err(Error::invalid_argument(
"setup_barrett requires U32 modulus rows with 1..=128 words",
));
}
let count =
u32::try_from(rows).map_err(|_| Error::invalid_argument("setup_barrett batch exceeds u32"))?;
let encoded_words = words * 2 + 3;
let elements = rows
.checked_mul(encoded_words)
.ok_or_else(|| Error::invalid_argument("setup_barrett extent overflows usize"))?;
let bytes = elements
.checked_mul(4)
.ok_or_else(|| Error::invalid_argument("setup_barrett bytes overflow usize"))?;
u32::try_from(bytes).map_err(|_| Error::invalid_argument("setup_barrett bytes exceed u32"))?;
let engine = modulus.engine_handle();
let encoded = Matrix::allocate_output(engine, vec![rows, encoded_words], elements, DType::U32)?;
let status = Matrix::allocate_output(engine, vec![rows], rows, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntSetupBarrettU32;
let buffers = [
BufferBinding::read(modulus.storage()),
BufferBinding::write(encoded.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [PushConstant::U32(count), PushConstant::U32(words as u32)];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &[modulus],
outputs: &[&encoded, &status],
attributes: &attributes,
},
)?;
}
Ok(BarrettParameters {
encoded,
status,
words,
})
}
pub fn reduce_barrett(left: &Matrix, parameters: &BarrettParameters) -> Result<(Matrix, Matrix)> {
let contract = crate::core::operation::cryptography::bigint::REDUCE_BARRETT;
let words = parameters.words;
let [rows, input_words] = match left.shape() {
[rows, input_words] => [*rows, *input_words],
_ => {
return Err(Error::invalid_argument(
"reduce_barrett requires rank-two double-width rows",
));
}
};
let prepared = ¶meters.encoded;
if left.dtype() != DType::U32
|| input_words != words * 2
|| (prepared.shape()[0] != 1 && prepared.shape()[0] != rows)
|| !left.engine_handle().same_as(prepared.engine_handle())
{
return Err(Error::invalid_argument(
"reduce_barrett requires matching Engine and modulus width/batch",
));
}
let count =
u32::try_from(rows).map_err(|_| Error::invalid_argument("reduce_barrett batch exceeds u32"))?;
let input_bytes = left
.num_elements()
.checked_mul(4)
.ok_or_else(|| Error::invalid_argument("reduce_barrett input bytes overflow usize"))?;
u32::try_from(input_bytes)
.map_err(|_| Error::invalid_argument("reduce_barrett input bytes exceed u32"))?;
let elements = rows
.checked_mul(words)
.ok_or_else(|| Error::invalid_argument("reduce_barrett output extent overflows usize"))?;
let engine = left.engine_handle();
let output = Matrix::allocate_output(engine, vec![rows, words], elements, DType::U32)?;
let status = Matrix::allocate_output(engine, vec![rows], rows, DType::U32)?;
if rows != 0 {
let kernel = KernelId::CryptographyBigIntReduceBarrettU32;
let buffers = [
BufferBinding::read(left.storage()),
BufferBinding::read(prepared.storage()),
BufferBinding::write(output.storage()),
BufferBinding::write(status.storage()),
];
let push_constants = [
PushConstant::U32(count),
PushConstant::U32(words as u32),
PushConstant::U32(prepared.shape()[0] as u32),
];
let attributes = [OpAttribute::UnsignedInteger {
name: "width_bits".into(),
value: (words * 32) as u64,
}];
engine.record_semantic(
ComputeDispatch {
kernel,
buffers: &buffers,
push_constants: &push_constants,
workgroups: kernel.linear_workgroups(count),
},
SemanticDispatch {
contract,
inputs: &[left, prepared],
outputs: &[&output, &status],
attributes: &attributes,
},
)?;
}
Ok((output, status))
}