dymokomi/luced-3d
Source of release 0.11.5
0.11.5 / 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
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
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.summary = outcome.summary
node.evaluations = outcome.evaluations
node.group_paths = outcome.paths
node.computing = false
node.phase = ""
node.cache = none
return report.notice
pub func close(self):
self.service.close()