Struct TaskWorkItem 

#[repr(C)]
pub struct TaskWorkItem {

    pub state: u32,
    pub op_handle: u32,
    pub tenant_id: u32,
    pub priority: u32,
    pub input_handle: u32,
    pub output_handle: u32,
    pub param: u32,
    pub continuation_pc: u32,
    pub continuation_data: u32,
    pub resume_epoch: u32,
    pub task_id: u32,
    pub parent_task_id: u32,
    pub age_ticks: u32,
    pub requeue_count: u32,
    pub yield_count: u32,
    pub flags: u32,
}

One device-visible continuation task slot.

The first four words match the persistent ring header: status, opcode, tenant, priority. The remaining twelve words are the slot payload. Words 4..6 preserve the legacy MegakernelWorkItem payload; words 7..15 carry continuation and scheduler state.

Fields

state: u32

Raw TaskState word.

op_handle: u32

Stable op id index into the dialect registry.

tenant_id: u32

Tenant id checked by the runtime scheduler.

priority: u32

Raw TaskPriority word.

input_handle: u32

Input-buffer handle.

output_handle: u32

Output-buffer handle.

param: u32

Per-item parameter word.

continuation_pc: u32

Program counter or block id where the worker should resume.

continuation_data: u32

Opaque continuation-local scratch word.

resume_epoch: u32

Device-visible epoch at which the task may resume.

task_id: u32

Stable task id used to join yielded/requeued continuations.

parent_task_id: u32

Parent task id for split or fan-out work; zero when absent.

age_ticks: u32

Scheduler age ticks accumulated while waiting.

requeue_count: u32

Number of times this task has been requeued.

yield_count: u32

Number of times this task has yielded.

flags: u32

Bitset of TASK_FLAG_* continuation flags.

Implementations

impl TaskWorkItem

pub const fn from_work_item( task_id: u32, tenant_id: u32, priority: TaskPriority, item: MegakernelWorkItem, ) -> Self

Construct a ready continuation task from the compact legacy work item.

pub const fn work_item(&self) -> MegakernelWorkItem

Return the compact legacy work item payload carried by this task.

pub const fn task_state(&self) -> Option<TaskState>

Decode the task state word.

pub const fn task_priority(&self) -> Option<TaskPriority>

Decode the task priority word.

pub const fn is_schedulable(&self) -> bool

Return true when the task is eligible to be claimed by a worker.

pub const fn paused( self, continuation_pc: u32, continuation_data: u32, resume_epoch: u32, ) -> Self

Encode a pause at continuation_pc until resume_epoch.

pub const fn resumed(self) -> Self

Mark a paused task ready for GPU-side resume.

pub const fn yielded(self, continuation_pc: u32, continuation_data: u32) -> Self

Yield this task back to the scheduler at continuation_pc.

pub const fn requeued( self, continuation_pc: u32, continuation_data: u32, priority: TaskPriority, ) -> Self

Requeue this task, optionally changing its priority partition.

pub const fn completed(self) -> Self

Mark this task completed.

pub const fn faulted(self, fault_code: u32) -> Self

Mark this task faulted with a compact fault code.

Trait Implementations

impl Clone for TaskWorkItem

fn clone(&self) -> TaskWorkItem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for TaskWorkItem

impl Debug for TaskWorkItem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for TaskWorkItem

impl PartialEq for TaskWorkItem

fn eq(&self, other: &TaskWorkItem) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Pod for TaskWorkItem

impl StructuralPartialEq for TaskWorkItem

impl Zeroable for TaskWorkItem

fn zeroed() -> Self

Calls zeroed.