algeon-query-planning 0.1.2

Backend-neutral native query planning, proof, and admission contracts.
Documentation 
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

//! `Display` formatting for compiled pipeline IR.
//!
//! Output is diagnostic text used by triage tools. The format is not part of
//! the report contract; a tool that needs stable fields reads the report TSV
//! families, which change in place with their consumers.

use std::fmt;

use crate::pipeline::model::{
    CompiledPipeline, PipelineBarrierId, PipelineEdgeId, PipelineTaskId, ResidentLifetime, ResidentResourceId,
};

impl fmt::Display for PipelineTaskId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "t{}", self.index())
    }
}

impl fmt::Display for PipelineEdgeId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "e{}", self.index())
    }
}

impl fmt::Display for PipelineBarrierId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "b{}", self.index())
    }
}

impl fmt::Display for ResidentResourceId {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "r{}", self.index())
    }
}

impl fmt::Display for ResidentLifetime {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::TaskLocal { task } => write!(f, "task_local({task})"),
            Self::BetweenTasks { producer } => {
                write!(f, "between_tasks(producer={producer},release=after_all_consumers)")
            },
            Self::SinkOutput { producer } => write!(f, "sink_output(producer={producer})"),
        }
    }
}

impl fmt::Display for CompiledPipeline {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(f, "CompiledPipeline")?;
        writeln!(f, "  tasks:")?;
        for task in self.tasks() {
            let node = task.plan_node().map_or_else(|| "none".to_string(), |node| node.to_string());
            writeln!(
                f,
                "    {} kind={} node={} inputs={} outputs={}",
                task.id(),
                task.kind().as_str(),
                node,
                format_ids(task.input_resources()),
                format_ids(task.output_resources())
            )?;
        }

        writeln!(f, "  edges:")?;
        for edge in self.edges() {
            writeln!(
                f,
                "    {} {} -> {} kind={} resources={}",
                edge.id(),
                edge.from(),
                edge.to(),
                edge.kind().as_str(),
                format_ids(edge.resources())
            )?;
        }

        writeln!(f, "  barriers:")?;
        for barrier in self.barriers() {
            writeln!(
                f,
                "    {} kind={} upstream={} downstream={}",
                barrier.id(),
                barrier.kind().as_str(),
                format_ids(barrier.upstream_tasks()),
                format_ids(barrier.downstream_tasks())
            )?;
        }

        writeln!(f, "  resources:")?;
        for resource in self.resources() {
            writeln!(
                f,
                "    {} producer={} consumers={} lifetime={}",
                resource.id(),
                resource.producer(),
                format_ids(resource.consumers()),
                resource.lifetime()
            )?;
        }

        let sink = self.sink();
        writeln!(f, "  sink: kind={} input={}", sink.kind().as_str(), sink.input())
    }
}

fn format_ids<T: fmt::Display>(ids: &[T]) -> String {
    if ids.is_empty() { "none".to_string() } else { ids.iter().map(ToString::to_string).collect::<Vec<_>>().join(",") }
}