qualia_core_db/specialized_libs/qpu_bridge/
job.rs1use crate::lexicon::generate_60bit_token;
14use core::ptr;
15
16use super::*;
21
22#[repr(C)]
23pub struct QPUJobManager {
24 pub(crate) active_jobs: [QPUJob; 64],
26 pub(crate) completed_jobs: [QPUJob; 64],
28 pub(crate) job_counters: QPUJobCounters,
30 pub(crate) submission_state: QPUSubmissionState,
32}
33
34#[repr(C)]
35#[derive(Clone, Copy)]
36pub struct QPUJob {
37 pub(crate) job_id: [u8; 64],
39 pub(crate) job_type: QPUJobType,
41 pub(crate) priority: QPUJobPriority,
43 pub(crate) submitted_at: u64,
45 pub(crate) expected_completion: u64,
47 pub(crate) status: QPUJobStatus,
49 pub(crate) result_data: *const u8,
51 pub(crate) result_size: usize,
53}
54
55#[repr(u8)]
56#[derive(Clone, Copy, PartialEq)]
57pub enum QPUJobType {
58 HamiltonianMapping = 0,
59 QuantumStatePreparation = 1,
60 QuantumMeasurement = 2,
61 QuantumCircuitExecution = 3,
62 VariationalQuantumEigensolver = 4,
63 QuantumApproximateOptimization = 5,
64}
65
66#[repr(u8)]
67#[derive(Clone, Copy, PartialEq)]
68pub enum QPUJobPriority {
69 Low = 0,
70 Normal = 1,
71 High = 2,
72 Critical = 3,
73}
74
75#[repr(u8)]
76#[derive(Clone, Copy, PartialEq)]
77pub enum QPUJobStatus {
78 Queued = 0,
79 Running = 1,
80 Completed = 2,
81 Failed = 3,
82 Cancelled = 4,
83 Timeout = 5,
84}
85
86#[repr(C)]
87#[derive(Clone, Copy)]
88pub struct QPUJobCounters {
89 pub(crate) total_submitted: u64,
91 pub(crate) total_completed: u64,
93 pub(crate) total_failed: u64,
95 pub(crate) running_jobs: u32,
97 pub(crate) avg_completion_time_us: u32,
99}
100
101#[repr(u8)]
102#[derive(Clone, Copy, PartialEq)]
103pub enum QPUSubmissionState {
104 Idle = 0,
105 Submitting = 1,
106 Waiting = 2,
107 Retrieving = 3,
108}
109
110#[repr(C)]
111pub struct QPURateLimiter {
112 pub(crate) jobs_per_second: u32,
114 pub(crate) current_jobs: u32,
116 pub(crate) window_start: u64,
118 pub(crate) window_duration: u32,
120 pub(crate) quota_remaining: u32,
122}
123
124#[repr(C)]
125pub struct QPUJobSubmissionParams {
126 pub(crate) job_type: QPUJobType,
128 pub(crate) priority: QPUJobPriority,
130 pub(crate) input_data: *const u8,
132 pub(crate) input_size: usize,
134 pub(crate) expected_output_size: usize,
136 pub(crate) timeout: u32,
138}
139
140#[repr(C)]
141pub struct QPUJobResult {
142 pub(crate) job_id: [u8; 64],
144 pub(crate) success: bool,
146 pub(crate) result_data: *const u8,
148 pub(crate) result_size: usize,
150 pub(crate) execution_time_us: u64,
152 pub(crate) quantum_volume: u32,
154 pub(crate) error_code: QPUErrorCode,
156}
157
158impl QPUJobManager {
159 #[inline(always)]
160 pub const fn default() -> Self {
162 Self {
163 active_jobs: [QPUJob::default(); 64],
164 completed_jobs: [QPUJob::default(); 64],
165 job_counters: QPUJobCounters::default(),
166 submission_state: QPUSubmissionState::Idle,
167 }
168 }
169
170 pub fn allocate_job_slot(&mut self) -> Result<[u8; 64], QPUBridgeError> {
172 for i in 0..64 {
174 if self.active_jobs[i].job_id[0] == 0 {
175 let job_id = self.generate_job_id(i);
177 return Ok(job_id);
178 }
179 }
180 Err(QPUBridgeError::QueueFull)
181 }
182
183 pub fn release_job_slot(&mut self, job_id: [u8; 64]) {
185 for i in 0..64 {
187 if self.active_jobs[i].job_id == job_id {
188 self.active_jobs[i] = QPUJob::default();
189 break;
190 }
191 }
192 }
193
194 pub fn add_active_job(&mut self, job: QPUJob) {
196 for i in 0..64 {
198 if self.active_jobs[i].job_id == job.job_id {
199 self.active_jobs[i] = job;
200 self.job_counters.running_jobs += 1;
201 break;
202 }
203 }
204 }
205
206 pub fn find_active_job(&self, job_id: &[u8; 64]) -> Result<usize, QPUBridgeError> {
208 for i in 0..64 {
209 if self.active_jobs[i].job_id == *job_id {
210 return Ok(i);
211 }
212 }
213 Err(QPUBridgeError::JobNotFound)
214 }
215
216 pub fn move_to_completed(&mut self, active_index: usize) {
218 let job = self.active_jobs[active_index];
220
221 for i in 0..64 {
223 if self.completed_jobs[i].job_id[0] == 0 {
224 self.completed_jobs[i] = job;
225 break;
226 }
227 }
228
229 self.active_jobs[active_index] = QPUJob::default();
231 self.job_counters.running_jobs -= 1;
232 }
233
234 fn generate_job_id(&self, slot_index: usize) -> [u8; 64] {
235 let mut job_id = [0u8; 64];
236
237 let timestamp: u64 = 0; let hash = generate_60bit_token(×tamp.to_le_bytes()) as u64;
240
241 for i in 0..8 {
243 job_id[i] = (hash >> (i * 8)) as u8;
244 }
245
246 job_id[8] = slot_index as u8;
248
249 job_id
250 }
251}
252
253impl QPUJob {
254 #[inline(always)]
255 pub const fn default() -> Self {
257 Self {
258 job_id: [0u8; 64],
259 job_type: QPUJobType::HamiltonianMapping,
260 priority: QPUJobPriority::Normal,
261 submitted_at: 0,
262 expected_completion: 0,
263 status: QPUJobStatus::Queued,
264 result_data: ptr::null(),
265 result_size: 0,
266 }
267 }
268}
269
270impl QPUJobCounters {
271 #[inline(always)]
272 pub const fn default() -> Self {
274 Self {
275 total_submitted: 0,
276 total_completed: 0,
277 total_failed: 0,
278 running_jobs: 0,
279 avg_completion_time_us: 0,
280 }
281 }
282}
283
284impl QPURateLimiter {
285 #[inline(always)]
286 pub const fn default() -> Self {
288 Self {
289 jobs_per_second: 10,
290 current_jobs: 0,
291 window_start: 0,
292 window_duration: 1,
293 quota_remaining: 1000,
294 }
295 }
296
297 pub fn can_submit_job(&mut self, current_time: u64) -> bool {
299 if current_time - self.window_start > (self.window_duration as u64 * 1_000_000) {
301 self.window_start = current_time;
303 self.current_jobs = 0;
304 }
305
306 self.current_jobs < self.jobs_per_second && self.quota_remaining > 0
308 }
309
310 pub fn record_job_submission(&mut self, _current_time: u64) {
312 self.current_jobs += 1;
313 self.quota_remaining -= 1;
314 }
315}