Commit 9ee9034
3
plików
+182
dodanych
-75
usuniętych
@@ -263,6 +263,17 @@ i poprzedniej klatki. Scena z widocznym `dmabuf` wymusza pełną klatkę — kli
263 263 byłaby fałszywie zerowa. Kryterium: przy animacji panelu odczyt ≤ 10% klatki.
264 264 Testy: `drm::tests::present_region_*`.
265 265
266 +**Pacing per wyjście (zrobione):** każde wyjście prezentuje po **własnym**
267 +vblanku. Klatka narysowana dla wyjścia, które ma jeszcze flip w toku, czeka
268 +w rendererze (`pending_present`), a pętla śpi tylko wtedy, gdy żadne wyjście nie
269 +może się Zaprezentować (`poll_flips`). Wcześniej `wait_flips()` czekało na
270 +wszystkie monitory naraz, więc 60 Hz HDMI dyktowało tempo 75 Hz DP-1.
271 +
272 +**Statystyki prezentacji:** `SELENE_STATS=1` dopisuje do linii fps
273 +`| pełne N, damage M, dmabuf K`. Pełne klatki poza rozruchem oznaczają, że
274 +`force_full_frames` zadziałał (flip padł, tryb się zmienił, klatka nie zdążyła)
275 +albo scena ma widoczny `dmabuf`.
276 +
266 277 **Pacing (zrobione):** czekanie na flipy stoi **przed prezentacją**, a nie na
267 278 początku iteracji: scena i readback bieżącej klatki liczą się w trakcie skanowania
268 279 poprzedniej, więc opóźnienie renderu nie przepada jako cały vblank (wcześniej
@@ -872,6 +872,13 @@ pub struct DrmBackend {
872 872 /// Nazwa sterownika karty (`qxl`, `virtio_gpu`, `i915`, …).
873 873 /// Sterowniki wirtualne nie obsługują `XBGR8888` — patrz [`scanout_formats`].
874 874 driver: Option<String>,
875 + /// Statystyki prezentacji od ostatniego `take_present_stats`:
876 + /// (pełne klatki, kopie z damage, zero-copy). Pełne klatki poza startem
877 + /// oznaczają, że `force_full_frames` zadziałał — czyli flipy padają albo
878 + /// scena ma widoczny `dmabuf`.
879 + stat_full: u64,
880 + stat_partial: u64,
881 + stat_dmabuf: u64,
875 882 }
876 883
877 884 impl Drop for DrmBackend {
@@ -959,6 +966,9 @@ impl DrmBackend {
959 966 fd,
960 967 outputs,
961 968 driver,
969 + stat_full: 0,
970 + stat_partial: 0,
971 + stat_dmabuf: 0,
962 972 });
963 973 }
964 974 Err(last)
@@ -1163,28 +1173,32 @@ impl DrmBackend {
1163 1173 // Framebuffery `dmabuf`, których CRTC już nie skanuje, można oddać dopiero
1164 1174 // teraz — po odebraniu `FLIP_COMPLETE`.
1165 1175 self.prune_dmabuf_fbs(idx);
1166 - let Some((back, fb_id, copied, name, width, height)) = self.outputs.get(idx).map(|out| {
1167 - let back = (out.front + 1) & 1;
1168 - let (ptr, pitch) = (out.buffers[back].ptr, out.buffers[back].pitch);
1169 - let (w, h) = (out.width as usize, out.height as usize);
1170 - // Po zero-copy, nieudanym flipie lub zmianie trybu historia damage
1171 - // nie opisuje zawartości tego bufora — kopiujemy całą klatkę.
1172 - let region = effective_region(out.force_full_frames, region);
1173 - let copied = match (region, out.swizzle) {
1174 - (None, true) => swizzle_into(ptr, pitch, rgba, w, h),
1175 - (None, false) => copy_rows_into(ptr, pitch, rgba, w, h),
1176 - (Some(r), true) => swizzle_region_into(ptr, pitch, rgba, w, h, r),
1177 - (Some(r), false) => copy_region_into(ptr, pitch, rgba, w, h, r),
1178 - };
1179 - (
1180 - back,
1181 - out.buffers[back].fb_id,
1182 - copied,
1183 - out.name.clone(),
1184 - out.width,
1185 - out.height,
1186 - )
1187 - }) else {
1176 + let Some((back, fb_id, copied, name, width, height, full)) =
1177 + self.outputs.get(idx).map(|out| {
1178 + let back = (out.front + 1) & 1;
1179 + let (ptr, pitch) = (out.buffers[back].ptr, out.buffers[back].pitch);
1180 + let (w, h) = (out.width as usize, out.height as usize);
1181 + // Po zero-copy, nieudanym flipie lub zmianie trybu historia damage
1182 + // nie opisuje zawartości tego bufora — kopiujemy całą klatkę.
1183 + let forced = out.force_full_frames > 0;
1184 + let region = effective_region(out.force_full_frames, region);
1185 + let copied = match (region, out.swizzle) {
1186 + (None, true) => swizzle_into(ptr, pitch, rgba, w, h),
1187 + (None, false) => copy_rows_into(ptr, pitch, rgba, w, h),
1188 + (Some(r), true) => swizzle_region_into(ptr, pitch, rgba, w, h, r),
1189 + (Some(r), false) => copy_region_into(ptr, pitch, rgba, w, h, r),
1190 + };
1191 + (
1192 + back,
1193 + out.buffers[back].fb_id,
1194 + copied,
1195 + out.name.clone(),
1196 + out.width,
1197 + out.height,
1198 + forced || region.is_none(),
1199 + )
1200 + })
1201 + else {
1188 1202 return false;
1189 1203 };
1190 1204 // Rozmiar klatki renderera musi zgadzać się z trybem wyjścia. Gdy się nie
@@ -1213,9 +1227,26 @@ impl DrmBackend {
1213 1227 out.front = back;
1214 1228 out.front_dmabuf = false;
1215 1229 out.force_full_frames = out.force_full_frames.saturating_sub(1);
1230 + if full {
1231 + self.stat_full += 1;
1232 + } else {
1233 + self.stat_partial += 1;
1234 + }
1216 1235 true
1217 1236 }
1218 1237
1238 + /// Statystyki prezentacji od poprzedniego wywołania: `(pełne, damage, dmabuf)`.
1239 + ///
1240 + /// Diagnostyka: pełne klatki poza rozruchem oznaczają, że `force_full_frames`
1241 + /// zadziałał (flipy padają, tryb się zmienił) albo scena ma widoczny `dmabuf`.
1242 + pub fn take_present_stats(&mut self) -> (u64, u64, u64) {
1243 + let stats = (self.stat_full, self.stat_partial, self.stat_dmabuf);
1244 + self.stat_full = 0;
1245 + self.stat_partial = 0;
1246 + self.stat_dmabuf = 0;
1247 + stats
1248 + }
1249 +
1219 1250 /// Czeka, aż wyjście `idx` nie ma oczekującego flipa (z limitem czasu).
1220 1251 ///
1221 1252 /// Normalnie flaga jest już zdjęta przez `wait_flips()` w pętli kompozytora;
@@ -1391,6 +1422,7 @@ impl DrmBackend {
1391 1422 // Bufory `dumb` nie są już aktualne — dopiero po powrocie na readback
1392 1423 // trzeba będzie skopiować całą klatkę.
1393 1424 out.force_full_frames = 2;
1425 + self.stat_dmabuf += 1;
1394 1426 true
1395 1427 }
1396 1428
@@ -1398,29 +1430,48 @@ impl DrmBackend {
1398 1430 ///
1399 1431 /// Obsługuje wiele monitorów naraz (dopasowując `user_data` do indeksu wyjścia),
1400 1432 /// `EINTR` na `poll`/`read` oraz bezpieczny limit czasu po suspend/resume.
1401 - pub fn wait_flips(&mut self) {
1402 - use rustix::event::{poll, PollFd, PollFlags};
1403 - use std::time::{Duration, Instant};
1433 + /// Czy wyjście `idx` czeka jeszcze na `FLIP_COMPLETE`.
1434 + ///
1435 + /// Dopóki `true`, nie wolno wysyłać kolejnego `PAGE_FLIP` (jądro zwróci
1436 + /// `EBUSY`) ani kopiować do bufora, który jest skanowany.
1437 + pub fn flip_pending(&self, idx: usize) -> bool {
1438 + self.outputs.get(idx).is_some_and(|out| out.flip_pending)
1439 + }
1404 1440
1405 - if !self.outputs.iter().any(|o| o.flip_pending) {
1406 - return;
1441 + /// Czy jakiekolwiek wyjście czeka na zakończenie flipa.
1442 + pub fn any_flip_pending(&self) -> bool {
1443 + self.outputs.iter().any(|out| out.flip_pending)
1444 + }
1445 +
1446 + /// Wymusza skopiowanie całej klatki w najbliższych prezentacjach wyjścia.
1447 + ///
1448 + /// Wołane, gdy klatka narysowana dla tego wyjścia nie została pokazana
1449 + /// (CRTC czekał na vblank): zawartość bufora „back” przestaje się zgadzać
1450 + /// z historią damage.
1451 + pub fn force_full(&mut self, idx: usize) {
1452 + if let Some(out) = self.outputs.get_mut(idx) {
1453 + out.force_full_frames = 2;
1407 1454 }
1408 - let deadline = Instant::now() + Duration::from_millis(200);
1409 - let mut buf = [0u8; 1024];
1455 + }
1410 1456
1411 - while self.outputs.iter().any(|o| o.flip_pending) {
1412 - let remaining = deadline.saturating_duration_since(Instant::now());
1413 - if remaining.is_zero() {
1414 - break;
1415 - }
1416 - let timeout_ms = remaining.as_millis().min(200).max(1) as i32;
1417 - let mut fds = [PollFd::new(&self.fd, PollFlags::IN)];
1418 - match poll(&mut fds, timeout_ms) {
1419 - Ok(0) => break,
1420 - Ok(_) => {}
1421 - Err(rustix::io::Errno::INTR) => continue,
1422 - Err(_) => break,
1423 - }
1457 + /// Zbiera zdarzenia flipów, czekając maksymalnie `timeout_ms` na pierwsze.
1458 + ///
1459 + /// Zwraca liczbę odebranych zdarzeń `FLIP_COMPLETE` (0 = brak w zadanym
1460 + /// czasie). Nie czeka na **wszystkie** wyjścia — dzięki temu każde wyjście
1461 + /// może prezentować z własnym odświeżaniem (75 Hz i 60 Hz jednocześnie).
1462 + pub fn poll_flips(&mut self, timeout_ms: i32) -> usize {
1463 + use rustix::event::{poll, PollFd, PollFlags};
1464 + if !self.any_flip_pending() {
1465 + return 0;
1466 + }
1467 + let mut fds = [PollFd::new(&self.fd, PollFlags::IN)];
1468 + match poll(&mut fds, timeout_ms) {
1469 + Ok(0) | Err(_) => return 0,
1470 + Ok(_) => {}
1471 + }
1472 + let mut events = 0usize;
1473 + let mut buf = [0u8; 1024];
1474 + loop {
1424 1475 match rustix::io::read(&self.fd, &mut buf) {
1425 1476 Ok(0) => break,
1426 1477 Ok(n) => {
@@ -1455,25 +1506,35 @@ impl DrmBackend {
1455 1506 if let Some(out) = self.outputs.get_mut(idx) {
1456 1507 out.flip_pending = false;
1457 1508 }
1509 + events += 1;
1458 1510 }
1459 1511 offset += len;
1460 1512 }
1461 1513 }
1462 - Err(rustix::io::Errno::INTR | rustix::io::Errno::AGAIN) => continue,
1514 + Err(rustix::io::Errno::INTR | rustix::io::Errno::AGAIN) => break,
1463 1515 Err(_) => break,
1464 1516 }
1465 1517 }
1466 - // Timeout albo błąd odczytu: nie wiemy, które flipy się zakończyły.
1467 - // Zgubione zdarzenie nie może zablokować kompozytora na zawsze, więc
1468 - // zdejmujemy flagi — ale tylko tam, gdzie flip naprawdę wisiał, i każemy
1469 - // następnym klatkom iść w całości (stan buforów jest nieznany).
1470 - // Wcześniej robiliśmy to bezwarunkowo po każdym `wait_flips`, co kasowało
1471 - // całą optymalizację damage i samo powodowało pełne kopie 8 MB na klatkę.
1472 - for out in &mut self.outputs {
1473 - if out.flip_pending {
1474 - out.force_full_frames = 2;
1475 - out.flip_pending = false;
1518 + events
1519 + }
1520 +
1521 + pub fn wait_flips(&mut self) {
1522 + let deadline = std::time::Instant::now() + std::time::Duration::from_millis(200);
1523 + while self.any_flip_pending() {
1524 + if std::time::Instant::now() >= deadline {
1525 + // Timeout albo zgubione zdarzenie: nie wiemy, co skanuje CRTC.
1526 + // Zdejmujemy flagi tylko tam, gdzie flip naprawdę wisiał, i każemy
1527 + // następnym klatkom iść w całości (stan buforów jest nieznany).
1528 + for out in &mut self.outputs {
1529 + if out.flip_pending {
1530 + out.force_full_frames = 2;
1531 + out.flip_pending = false;
1532 + }
1533 + }
1534 + return;
1476 1535 }
1536 + // Krótkie okna, żeby nie przegapić deadline'u przy zgubionym zdarzeniu.
1537 + let _ = self.poll_flips(16);
1477 1538 }
1478 1539 }
1479 1540
@@ -643,6 +643,7 @@ pub fn spawn_drm(
643 643 let mut frames = 0u64;
644 644 let (mut ms_render, mut ms_present, mut ms_wait) = (0.0f64, 0.0f64, 0.0f64);
645 645 let mut report = std::time::Instant::now();
646 + let mut present_stats = backend.take_present_stats();
646 647 let mut last_sigs: Vec<Option<u64>> = vec![None; sizes.len()];
647 648 let mut last_cur: Option<Point> = None;
648 649 // Damage (tylko GPU): poprzednia scena per wyjście i prostokąt skopiowany
@@ -655,6 +656,9 @@ pub fn spawn_drm(
655 656 let mut last_present = std::time::Instant::now();
656 657 // Flipy zakolejkowane w poprzedniej iteracji, na które jeszcze nie czekaliśmy.
657 658 let mut pending_flips = 0usize;
659 + // Klatki narysowane, ale jeszcze nie pokazane (CRTC czekał na vblank).
660 + // Dzięki temu 60 Hz HDMI nie blokuje 75 Hz DP-1.
661 + let mut pending_present = vec![false; sizes.len()];
658 662 // Wykrywanie powrotu z uśpienia: pętla po suspendzie wznawia się po
659 663 // wielosekundowej przerwie. Jądro mogło zgubić stan CRTC, a zdarzenia
660 664 // flipów sprzed snu nie dotyczą już nowych klatek.
@@ -677,6 +681,7 @@ pub fn spawn_drm(
677 681 last_sigs = vec![None; sizes.len()];
678 682 prev_scene = vec![None; sizes.len()];
679 683 prev_damage = vec![None; sizes.len()];
684 + pending_present = vec![false; sizes.len()];
680 685 cursor_shown = vec![false; sizes.len()];
681 686 applied_night = None;
682 687 applied_power = false;
@@ -740,6 +745,7 @@ pub fn spawn_drm(
740 745 pending_flips = 0;
741 746 present.presented();
742 747 }
748 + pending_present = vec![false; sizes.len()];
743 749 last_present = std::time::Instant::now();
744 750 // Modeset zresetował płaszczyznę kursora — ładujemy ją ponownie.
745 751 hw_cursor =
@@ -849,6 +855,7 @@ pub fn spawn_drm(
849 855 prev_scene = vec![None; sizes.len()];
850 856 prev_damage = vec![None; sizes.len()];
851 857 last_present = std::time::Instant::now();
858 + pending_present = vec![false; sizes.len()];
852 859 // Modeset odtworzył bufory — zdarzenia flipów sprzed zmiany
853 860 // trybu nie dotyczą już nowych framebufferów.
854 861 if pending_flips > 0 {
@@ -1041,6 +1048,14 @@ pub fn spawn_drm(
1041 1048 }
1042 1049 }
1043 1050
1051 + // Wyjście z klatką czekającą na vblank nie renderuje kolejnej — najpierw
1052 + // musi pokazać tę, inaczej damage opisuje inną zawartość bufora.
1053 + for (i, pending) in pending_present.iter().enumerate() {
1054 + if *pending {
1055 + changed[i] = false;
1056 + }
1057 + }
1058 +
1044 1059 // Zwolnienia buforów czekają na prezentację. Gdy scena się nie zmieniła
1045 1060 // (np. okno jest na innej przestrzeni), wymuś klatkę — inaczej klient
1046 1061 // nigdy nie dostanie `wl_buffer.release` i stanie. Callbacki NIE wymuszają
@@ -1052,14 +1067,16 @@ pub fn spawn_drm(
1052 1067 any_changed = true;
1053 1068 }
1054 1069
1055 - if !any_changed && !cur_changed {
1056 - if pending_flips > 0 {
1070 + let any_pending_present = pending_present.iter().any(|p| *p);
1071 + if !any_changed && !cur_changed && !any_pending_present {
1072 + if backend.any_flip_pending() {
1057 1073 let t = std::time::Instant::now();
1058 - backend.wait_flips();
1074 + if backend.poll_flips(16) > 0 {
1075 + present.presented();
1076 + }
1059 1077 ms_wait += t.elapsed().as_secs_f64() * 1000.0;
1060 - pending_flips = 0;
1061 - present.presented();
1062 1078 }
1079 + pending_flips = 0;
1063 1080 if present.has_pending_frames() {
1064 1081 // Pacing ~60 Hz bez przerysowywania pulpitu; jeśli w międzyczasie
1065 1082 // przyjdzie commit lub wejście, wstajemy natychmiast zamiast spać 16 ms.
@@ -1176,24 +1193,25 @@ pub fn spawn_drm(
1176 1193 }
1177 1194 ms_render += t_render.elapsed().as_secs_f64() * 1000.0;
1178 1195
1179 - // Dopiero teraz czekamy na flipy poprzedniej klatki. Cały render
1180 - // i readback zdążyły się wykonać **w trakcie** skanowania
1181 - // poprzedniej klatki, więc nie dokładają się do okresu odświeżania
1182 - // (wcześniej czekanie stało na początku iteracji i przy 60 Hz
1183 - // każde opóźnienie renderu kosztowało cały vblank — YouTube spadał
1184 - // z 60 do 30 klatek).
1185 - if pending_flips > 0 {
1186 - let t = std::time::Instant::now();
1187 - backend.wait_flips();
1188 - ms_wait += t.elapsed().as_secs_f64() * 1000.0;
1189 - // Flipy się zakończyły — klatki są na ekranie. Dopiero teraz
1190 - // oddajemy klientom bufory, których już nikt nie skanuje.
1196 + // Zbierz flipy, które już się zakończyły — bez czekania na
1197 + // wolniejsze wyjście (to ono decydowało o fps całej sesji).
1198 + if backend.poll_flips(0) > 0 {
1191 1199 present.presented();
1192 1200 }
1193 1201
1194 1202 let mut num_flips = 0;
1203 + let mut blocked = 0usize;
1195 1204 for i in 0..sizes.len() {
1196 - if !changed[i] {
1205 + if !changed[i] && !pending_present[i] {
1206 + continue;
1207 + }
1208 + if backend.flip_pending(i) {
1209 + // CRTC jeszcze skanuje poprzednią klatkę — kolejny
1210 + // `PAGE_FLIP` zwróciłby `EBUSY`. Klatka zostaje
1211 + // w rendererze, a bufor trzeba będzie skopiować w całości.
1212 + pending_present[i] = true;
1213 + backend.force_full(i);
1214 + blocked += 1;
1197 1215 continue;
1198 1216 }
1199 1217 let t = std::time::Instant::now();
@@ -1248,12 +1266,25 @@ pub fn spawn_drm(
1248 1266 ms_present += t.elapsed().as_secs_f64() * 1000.0;
1249 1267
1250 1268 if flipped {
1269 + pending_present[i] = false;
1251 1270 num_flips += 1;
1271 + } else {
1272 + // Nie udało się (np. niezgodny rozmiar ramki) — nie ponawiamy
1273 + // w kółko: następna zmiana sceny narysuje wszystko od nowa
1274 + // (`present_region` ustawia wtedy `force_full_frames`).
1275 + pending_present[i] = false;
1252 1276 }
1253 1277 }
1254 1278
1255 - // Czekanie na flipy przenosimy na początek następnej iteracji
1256 - // (patrz `pending_flips` wyżej) — tutaj tylko je zapamiętujemy.
1279 + // Wszystkie wyjścia czekają na vblank — śpij do najbliższego
1280 + // zdarzenia zamiast kręcić pętlą albo czekać na wolniejsze.
1281 + if num_flips == 0 && blocked > 0 {
1282 + let t = std::time::Instant::now();
1283 + if backend.poll_flips(16) > 0 {
1284 + present.presented();
1285 + }
1286 + ms_wait += t.elapsed().as_secs_f64() * 1000.0;
1287 + }
1257 1288 pending_flips = num_flips;
1258 1289 if num_flips > 0 {
1259 1290 present.mark_submitted();
@@ -1265,12 +1296,16 @@ pub fn spawn_drm(
1265 1296 let frames_f = frames.max(1) as f64;
1266 1297 let per_monitor = frames_f * sizes.len() as f64;
1267 1298 eprintln!(
1268 - "selene/drm: {:.1} klatek/s | render {:.2} ms/klatke, present {:.2} ms, wait_flip {:.2} ms",
1299 + "selene/drm: {:.1} klatek/s | render {:.2} ms/klatke, present {:.2} ms, wait_flip {:.2} ms | pełne {}, damage {}, dmabuf {}",
1269 1300 frames as f64 / secs,
1270 1301 ms_render / frames_f,
1271 1302 ms_present / per_monitor.max(1.0),
1272 - ms_wait / per_monitor.max(1.0)
1303 + ms_wait / per_monitor.max(1.0),
1304 + present_stats.0,
1305 + present_stats.1,
1306 + present_stats.2
1273 1307 );
1308 + present_stats = backend.take_present_stats();
1274 1309 frames = 0;
1275 1310 ms_render = 0.0;
1276 1311 ms_present = 0.0;