Struct GpuPartialOrderTrace 

#[repr(C, align(256))]
pub struct GpuPartialOrderTrace {

    pub trace_id: u64,
    pub case_id: u64,
    pub event_count: u32,
    pub activity_count: u32,
    pub start_time: HybridTimestamp,
    pub end_time: HybridTimestamp,
    pub max_width: u32,
    pub flags: u32,
    pub precedence_matrix: [u16; 16],
    pub activity_ids: [u32; 16],
    pub activity_start_secs: [u16; 16],
    pub activity_duration_secs: [u16; 16],
    pub _reserved: [u8; 32],
}

GPU-compatible partial order trace (256 bytes).

Contains a 16x16 bit precedence matrix representing ordering relationships.

Fields

trace_id: u64

Trace identifier.

case_id: u64

Case identifier.

event_count: u32

Number of events in the trace.

activity_count: u32

Number of unique activities.

start_time: HybridTimestamp

Start timestamp.

end_time: HybridTimestamp

End timestamp.

max_width: u32

Maximum concurrency level (width).

flags: u32

Flags: has_cycles, is_total_order, has_transitive_closure.

precedence_matrix: [u16; 16]

Precedence matrix (16x16 bits = 32 bytes). Row i bit j set means activity i precedes activity j.

activity_ids: [u32; 16]

Activity ID mapping (index -> activity ID), up to 16 activities.

activity_start_secs: [u16; 16]

Activity start times (relative to trace start, in SECONDS), up to 16 activities. Using seconds instead of ms to avoid u16 overflow for long-running activities.

activity_duration_secs: [u16; 16]

Activity durations (in SECONDS), up to 16 activities. Using seconds instead of ms to avoid u16 overflow for long-running activities.

_reserved: [u8; 32]

Reserved padding to reach 256 bytes.

Implementations

impl GpuPartialOrderTrace

pub fn new(trace_id: u64, case_id: u64) -> Self

Create a new partial order trace.

pub fn set_precedence(&mut self, i: usize, j: usize)

Set precedence: i precedes j.

pub fn precedes(&self, i: usize, j: usize) -> bool

Check if i precedes j.

pub fn is_concurrent(&self, i: usize, j: usize) -> bool

Check if i and j are concurrent (neither precedes the other).

pub fn add_activity(&mut self, activity_id: ActivityId) -> Option<usize>

Add an activity and return its index.

pub fn get_activity_index(&self, activity_id: ActivityId) -> Option<usize>

Get activity index by ID.

pub fn compute_transitive_closure(&mut self)

Compute transitive closure using Floyd-Warshall.

pub fn has_cycles(&self) -> bool

Check if has cycles (after transitive closure, if i precedes i).

pub fn is_total_order(&self) -> bool

Check if this is a total order (all pairs are ordered).

pub fn compute_width(&mut self) -> u32

Compute width (maximum antichain size = maximum concurrency).

pub fn concurrent_with(&self, activity_idx: usize) -> Vec<usize>

Get concurrent activities with given activity.

Trait Implementations

impl Archive for GpuPartialOrderTrace

where u64: Archive, u32: Archive, HybridTimestamp: Archive, [u16; 16]: Archive, [u32; 16]: Archive, [u8; 32]: Archive,

type Archived = ArchivedGpuPartialOrderTrace

The archived representation of this type.

type Resolver = GpuPartialOrderTraceResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived, )

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for GpuPartialOrderTrace

fn clone(&self) -> GpuPartialOrderTrace

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GpuPartialOrderTrace

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

Formats the value using the given formatter.

impl Default for GpuPartialOrderTrace

fn default() -> Self

Returns the “default value” for a type.

impl<__D: Fallible + ?Sized> Deserialize<GpuPartialOrderTrace, __D> for Archived<GpuPartialOrderTrace>

where u64: Archive, Archived<u64>: Deserialize<u64, __D>, u32: Archive, Archived<u32>: Deserialize<u32, __D>, HybridTimestamp: Archive, Archived<HybridTimestamp>: Deserialize<HybridTimestamp, __D>, [u16; 16]: Archive, Archived<[u16; 16]>: Deserialize<[u16; 16], __D>, [u32; 16]: Archive, Archived<[u32; 16]>: Deserialize<[u32; 16], __D>, [u8; 32]: Archive, Archived<[u8; 32]>: Deserialize<[u8; 32], __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<GpuPartialOrderTrace, __D::Error>

Deserializes using the given deserializer

impl<__S: Fallible + ?Sized> Serialize<__S> for GpuPartialOrderTrace

where u64: Serialize<__S>, u32: Serialize<__S>, HybridTimestamp: Serialize<__S>, [u16; 16]: Serialize<__S>, [u32; 16]: Serialize<__S>, [u8; 32]: Serialize<__S>,

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl Copy for GpuPartialOrderTrace