Commit e26de76
3
plików
+75
dodanych
-182
usuniętych
@@ -263,17 +263,6 @@ 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 -
277 266 **Pacing (zrobione):** czekanie na flipy stoi **przed prezentacją**, a nie na
278 267 początku iteracji: scena i readback bieżącej klatki liczą się w trakcie skanowania
279 268 poprzedniej, więc opóźnienie renderu nie przepada jako cały vblank (wcześniej
@@ -872,13 +872,6 @@ 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,
882 875 }
883 876
884 877 impl Drop for DrmBackend {
@@ -966,9 +959,6 @@ impl DrmBackend {
966 959 fd,
967 960 outputs,
968 961 driver,
969 - stat_full: 0,
970 - stat_partial: 0,
971 - stat_dmabuf: 0,
972 962 });
973 963 }
974 964 Err(last)
@@ -1173,32 +1163,28 @@ impl DrmBackend {
1173 1163 // Framebuffery `dmabuf`, których CRTC już nie skanuje, można oddać dopiero
1174 1164 // teraz — po odebraniu `FLIP_COMPLETE`.
1175 1165 self.prune_dmabuf_fbs(idx);
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 {
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 {
1202 1188 return false;
1203 1189 };
1204 1190 // Rozmiar klatki renderera musi zgadzać się z trybem wyjścia. Gdy się nie
@@ -1227,26 +1213,9 @@ impl DrmBackend {
1227 1213 out.front = back;
1228 1214 out.front_dmabuf = false;
1229 1215 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 - }
1235 1216 true
1236 1217 }
1237 1218
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 -
1250 1219 /// Czeka, aż wyjście `idx` nie ma oczekującego flipa (z limitem czasu).
1251 1220 ///
1252 1221 /// Normalnie flaga jest już zdjęta przez `wait_flips()` w pętli kompozytora;
@@ -1422,7 +1391,6 @@ impl DrmBackend {
1422 1391 // Bufory `dumb` nie są już aktualne — dopiero po powrocie na readback
1423 1392 // trzeba będzie skopiować całą klatkę.
1424 1393 out.force_full_frames = 2;
1425 - self.stat_dmabuf += 1;
1426 1394 true
1427 1395 }
1428 1396
@@ -1430,48 +1398,29 @@ impl DrmBackend {
1430 1398 ///
1431 1399 /// Obsługuje wiele monitorów naraz (dopasowując `user_data` do indeksu wyjścia),
1432 1400 /// `EINTR` na `poll`/`read` oraz bezpieczny limit czasu po suspend/resume.
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 - }
1440 -
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;
1454 - }
1455 - }
1456 -
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 {
1401 + pub fn wait_flips(&mut self) {
1463 1402 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(_) => {}
1403 + use std::time::{Duration, Instant};
1404 +
1405 + if !self.outputs.iter().any(|o| o.flip_pending) {
1406 + return;
1471 1407 }
1472 - let mut events = 0usize;
1408 + let deadline = Instant::now() + Duration::from_millis(200);
1473 1409 let mut buf = [0u8; 1024];
1474 - loop {
1410 +
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 + }
1475 1424 match rustix::io::read(&self.fd, &mut buf) {
1476 1425 Ok(0) => break,
1477 1426 Ok(n) => {
@@ -1506,35 +1455,25 @@ impl DrmBackend {
1506 1455 if let Some(out) = self.outputs.get_mut(idx) {
1507 1456 out.flip_pending = false;
1508 1457 }
1509 - events += 1;
1510 1458 }
1511 1459 offset += len;
1512 1460 }
1513 1461 }
1514 - Err(rustix::io::Errno::INTR | rustix::io::Errno::AGAIN) => break,
1462 + Err(rustix::io::Errno::INTR | rustix::io::Errno::AGAIN) => continue,
1515 1463 Err(_) => break,
1516 1464 }
1517 1465 }
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;
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;
1535 1476 }
1536 - // Krótkie okna, żeby nie przegapić deadline'u przy zgubionym zdarzeniu.
1537 - let _ = self.poll_flips(16);
1538 1477 }
1539 1478 }
1540 1479
@@ -643,7 +643,6 @@ 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();
647 646 let mut last_sigs: Vec<Option<u64>> = vec![None; sizes.len()];
648 647 let mut last_cur: Option<Point> = None;
649 648 // Damage (tylko GPU): poprzednia scena per wyjście i prostokąt skopiowany
@@ -656,9 +655,6 @@ pub fn spawn_drm(
656 655 let mut last_present = std::time::Instant::now();
657 656 // Flipy zakolejkowane w poprzedniej iteracji, na które jeszcze nie czekaliśmy.
658 657 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()];
662 658 // Wykrywanie powrotu z uśpienia: pętla po suspendzie wznawia się po
663 659 // wielosekundowej przerwie. Jądro mogło zgubić stan CRTC, a zdarzenia
664 660 // flipów sprzed snu nie dotyczą już nowych klatek.
@@ -681,7 +677,6 @@ pub fn spawn_drm(
681 677 last_sigs = vec![None; sizes.len()];
682 678 prev_scene = vec![None; sizes.len()];
683 679 prev_damage = vec![None; sizes.len()];
684 - pending_present = vec![false; sizes.len()];
685 680 cursor_shown = vec![false; sizes.len()];
686 681 applied_night = None;
687 682 applied_power = false;
@@ -745,7 +740,6 @@ pub fn spawn_drm(
745 740 pending_flips = 0;
746 741 present.presented();
747 742 }
748 - pending_present = vec![false; sizes.len()];
749 743 last_present = std::time::Instant::now();
750 744 // Modeset zresetował płaszczyznę kursora — ładujemy ją ponownie.
751 745 hw_cursor =
@@ -855,7 +849,6 @@ pub fn spawn_drm(
855 849 prev_scene = vec![None; sizes.len()];
856 850 prev_damage = vec![None; sizes.len()];
857 851 last_present = std::time::Instant::now();
858 - pending_present = vec![false; sizes.len()];
859 852 // Modeset odtworzył bufory — zdarzenia flipów sprzed zmiany
860 853 // trybu nie dotyczą już nowych framebufferów.
861 854 if pending_flips > 0 {
@@ -1048,14 +1041,6 @@ pub fn spawn_drm(
1048 1041 }
1049 1042 }
1050 1043
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 -
1059 1044 // Zwolnienia buforów czekają na prezentację. Gdy scena się nie zmieniła
1060 1045 // (np. okno jest na innej przestrzeni), wymuś klatkę — inaczej klient
1061 1046 // nigdy nie dostanie `wl_buffer.release` i stanie. Callbacki NIE wymuszają
@@ -1067,16 +1052,14 @@ pub fn spawn_drm(
1067 1052 any_changed = true;
1068 1053 }
1069 1054
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() {
1055 + if !any_changed && !cur_changed {
1056 + if pending_flips > 0 {
1073 1057 let t = std::time::Instant::now();
1074 - if backend.poll_flips(16) > 0 {
1075 - present.presented();
1076 - }
1058 + backend.wait_flips();
1077 1059 ms_wait += t.elapsed().as_secs_f64() * 1000.0;
1060 + pending_flips = 0;
1061 + present.presented();
1078 1062 }
1079 - pending_flips = 0;
1080 1063 if present.has_pending_frames() {
1081 1064 // Pacing ~60 Hz bez przerysowywania pulpitu; jeśli w międzyczasie
1082 1065 // przyjdzie commit lub wejście, wstajemy natychmiast zamiast spać 16 ms.
@@ -1193,25 +1176,24 @@ pub fn spawn_drm(
1193 1176 }
1194 1177 ms_render += t_render.elapsed().as_secs_f64() * 1000.0;
1195 1178
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 {
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.
1199 1191 present.presented();
1200 1192 }
1201 1193
1202 1194 let mut num_flips = 0;
1203 - let mut blocked = 0usize;
1204 1195 for i in 0..sizes.len() {
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;
1196 + if !changed[i] {
1215 1197 continue;
1216 1198 }
1217 1199 let t = std::time::Instant::now();
@@ -1266,25 +1248,12 @@ pub fn spawn_drm(
1266 1248 ms_present += t.elapsed().as_secs_f64() * 1000.0;
1267 1249
1268 1250 if flipped {
1269 - pending_present[i] = false;
1270 1251 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;
1276 1252 }
1277 1253 }
1278 1254
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 - }
1255 + // Czekanie na flipy przenosimy na początek następnej iteracji
1256 + // (patrz `pending_flips` wyżej) — tutaj tylko je zapamiętujemy.
1288 1257 pending_flips = num_flips;
1289 1258 if num_flips > 0 {
1290 1259 present.mark_submitted();
@@ -1296,16 +1265,12 @@ pub fn spawn_drm(
1296 1265 let frames_f = frames.max(1) as f64;
1297 1266 let per_monitor = frames_f * sizes.len() as f64;
1298 1267 eprintln!(
1299 - "selene/drm: {:.1} klatek/s | render {:.2} ms/klatke, present {:.2} ms, wait_flip {:.2} ms | pełne {}, damage {}, dmabuf {}",
1268 + "selene/drm: {:.1} klatek/s | render {:.2} ms/klatke, present {:.2} ms, wait_flip {:.2} ms",
1300 1269 frames as f64 / secs,
1301 1270 ms_render / frames_f,
1302 1271 ms_present / 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
1272 + ms_wait / per_monitor.max(1.0)
1307 1273 );
1308 - present_stats = backend.take_present_stats();
1309 1274 frames = 0;
1310 1275 ms_render = 0.0;
1311 1276 ms_present = 0.0;