Luce packages
LuceLuce BaseLuciaOS

dymokomi/luced-3d

Source of release 0.11.6

0.11.6 / src / compute_session.luc

## UI-side scheduling: stamp the graph, send the delta, poll progress and
## adopt reports. A node is dirty while its stamp has no reported result.
from compute_bridge import ComputeService
from compute_worker import compute_factory
from compute_request import RequestWriter, read_report
from network import Network
from stamps import stamp_graph

pub class ComputeSession:
    pub let service: ComputeService
    pub var generation: int = 0
    pub var applied: int = 0
    var sequence: int = -1
    pub var busy: bool = false
    ## Set when the worker asked for a full request; the caller resubmits once.
    pub var resync: bool = false
    ## Size of the last request text and Edit recipes the last cook applied.
    pub var request_size: int = 0
    pub var recipes: int = 0
    ## The last report's Project shadows and the Sketch stamp they are for.
    pub var shadows: str = ""
    pub var shadows_stamp: int = 0
    ## The last report's Slice cap and the Sketch stamp it is for.
    pub var section: str = ""
    pub var section_stamp: int = 0
    let writer: RequestWriter
    var resyncs: int = 0

    pub func init(self) -> unit!:
        self.service = ComputeService(compute_factory)
        self.writer = RequestWriter()

    pub func submit(self, graph: Network, mode: int, normals: bool = false) -> unit!:
        stamp_graph(graph)
        self.generation += 1
        self.busy = true
        let wanted: list[int] = []
        for node in graph.nodes:
            wanted.append(node.stamp)
            node.dirty = node.stamp != node.cooked
            node.computing = node.dirty
            node.progress = 0.0
            node.phase = "Queued" if node.dirty else ""
        let request = self.writer.encode(graph, mode, normals)
        self.request_size = request.byte_count
        self.service.submit(request, self.generation, wanted)

    pub func poll_progress(self, graph: Network) -> bool!:
        let sequence = self.service.sequence()
        if sequence == self.sequence:
            return false
        self.sequence = sequence
        for node in graph.nodes:
            if node.phase != "Queued":
                node.computing = false
        if let node = graph.find(self.service.active_node()):
            node.computing = self.busy
            node.progress = self.service.progress()
            node.phase = self.service.phase()
        return true

    pub func read_report(self, graph: Network) -> str!:
        self.busy = false
        self.applied = self.generation
        self.resync = false
        if self.service.failed():
            # The worker's mirror may hold part of a failed delta.
            self.writer.reset()
            for node in graph.nodes:
                node.computing = false
                node.phase = ""
            return self.service.report()
        let report = read_report(self.service.report())
        self.recipes = report.recipes
        self.shadows = report.shadows
        self.shadows_stamp = report.shadows_stamp
        self.section = report.section
        self.section_stamp = report.section_stamp
        if report.resync:
            # One full resend; a second refusal is reported, not retried.
            self.writer.reset()
            self.resyncs += 1
            self.resync = self.resyncs == 1
            return report.notice
        self.resyncs = 0
        for outcome in report.outcomes:
            let node = graph.find(outcome.id) else continue
            node.cooked = outcome.cooked
            node.dirty = node.stamp != outcome.cooked
            node.failure = outcome.failure
            node.warning = outcome.warning
            node.console = outcome.console
            node.sketch_state = outcome.sketch_state
            node.automatic = outcome.automatic
            # Handles stay where the last good cook put them while one is in
            # flight or fails (a radius dragged too large keeps its arrow).
            if outcome.cooked != 0 and outcome.failure == "":
                node.handles = outcome.handles
            node.summary = outcome.summary
            node.evaluations = outcome.evaluations
            node.group_paths = outcome.paths
            node.curve_paths = outcome.curves
            node.computing = false
            node.phase = ""
            node.cache = none
        return report.notice

    pub func close(self):
        self.service.close()