oarust 0.8.6

GPU-first semantic computing engine written in Rust
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::{Audio, Error, Image, Matrix, OpAttribute, OperationContract, Result};

use super::shader::KernelId;

/// Borrowed semantic inputs and outputs for one executable lowering.
pub(crate) struct SemanticDispatch<'a> {
	pub(crate) contract: OperationContract,
	pub(crate) inputs: &'a [&'a Matrix],
	pub(crate) outputs: &'a [&'a Matrix],
	pub(crate) attributes: &'a [OpAttribute],
}

/// Borrowed semantic values for a contract with explicitly absent inputs.
pub(crate) struct OptionalSemanticDispatch<'a> {
	pub(crate) contract: OperationContract,
	pub(crate) inputs: &'a [Option<&'a Matrix>],
	pub(crate) outputs: &'a [&'a Matrix],
	pub(crate) attributes: &'a [OpAttribute],
}

impl OptionalSemanticDispatch<'_> {
	pub(crate) fn validate_kernel(&self, kernel: KernelId) -> Result<()> {
		let registered = kernel.semantic_contract().ok_or_else(|| {
			Error::internal(format!(
				"lowering-only kernel {} cannot record a direct semantic operation",
				kernel.report_name()
			))
		})?;
		if registered.name() != self.contract.name() || registered.hash() != self.contract.hash() {
			return Err(Error::internal(format!(
				"kernel {} is registered for {}, not {}",
				kernel.report_name(),
				registered.name(),
				self.contract.name()
			)));
		}
		Ok(())
	}
}

impl SemanticDispatch<'_> {
	pub(crate) fn validate_kernel(&self, kernel: KernelId) -> Result<()> {
		let registered = kernel.semantic_contract().ok_or_else(|| {
			Error::internal(format!(
				"lowering-only kernel {} cannot record a direct semantic operation",
				kernel.report_name()
			))
		})?;
		if registered.name() != self.contract.name() || registered.hash() != self.contract.hash() {
			return Err(Error::internal(format!(
				"kernel {} is registered for {}, not {}",
				kernel.report_name(),
				registered.name(),
				self.contract.name()
			)));
		}
		Ok(())
	}
}

/// Semantic output whose public value kind can differ from its Audio input.
pub(crate) enum AudioSemanticOutput<'a> {
	Audio(&'a Audio),
	Matrix(&'a Matrix),
}

/// Borrowed Audio-valued semantic operation for one or more executable nodes.
pub(crate) struct AudioSemanticDispatch<'a> {
	pub(crate) contract: OperationContract,
	pub(crate) inputs: &'a [&'a Audio],
	pub(crate) outputs: &'a [AudioSemanticOutput<'a>],
	pub(crate) attributes: &'a [OpAttribute],
}

impl AudioSemanticDispatch<'_> {
	pub(crate) fn validate_kernel(&self, kernel: KernelId) -> Result<()> {
		let registered = kernel.semantic_contract().ok_or_else(|| {
			Error::internal(format!(
				"lowering-only kernel {} cannot record a direct Audio operation",
				kernel.report_name()
			))
		})?;
		if registered.name() != self.contract.name() || registered.hash() != self.contract.hash() {
			return Err(Error::internal(format!(
				"kernel {} is registered for {}, not {}",
				kernel.report_name(),
				registered.name(),
				self.contract.name()
			)));
		}
		Ok(())
	}
}

/// Semantic input accepted by an Image operation.
///
/// Spatial transforms keep pixels as an [`Image`] while maps and transform
/// coefficients remain ordinary [`Matrix`] values in the semantic graph.
pub(crate) enum ImageSemanticInput<'a> {
	Image(&'a Image),
	Matrix(&'a Matrix),
}

/// Borrowed Image-valued semantic operation for one executable lowering.
pub(crate) struct ImageSemanticDispatch<'a> {
	pub(crate) contract: OperationContract,
	pub(crate) inputs: &'a [ImageSemanticInput<'a>],
	pub(crate) outputs: &'a [&'a Image],
	pub(crate) attributes: &'a [OpAttribute],
}

impl ImageSemanticDispatch<'_> {
	pub(crate) fn validate_kernel(&self, kernel: KernelId) -> Result<()> {
		let registered = kernel.semantic_contract().ok_or_else(|| {
			Error::internal(format!(
				"lowering-only kernel {} cannot record a direct Image operation",
				kernel.report_name()
			))
		})?;
		if registered.name() != self.contract.name() || registered.hash() != self.contract.hash() {
			return Err(Error::internal(format!(
				"kernel {} is registered for {}, not {}",
				kernel.report_name(),
				registered.name(),
				self.contract.name()
			)));
		}
		Ok(())
	}
}