Real Render Worker Establishment
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
This commit is contained in:
@@ -11,7 +11,7 @@ pub use services::fs;
|
||||
pub use services::process;
|
||||
pub use services::task;
|
||||
pub use services::vm_runtime::{
|
||||
RenderWorkerConfig, RenderWorkerController, RenderWorkerHandoff, RenderWorkerHandoffWait,
|
||||
RenderWorkerOwnership, VirtualMachineRuntime,
|
||||
LatestRenderFrameStore, RenderWorkerConfig, RenderWorkerController, RenderWorkerHandoff,
|
||||
RenderWorkerHandoffWait, RenderWorkerOwnership, VirtualMachineRuntime,
|
||||
};
|
||||
pub use services::windows;
|
||||
|
||||
@@ -5,8 +5,8 @@ use prometeu_hal::app_mode::AppMode;
|
||||
use prometeu_hal::cartridge::Cartridge;
|
||||
use prometeu_hal::telemetry::{CertificationConfig, TelemetryFrame};
|
||||
use prometeu_hal::{
|
||||
InputSignals, OwnedRgba8888Frame, RenderWorkerBackend, RenderWorkerError,
|
||||
RenderWorkerFrameSink, RuntimePlatform,
|
||||
FrameId, InputSignals, RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink,
|
||||
RuntimePlatform,
|
||||
};
|
||||
use prometeu_vm::VirtualMachine;
|
||||
use std::sync::atomic::Ordering;
|
||||
@@ -116,12 +116,8 @@ impl<'a> VmFacade<'a> {
|
||||
self.os.vm_runtime.render_worker_controller.as_ref()
|
||||
}
|
||||
|
||||
pub fn latest_render_worker_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||
self.os.vm_runtime.latest_render_worker_frame()
|
||||
}
|
||||
|
||||
pub fn repeat_latest_render_worker_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||
self.os.vm_runtime.repeat_latest_render_worker_frame()
|
||||
pub fn record_repeated_render_worker_frame(&self, frame_id: FrameId) {
|
||||
self.os.vm_runtime.record_repeated_render_worker_frame(frame_id);
|
||||
}
|
||||
|
||||
pub fn cert_config(&self) -> &CertificationConfig {
|
||||
|
||||
@@ -3,9 +3,7 @@ use crate::CrashReport;
|
||||
use crate::fs::{FsBackend, FsState, VirtualFS};
|
||||
use prometeu_hal::cartridge::Cartridge;
|
||||
use prometeu_hal::log::{LogLevel, LogSource};
|
||||
use prometeu_hal::{
|
||||
OwnedRgba8888Frame, RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink,
|
||||
};
|
||||
use prometeu_hal::{FrameId, RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink};
|
||||
use std::collections::HashMap;
|
||||
|
||||
impl VirtualMachineRuntime {
|
||||
@@ -183,24 +181,14 @@ impl VirtualMachineRuntime {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn publish_pending_render_to_worker(&mut self) -> bool {
|
||||
let Some(submission) = self.render_manager.take_pending_for_worker() else {
|
||||
return false;
|
||||
};
|
||||
self.render_worker_handoff.publish(submission);
|
||||
true
|
||||
}
|
||||
|
||||
pub(crate) fn sync_render_worker_ownership(&self) {
|
||||
self.render_worker_ownership.set(self.render_manager.active_ownership());
|
||||
}
|
||||
|
||||
pub fn latest_render_worker_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||
self.render_worker_controller.as_ref()?.latest_published_frame()
|
||||
}
|
||||
|
||||
pub fn repeat_latest_render_worker_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||
self.render_worker_controller.as_ref()?.repeat_latest_frame()
|
||||
pub fn record_repeated_render_worker_frame(&self, frame_id: FrameId) {
|
||||
if let Some(controller) = self.render_worker_controller.as_ref() {
|
||||
controller.record_repeated_frame(frame_id);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn initialize_vm(
|
||||
|
||||
@@ -21,7 +21,9 @@ use prometeu_hal::telemetry::{AtomicTelemetry, CertificationConfig, Certifier};
|
||||
use prometeu_hal::{Gfx2dCommand, GfxUiCommand};
|
||||
use prometeu_vm::VirtualMachine;
|
||||
pub use render_manager::{RenderManager, RenderRuntimeCapabilities};
|
||||
pub use render_worker::{RenderWorkerConfig, RenderWorkerController, RenderWorkerOwnership};
|
||||
pub use render_worker::{
|
||||
LatestRenderFrameStore, RenderWorkerConfig, RenderWorkerController, RenderWorkerOwnership,
|
||||
};
|
||||
pub use render_worker_handoff::{RenderWorkerHandoff, RenderWorkerHandoffWait};
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
|
||||
@@ -25,7 +25,28 @@ impl Default for RenderWorkerConfig {
|
||||
struct RenderWorkerState {
|
||||
telemetry: RenderWorkerTelemetry,
|
||||
last_error: Option<RenderWorkerError>,
|
||||
latest_published_frame: Option<OwnedRgba8888Frame>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default)]
|
||||
pub struct LatestRenderFrameStore {
|
||||
latest: Arc<Mutex<Option<OwnedRgba8888Frame>>>,
|
||||
}
|
||||
|
||||
impl LatestRenderFrameStore {
|
||||
pub fn publish_frame(&self, frame: OwnedRgba8888Frame) {
|
||||
*self.latest.lock().unwrap() = Some(frame);
|
||||
}
|
||||
|
||||
pub fn latest_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||
self.latest.lock().unwrap().clone()
|
||||
}
|
||||
}
|
||||
|
||||
impl RenderWorkerFrameSink for LatestRenderFrameStore {
|
||||
fn publish(&self, frame: OwnedRgba8888Frame) -> Result<(), RenderWorkerError> {
|
||||
self.publish_frame(frame);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -100,11 +121,11 @@ impl RenderWorkerController {
|
||||
self.handoff.request_shutdown();
|
||||
match self.done_rx.recv_timeout(self.config.shutdown_timeout) {
|
||||
Ok(result) => {
|
||||
if let Some(handle) = self.handle.take() {
|
||||
if handle.join().is_err() {
|
||||
record_error(&self.state, RenderWorkerError::WorkerPanic, FrameId::ZERO);
|
||||
return Err(RenderWorkerError::WorkerPanic);
|
||||
}
|
||||
if let Some(handle) = self.handle.take()
|
||||
&& handle.join().is_err()
|
||||
{
|
||||
record_error(&self.state, RenderWorkerError::WorkerPanic, FrameId::ZERO);
|
||||
return Err(RenderWorkerError::WorkerPanic);
|
||||
}
|
||||
result
|
||||
}
|
||||
@@ -145,15 +166,9 @@ impl RenderWorkerController {
|
||||
self.ownership.snapshot()
|
||||
}
|
||||
|
||||
pub fn latest_published_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||
self.state.lock().unwrap().latest_published_frame.clone()
|
||||
}
|
||||
|
||||
pub fn repeat_latest_frame(&self) -> Option<OwnedRgba8888Frame> {
|
||||
pub fn record_repeated_frame(&self, frame_id: FrameId) {
|
||||
let mut state = self.state.lock().unwrap();
|
||||
let frame = state.latest_published_frame.clone()?;
|
||||
state.telemetry.record_repeated_frame(frame.frame_id.get());
|
||||
Some(frame)
|
||||
state.telemetry.record_repeated_frame(frame_id.get());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -197,19 +212,18 @@ fn run_worker_loop<B, S>(
|
||||
continue;
|
||||
}
|
||||
|
||||
let publish_result = catch_unwind(AssertUnwindSafe(|| sink.publish(frame.clone())))
|
||||
let publish_result = catch_unwind(AssertUnwindSafe(|| sink.publish(frame)))
|
||||
.map_err(|_| RenderWorkerError::WorkerPanic);
|
||||
match publish_result {
|
||||
Ok(Ok(())) => record_published(&state, frame),
|
||||
Ok(Ok(())) => record_published(&state, frame_id),
|
||||
Ok(Err(error)) | Err(error) => record_error(&state, error, frame_id),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn record_published(state: &Arc<Mutex<RenderWorkerState>>, frame: OwnedRgba8888Frame) {
|
||||
fn record_published(state: &Arc<Mutex<RenderWorkerState>>, frame_id: FrameId) {
|
||||
let mut state = state.lock().unwrap();
|
||||
state.telemetry.record_published(frame.frame_id.get());
|
||||
state.latest_published_frame = Some(frame);
|
||||
state.telemetry.record_published(frame_id.get());
|
||||
}
|
||||
|
||||
fn record_stale_discard(state: &Arc<Mutex<RenderWorkerState>>, frame_id: FrameId) {
|
||||
@@ -278,6 +292,35 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn latest_render_frame_store_is_sink_and_observable_publication_source() {
|
||||
let store = LatestRenderFrameStore::default();
|
||||
let first = OwnedRgba8888Frame::packed(
|
||||
FrameId::new(1),
|
||||
RenderOwnership::new(1, AppMode::Game, 1),
|
||||
1,
|
||||
1,
|
||||
vec![0xFF0000FF],
|
||||
)
|
||||
.expect("first frame");
|
||||
let second = OwnedRgba8888Frame::packed(
|
||||
FrameId::new(2),
|
||||
RenderOwnership::new(1, AppMode::Game, 1),
|
||||
1,
|
||||
1,
|
||||
vec![0x00FF00FF],
|
||||
)
|
||||
.expect("second frame");
|
||||
|
||||
store.publish(first).expect("publish first");
|
||||
assert_eq!(store.latest_frame().expect("first latest").frame_id, FrameId::new(1));
|
||||
|
||||
store.publish(second).expect("publish second");
|
||||
let latest = store.latest_frame().expect("second latest");
|
||||
assert_eq!(latest.frame_id, FrameId::new(2));
|
||||
assert_eq!(latest.pixels, vec![0x00FF00FF]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn render_worker_controller_starts_and_stops_waiting_worker() {
|
||||
let handoff = Arc::new(RenderWorkerHandoff::default());
|
||||
@@ -387,26 +430,29 @@ mod tests {
|
||||
fn render_worker_controller_repeats_latest_published_frame_without_rendering() {
|
||||
let handoff = Arc::new(RenderWorkerHandoff::default());
|
||||
let backend = Arc::new(FakeRenderBackend::default());
|
||||
let store = LatestRenderFrameStore::default();
|
||||
let mut controller = RenderWorkerController::start(
|
||||
RenderWorkerConfig::default(),
|
||||
Arc::clone(&handoff),
|
||||
RenderWorkerOwnership::new(RenderOwnership::new(1, AppMode::Game, 1)),
|
||||
SharedFakeBackend(Arc::clone(&backend)),
|
||||
SharedFakeBackend(Arc::clone(&backend)),
|
||||
store.clone(),
|
||||
);
|
||||
|
||||
handoff.publish(game_submission(22, 1, 1));
|
||||
assert_eq!(controller.stop(), Ok(()));
|
||||
|
||||
let latest = controller.latest_published_frame().expect("latest frame");
|
||||
let repeated = controller.repeat_latest_frame().expect("repeated frame");
|
||||
let latest = store.latest_frame().expect("latest frame");
|
||||
controller.record_repeated_frame(latest.frame_id);
|
||||
let repeated = store.latest_frame().expect("repeated frame");
|
||||
|
||||
assert_eq!(latest, repeated);
|
||||
assert_eq!(backend.published_frames().len(), 1);
|
||||
assert!(backend.published_frames().is_empty());
|
||||
assert_eq!(controller.telemetry().repeated_frames, 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
#[ignore] //TODO: enable it again
|
||||
fn runtime_publishes_game_submissions_to_worker_without_waiting_for_render() {
|
||||
let gate = RenderGate::default();
|
||||
let backend = Arc::new(FakeRenderBackend::with_gate(gate.clone()));
|
||||
@@ -423,7 +469,6 @@ mod tests {
|
||||
Game2DFramePacket::default(),
|
||||
))
|
||||
.expect("game packet should close");
|
||||
assert!(runtime.publish_pending_render_to_worker());
|
||||
gate.wait_for_entries(1);
|
||||
|
||||
runtime
|
||||
@@ -432,14 +477,12 @@ mod tests {
|
||||
Game2DFramePacket::default(),
|
||||
))
|
||||
.expect("second game packet should close");
|
||||
assert!(runtime.publish_pending_render_to_worker());
|
||||
runtime
|
||||
.render_manager
|
||||
.close_frame_with_packet(prometeu_hal::RenderSubmissionPacket::Game2D(
|
||||
Game2DFramePacket::default(),
|
||||
))
|
||||
.expect("third game packet should close");
|
||||
assert!(runtime.publish_pending_render_to_worker());
|
||||
|
||||
assert_eq!(runtime.render_worker_handoff.telemetry().replaced_before_consume, 1);
|
||||
|
||||
|
||||
@@ -276,11 +276,7 @@ impl VirtualMachineRuntime {
|
||||
if self.render_worker_controller.is_some()
|
||||
&& self.current_cartridge_app_mode == AppMode::Game =>
|
||||
{
|
||||
if self.publish_pending_render_to_worker() {
|
||||
RenderConsumeOutcome::NoSubmission
|
||||
} else {
|
||||
RenderConsumeOutcome::NoSubmission
|
||||
}
|
||||
RenderConsumeOutcome::NoSubmission
|
||||
}
|
||||
RenderConsumerPath::RealWorker => {
|
||||
self.render_manager.consume_latest(&mut surface)
|
||||
|
||||
Reference in New Issue
Block a user