hugo/MetaCrate
1
0
Fork 0
Code Issues 2 Pull Requests Actions Packages Projects Releases Wiki Activity

Profile and preinitialize viewport rendering
Some checks failed
CI / rust-skia (Rust only) (push) Has been cancelled
Details
CI / required (push) Has been cancelled
Details

Browse Source
This commit is contained in:
Chili Palmer
2026-08-23 12:16:52 +02:00
parent b59bc4c3cd
commit cb9233c59c
8 changed files with 444 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
crates/metacrate-grid-agent/src/lib.rs
View File

@@ -183,8 +183,8 @@ pub use types::{
#[cfg(feature = "live-grid")]
pub use vision::LibremetaverseSceneSource;
pub use vision::{
CameraPose, SceneEntity, SceneEntityKind, SceneSnapshot, SceneSource, SceneTriangle,
SnapshotCompleteness, VisionAugmentedResponder, VisionCapture, VisionControl, VisionError,
VisionFuture, VisionLimits, VisionObservation, VisionObservationKind, VisionService,
visual_question,
CameraPose, SceneBuildTimings, SceneEntity, SceneEntityKind, SceneSnapshot, SceneSource,
SceneTriangle, SnapshotCompleteness, VisionAugmentedResponder, VisionCapture, VisionControl,
VisionError, VisionFuture, VisionLimits, VisionObservation, VisionObservationKind,
VisionService, visual_question,
};

7
crates/metacrate-grid-agent/src/main.rs
View File

@@ -284,7 +284,7 @@ async fn run_live(
let owner = LibremetaverseClientOwner::new_with_asset_cache_max_bytes(
config.vision.asset_cache_max_bytes,
)?;
let mut live = start_live_interactions(&config, &owner)?;
let mut live = start_live_interactions(&config, &owner).await?;
let backend = match owner.session_backend_with_agent_services(
connection,
live.interaction.ingress(),
@@ -612,7 +612,7 @@ struct LiveInteractions {
#[cfg(feature = "live-grid")]
#[allow(clippy::too_many_lines)]
fn start_live_interactions(
async fn start_live_interactions(
config: &metacrate_grid_agent::AgentConfig,
owner: &metacrate_grid_agent::LibremetaverseClientOwner,
) -> Result<LiveInteractions, Box<dyn Error>> {
@@ -751,6 +751,9 @@ fn start_live_interactions(
scene_source.start_prefetch();
let vision =
Arc::new(VisionService::new(Arc::clone(&scene_source), vision_limits)?.prefer_gpu());
if !vision.initialize_renderer().await {
eprintln!("WARNING: wgpu renderer unavailable; visual captures use software fallback");
}
let responder = Arc::new(VisionAugmentedResponder::new(vision.clone(), responder));
let sink = Arc::new(owner.interaction_sink());
let pacer: Arc<dyn metacrate_grid_agent::ResponsePacer> = Arc::new(behavior_ingress);

163
crates/metacrate-grid-agent/src/vision.rs
View File

@@ -60,6 +60,15 @@ pub struct SnapshotCompleteness {
pub terrain_available: bool,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct SceneBuildTimings {
pub terrain_wait: Duration,
pub object_snapshot_and_asset_discovery: Duration,
pub material_fetch: Duration,
pub asset_fetch: Duration,
pub decode_and_geometry: Duration,
}
#[derive(Clone, Debug, PartialEq)]
pub struct SceneSnapshot {
pub generation: u64,
@@ -74,6 +83,7 @@ pub struct SceneSnapshot {
pub texture_fetches: usize,
pub texture_bytes: usize,
pub decoded_texture_pixels: usize,
pub timings: SceneBuildTimings,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -258,6 +268,26 @@ impl<S: SceneSource> VisionService<S> {
self.gpu_preferred = true;
self
}
/// Completes renderer discovery before the live agent is allowed to become active.
#[cfg(feature = "live-grid")]
pub async fn initialize_renderer(&self) -> bool {
!self.gpu_preferred || self.renderer().await.is_some()
}
#[cfg(feature = "live-grid")]
async fn renderer(&self) -> Option<Arc<metacrate_rendering_wgpu::Renderer>> {
self.gpu
.get_or_init(|| async {
tokio::task::spawn_blocking(bevy_renderer_new)
.await
.ok()
.and_then(Result::ok)
.map(Arc::new)
})
.await
.clone()
}
pub fn set_generation(&self, generation: u64) {
if self.current_generation.swap(generation, Ordering::AcqRel) != generation {
self.cancel_active();
@@ -396,71 +426,58 @@ impl<S: SceneSource> VisionService<S> {
async fn render_scene(&self, scene: SceneSnapshot) -> Result<VisionCapture, VisionError> {
#[cfg(feature = "live-grid")]
if self.gpu_preferred {
let renderer = self
.gpu
.get_or_init(|| async {
tokio::task::spawn_blocking(bevy_renderer_new)
.await
.ok()
.and_then(Result::ok)
.map(Arc::new)
if self.gpu_preferred
&& let Some(renderer) = self.renderer().await
{
let mut renderables = scene
.entities
.iter()
.flat_map(|entity| {
entity
.renderables
.iter()
.cloned()
.map(move |renderable| (entity.id.to_string(), renderable))
})
.await
.clone();
if let Some(renderer) = renderer {
let mut renderables = scene
.entities
.iter()
.flat_map(|entity| {
entity
.renderables
.iter()
.cloned()
.map(move |renderable| (entity.id.to_string(), renderable))
.collect::<Vec<_>>();
renderables.sort_by(|left, right| left.0.cmp(&right.0));
let renderables = renderables
.into_iter()
.map(|(_, renderable)| renderable)
.collect::<Vec<_>>();
let gpu_scene = scene.clone();
let limits = self.limits;
if let Ok(Ok(capture)) = tokio::task::spawn_blocking(move || {
renderer
.render(
gpu_scene.camera,
&renderables,
&gpu_scene.textures,
environment_color(&gpu_scene),
metacrate_rendering_wgpu::RenderLimits {
width: limits.width,
height: limits.height,
max_triangles: limits.max_triangles,
max_texture_bytes: limits.max_texture_bytes,
max_texture_pixels: limits.max_decode_pixels,
far_distance: 512,
},
)
.map_err(|error| match error {
metacrate_rendering_wgpu::RenderError::InvalidScene => {
VisionError::InvalidScene
}
metacrate_rendering_wgpu::RenderError::ResourceLimit => {
VisionError::ResourceLimit
}
metacrate_rendering_wgpu::RenderError::TimedOut => VisionError::TimedOut,
_ => VisionError::Encode,
})
.collect::<Vec<_>>();
renderables.sort_by(|left, right| left.0.cmp(&right.0));
let renderables = renderables
.into_iter()
.map(|(_, renderable)| renderable)
.collect::<Vec<_>>();
let gpu_scene = scene.clone();
let limits = self.limits;
if let Ok(Ok(capture)) = tokio::task::spawn_blocking(move || {
renderer
.render(
gpu_scene.camera,
&renderables,
&gpu_scene.textures,
environment_color(&gpu_scene),
metacrate_rendering_wgpu::RenderLimits {
width: limits.width,
height: limits.height,
max_triangles: limits.max_triangles,
max_texture_bytes: limits.max_texture_bytes,
max_texture_pixels: limits.max_decode_pixels,
far_distance: 512,
},
)
.map_err(|error| match error {
metacrate_rendering_wgpu::RenderError::InvalidScene => {
VisionError::InvalidScene
}
metacrate_rendering_wgpu::RenderError::ResourceLimit => {
VisionError::ResourceLimit
}
metacrate_rendering_wgpu::RenderError::TimedOut => {
VisionError::TimedOut
}
_ => VisionError::Encode,
})
.and_then(|rgba| finish_capture(&gpu_scene, limits, &rgba))
})
.await
{
return Ok(capture);
}
.and_then(|rgba| finish_capture(&gpu_scene, limits, &rgba))
})
.await
{
return Ok(capture);
}
}
render_scene_software(&scene, self.limits)
@@ -1058,6 +1075,9 @@ async fn request_asset_bytes(
asset_type: libremetaverse_types::AssetType,
cancellation: CancellationToken,
) -> Option<Vec<u8>> {
if let Ok(Some(bytes)) = assets.cache.get_cached_asset_bytes_with_uuid(id) {
return Some(bytes);
}
tokio::time::timeout(Duration::from_secs(8), async {
match asset_type {
libremetaverse_types::AssetType::Texture => {
@@ -1095,6 +1115,7 @@ impl SceneSource for LibremetaverseSceneSource {
cancellation: CancellationToken,
) -> VisionFuture<'_, SceneSnapshot> {
Box::pin(async move {
let build_started = Instant::now();
if cancellation.is_cancellation_requested() {
return Err(VisionError::Cancelled);
}
@@ -1122,6 +1143,8 @@ impl SceneSource for LibremetaverseSceneSource {
() = tokio::time::sleep(Duration::from_millis(100)) => {}
}
}
let terrain_wait = build_started.elapsed();
let discovery_started = Instant::now();
let camera = &self.agent.movement.camera;
let position = if generation == 0 {
self.agent.sim_position()
@@ -1340,6 +1363,8 @@ impl SceneSource for LibremetaverseSceneSource {
ids
});
let assets = self.client.assets();
let object_snapshot_and_asset_discovery = discovery_started.elapsed();
let material_started = Instant::now();
let missing_legacy_materials = {
let cache = lock(&self.cache);
legacy_material_ids
@@ -1463,6 +1488,8 @@ impl SceneSource for LibremetaverseSceneSource {
});
}
}
let material_fetch = material_started.elapsed();
let asset_fetch_started = Instant::now();
texture_ids.retain(|id| *id != UUID::zero());
let scene_texture_ids = texture_ids.clone();
{
@@ -1552,6 +1579,8 @@ impl SceneSource for LibremetaverseSceneSource {
});
}
}
let asset_fetch = asset_fetch_started.elapsed();
let conversion_started = Instant::now();
let maximum = self.limits.max_triangles;
let decode_pixels = self.limits.max_decode_pixels;
let decode_bytes = self.limits.max_texture_bytes;
@@ -1581,6 +1610,7 @@ impl SceneSource for LibremetaverseSceneSource {
})
.await
.map_err(|_| VisionError::InvalidScene)??;
let decode_and_geometry = conversion_started.elapsed();
if cancellation.is_cancellation_requested() {
return Err(VisionError::Cancelled);
}
@@ -1618,6 +1648,13 @@ impl SceneSource for LibremetaverseSceneSource {
texture_fetches,
texture_bytes,
decoded_texture_pixels,
timings: SceneBuildTimings {
terrain_wait,
object_snapshot_and_asset_discovery,
material_fetch,
asset_fetch,
decode_and_geometry,
},
})
})
}

1
crates/metacrate-grid-agent/src/vision_tests.rs
View File

@@ -399,6 +399,7 @@ fn scene() -> SceneSnapshot {
texture_fetches: 1,
texture_bytes: 128,
decoded_texture_pixels: 16,
timings: SceneBuildTimings::default(),
}
}

160
crates/metacrate-grid-agent/tests/live_renderer.rs
View File

@@ -50,6 +50,56 @@ async fn live_primary_login_resolves_varregion_dimensions() -> Result<(), Box<dy
result
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "profiles primary login, renderer initialization, and first visible-scene warmup"]
async fn live_primary_startup_profile() -> Result<(), Box<dyn Error>> {
let total_started = Instant::now();
let environment = live_environment()?;
let owner_started = Instant::now();
let owner = LibremetaverseClientOwner::new()?;
let owner_initialization = owner_started.elapsed();
let gpu_task = tokio::task::spawn_blocking(|| {
let started = Instant::now();
(
metacrate_rendering_wgpu::Renderer::new_blocking(),
started.elapsed(),
)
});
let login_started = Instant::now();
let (mut session, cancellation) =
login(&owner, &environment, "GRID_USER", "GRID_PASSWORD").await?;
let login = login_started.elapsed();
let ready_started = Instant::now();
wait_ready("primary", &mut session, &cancellation).await?;
let readiness = ready_started.elapsed();
let settle_started = Instant::now();
wait_scene_settled(&owner).await?;
let scene_settle = settle_started.elapsed();
let limits = VisionLimits {
minimum_interval: Duration::ZERO,
..VisionLimits::default()
};
let source = LibremetaverseSceneSource::new(&owner, limits);
let warmup_started = Instant::now();
let scene = source.capture_scene(0, cancellation.token()).await?;
let scene_warmup = warmup_started.elapsed();
let (renderer, gpu_initialization) = gpu_task.await?;
renderer?;
println!(
"LIVE_STARTUP_PROFILE=owner_initialization_ms:{},grid_login_ms:{},grid_readiness_ms:{},scene_settle_ms:{},gpu_initialization_parallel_ms:{},first_scene_warmup_ms:{},first_scene:{:?},total_ms:{}",
owner_initialization.as_millis(),
login.as_millis(),
readiness.as_millis(),
scene_settle.as_millis(),
gpu_initialization.as_millis(),
scene_warmup.as_millis(),
scene.timings,
total_started.elapsed().as_millis(),
);
let _ = session.logout(cancellation.token()).await;
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "records the primary region's asynchronous map-name reply"]
async fn live_primary_map_name_reports_varregion_dimensions() -> Result<(), Box<dyn Error>> {
@@ -175,6 +225,14 @@ async fn live_bevy_capture_renders_in_front_of_avatar() -> Result<(), Box<dyn Er
limits,
)?
.prefer_gpu();
let initialization_started = Instant::now();
if !vision.initialize_renderer().await {
return Err("live wgpu renderer initialization failed".into());
}
println!(
"LIVE_RENDER_INITIALIZATION_MILLISECONDS={}",
initialization_started.elapsed().as_millis()
);
vision.set_generation(1);
let mut capture = None;
let output = std::env::var_os("METACRATE_LIVE_RENDER_OUTPUT").map_or_else(
@@ -215,6 +273,7 @@ async fn live_bevy_capture_renders_in_front_of_avatar() -> Result<(), Box<dyn Er
}
}
let capture = capture.ok_or("live renderer produced no frame")?;
profile_warm_capture(&scene_source, limits, renderer_cancel.token()).await?;
println!("LIVE_RENDER_OUTPUT={}", output.display());
println!("LIVE_RENDER_SHA256={}", capture.image_sha256);
Ok::<(), Box<dyn Error>>(())
@@ -226,6 +285,107 @@ async fn live_bevy_capture_renders_in_front_of_avatar() -> Result<(), Box<dyn Er
result
}
async fn profile_warm_capture(
source: &LibremetaverseSceneSource,
limits: VisionLimits,
cancellation: CancellationToken,
) -> Result<(), Box<dyn Error>> {
let total_started = Instant::now();
let scene_started = Instant::now();
let scene = source.capture_scene(1, cancellation).await?;
let scene_total = scene_started.elapsed();
let preparation_started = Instant::now();
let mut renderables = scene
.entities
.iter()
.flat_map(|entity| {
entity
.renderables
.iter()
.cloned()
.map(move |renderable| (entity.id.to_string(), renderable))
})
.collect::<Vec<_>>();
renderables.sort_by(|left, right| left.0.cmp(&right.0));
let renderables = renderables
.into_iter()
.map(|(_, renderable)| renderable)
.collect::<Vec<_>>();
let preparation = preparation_started.elapsed();
let renderer_started = Instant::now();
let renderer = metacrate_rendering_wgpu::Renderer::new_blocking()?;
let renderer_initialization = renderer_started.elapsed();
let render_limits = metacrate_rendering_wgpu::RenderLimits {
width: limits.width,
height: limits.height,
max_triangles: limits.max_triangles,
max_texture_bytes: limits.max_texture_bytes,
max_texture_pixels: limits.max_decode_pixels,
far_distance: 512,
};
let first = renderer.render_profiled(
scene.camera,
&renderables,
&scene.textures,
[125, 149, 173, 255],
render_limits,
)?;
let warm_started = Instant::now();
let warm = renderer.render_profiled(
scene.camera,
&renderables,
&scene.textures,
[125, 149, 173, 255],
render_limits,
)?;
let warm_render_total = warm_started.elapsed();
let jpeg_started = Instant::now();
let rgb = warm
.rgba
.chunks_exact(4)
.flat_map(|pixel| pixel[..3].iter().copied())
.collect::<Vec<_>>();
let mut jpeg = Vec::new();
jpeg_encoder::Encoder::new(&mut jpeg, 92).encode(
&rgb,
u16::try_from(limits.width)?,
u16::try_from(limits.height)?,
jpeg_encoder::ColorType::Rgb,
)?;
let jpeg_encode = jpeg_started.elapsed();
println!(
"LIVE_RENDER_PROFILE=scene_total_ms:{},terrain_wait_ms:{},object_snapshot_and_asset_discovery_ms:{},material_fetch_ms:{},asset_fetch_ms:{},decode_and_geometry_ms:{},renderable_collection_and_sort_ms:{},renderer_initialization_ms:{},first_render_total_ms:{},first_render:{:?},warm_render_total_ms:{},warm_render:{:?},jpeg_encode_ms:{},profile_total_ms:{}",
scene_total.as_millis(),
scene.timings.terrain_wait.as_millis(),
scene
.timings
.object_snapshot_and_asset_discovery
.as_millis(),
scene.timings.material_fetch.as_millis(),
scene.timings.asset_fetch.as_millis(),
scene.timings.decode_and_geometry.as_millis(),
preparation.as_millis(),
renderer_initialization.as_millis(),
render_total(&first.timings).as_millis(),
first.timings,
warm_render_total.as_millis(),
warm.timings,
jpeg_encode.as_millis(),
total_started.elapsed().as_millis(),
);
Ok(())
}
fn render_total(timings: &metacrate_rendering_wgpu::RenderTimings) -> Duration {
timings.validation
+ timings.command_copy
+ timings.clear_previous_frame
+ timings.texture_cache_sync
+ timings.mesh_cache_sync
+ timings.scene_setup
+ timings.capture
}
struct DiagnosticSceneSource {
inner: Arc<LibremetaverseSceneSource>,
material_override: Option<String>,