Commit 5c8abfa
6
plików
+558
dodanych
-117
usuniętych
@@ -263,10 +263,21 @@ 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 (zrobione):** czekanie na flipy przeniesione na początek następnej
267 -iteracji (`pending_flips`) — render bieżącej klatki nakłada się na skanowanie
268 -poprzedniej. Wcześniej `present` i `wait_flip` stały obok siebie, więc każda klatka
269 -płaciła pełny vblank i przy 75 Hz + 60 Hz gubiła terminy (spadki do ~16 kl./s).
266 +**Pacing (zrobione):** czekanie na flipy stoi **przed prezentacją**, a nie na
267 +początku iteracji: scena i readback bieżącej klatki liczą się w trakcie skanowania
268 +poprzedniej, więc opóźnienie renderu nie przepada jako cały vblank (wcześniej
269 +przy 60 Hz YouTube spadał z 60 do 30 klatek). Po `FLIP_COMPLETE` wątek wyjścia
270 +budzi pętlę główną (`present_wake`), która natychmiast wysyła klientom
271 +`wl_buffer.release` i `wl_callback.done` — bez czekania na ruch myszy.
272 +
273 +**Spójność buforów przy damage (zrobione):** `DrmOutput::force_full_frames`
274 +wymusza kopię **całej** klatki po zdarzeniach, które psują historię damage:
275 +po `present_dmabuf` (zero-copy zmienia framebuffer CRTC), po nieudanym flipie
276 +i po zmianie trybu/wybudzeniu. Bez tego przeglądarka rysująca mały fragment
277 +(pasek postępu wideo) dostawała go na starym tle — kwadratowe artefakty i
278 +mruganie wokół odtwarzacza. Framebuffery `dmabuf` są zwalniane wyłącznie po
279 +`FLIP_COMPLETE` (`flip_pending == false`): wcześniejsze `RMFB`/`GEM_CLOSE`
280 +kazało kernelowi skanować zwolnioną pamięć.
270 281
271 282 **Kontekst EGL per monitor (zrobione):** `Gl::bind()` przed każdym `draw`
272 283 — bez tego drugi monitor rysował w obiekty pierwszego (migotanie i treść w złym
@@ -56,6 +56,10 @@ const DRM_FORMAT_XRGB8888: u32 = 0x3432_5258;
56 56 /// Cztery znaki `XBGR8888` (kolejność bajtów R,G,B,X) — **taka sama jak wyjście
57 57 /// tiny-skia**, więc klatkę można skopiować bez przepisywania kanałów.
58 58 const DRM_FORMAT_XBGR8888: u32 = 0x3432_4258;
59 +/// Cztery znaki `ABGR8888` (kolejność bajtów R,G,B,A) — domyślny eksport `GL_RGBA8` z EGL.
60 +const DRM_FORMAT_ABGR8888: u32 = 0x3432_4241;
61 +/// `DRM_FORMAT_MOD_INVALID` — brak jawnego modyfikatora (np. starsze sterowniki EGL).
62 +const DRM_FORMAT_MOD_INVALID: u64 = 0x00ff_ffff_ffff_ffff;
59 63 /// Cztery znaki `ARGB8888` (kolejność bajtów B,G,R,A) — format kursora.
60 64 const DRM_FORMAT_ARGB8888: u32 = 0x3432_5241;
61 65 /// `DRM_MODE_CURSOR_BO` — ustaw obraz kursora (albo wyłącz, gdy `handle` = 0).
@@ -796,6 +800,58 @@ struct DrmOutput {
796 800 /// Trzymamy je do momentu, gdy flip je zastąpi — wcześniejsze zwolnienie
797 801 /// kazałoby kernelowi skanować zwolnioną pamięć.
798 802 dmabuf_fbs: std::collections::VecDeque<(u32, Vec<u32>)>,
803 + /// Czy CRTC skanuje teraz framebuffer z `dmabuf` (zero-copy).
804 + ///
805 + /// Po udanym `present_dmabuf` bufory `dumb` są nieaktualne, a ostatni fb
806 + /// z `dmabuf_fbs` jest skanowany — nie wolno go jeszcze zwalniać.
807 + front_dmabuf: bool,
808 + /// Czy na tym CRTC wisi flip, na który nie odebraliśmy jeszcze
809 + /// `DRM_EVENT_FLIP_COMPLETE`.
810 + ///
811 + /// Dopóki jest `true`, nie wolno zwalniać framebufferów `dmabuf` (kernel może
812 + /// je jeszcze skanować) ani wysyłać kolejnego `PAGE_FLIP` (jądro zwróci
813 + /// `EBUSY`). Flaga schodzi dopiero po zdarzeniu z pasującym `user_data`.
814 + flip_pending: bool,
815 + /// Ile najbliższych prezentacji musi skopiować **całą** klatkę, mimo damage.
816 + ///
817 + /// Oba bufory `DumbBuffer` są spójne z historią damage tylko wtedy, gdy
818 + /// poprzednie klatki przeszły przez `present_region`. Po zero-copy
819 + /// (`present_dmabuf` zmienia framebuffer CRTC), po nieudanym flipie i po
820 + /// zmianie trybu/wybudzeniu zawartość „back” jest nieaktualna — wtedy damage
821 + /// rysowałby nowy fragment na starym tle (kwadratowe artefakty, mruganie
822 + /// wokół odtwarzacza wideo). Wartość 2 pokrywa podwójne buforowanie.
823 + force_full_frames: u8,
824 +}
825 +
826 +/// Region do skopiowania w `present_region`: `force_full_frames > 0` wymusza całą klatkę.
827 +///
828 +/// Damage jest poprawny tylko wtedy, gdy **oba** bufory `dumb` przeszły w poprzednich
829 +/// klatkach przez `present_region`. Po zero-copy (`present_dmabuf` zmienia framebuffer
830 +/// CRTC), po nieudanym flipie i po zmianie trybu/wybudzeniu zawartość bufora „back”
831 +/// jest nieaktualna — wtedy nowy fragment trafiłby na stare tło (kwadratowe artefakty
832 +/// i mruganie wokół odtwarzacza wideo w przeglądarce).
833 +fn effective_region(force_full_frames: u8, region: Option<PixelRect>) -> Option<PixelRect> {
834 + if force_full_frames > 0 {
835 + None
836 + } else {
837 + region
838 + }
839 +}
840 +
841 +/// Ile framebufferów `dmabuf` musi pozostać w kolejce wyjścia.
842 +///
843 +/// `None` = nie wolno nic zwalniać: flip jeszcze trwa i kernel może skanować
844 +/// dowolny z zakolejkowanych buforów. `Some(1)` = CRTC skanuje najnowszy fb
845 +/// `dmabuf` (starsze wolno oddać). `Some(0)` = CRTC skanuje bufor `dumb`, więc
846 +/// wszystkie framebuffery `dmabuf` są wolne.
847 +fn dmabuf_keep(flip_pending: bool, front_dmabuf: bool) -> Option<usize> {
848 + if flip_pending {
849 + None
850 + } else if front_dmabuf {
851 + Some(1)
852 + } else {
853 + Some(0)
854 + }
799 855 }
800 856
801 857 /// Powód, dla którego nie udało się otworzyć wyjścia DRM (do diagnostyki).
@@ -820,6 +876,20 @@ pub struct DrmBackend {
820 876
821 877 impl Drop for DrmBackend {
822 878 fn drop(&mut self) {
879 + let fd = self.fd.as_fd();
880 + for out in &mut self.outputs {
881 + for (fb, handles) in out.dmabuf_fbs.drain(..) {
882 + destroy_fb(fd, fb);
883 + release_gem(fd, &handles);
884 + }
885 + for buf in &out.buffers {
886 + destroy_fb(fd, buf.fb_id);
887 + destroy_dumb(fd, buf.handle);
888 + }
889 + if let Some(cur) = out.cursor.take() {
890 + destroy_dumb(fd, cur.handle);
891 + }
892 + }
823 893 // Zwolnij bycie masterem, gdy kończymy.
824 894 let _ = ioctl_none::<DRM_IOCTL_DROP_MASTER, _>(&self.fd);
825 895 }
@@ -950,6 +1020,10 @@ impl DrmBackend {
950 1020 let _ = ioctl_none::<DRM_IOCTL_SET_MASTER, _>(&fd);
951 1021 let mut ok = true;
952 1022 for out in &mut self.outputs {
1023 + out.flip_pending = false;
1024 + out.front_dmabuf = false;
1025 + // Po wybudzeniu zawartość buforów jest nieznana.
1026 + out.force_full_frames = 2;
953 1027 let wanted = OutputMode::new(out.width as u16, out.height as u16, out.hz as u16);
954 1028 let Some(mode) = pick_mode(&out.raw_modes, Some(wanted)).copied() else {
955 1029 ok = false;
@@ -1030,12 +1104,16 @@ impl DrmBackend {
1030 1104 let out = &mut self.outputs[index];
1031 1105 for old in &out.buffers {
1032 1106 destroy_fb(fd, old.fb_id);
1107 + destroy_dumb(fd, old.handle);
1033 1108 }
1034 1109 out.width = width;
1035 1110 out.height = height;
1036 1111 out.hz = mode.vrefresh;
1037 1112 out.swizzle = swizzle;
1038 1113 out.front = 0;
1114 + out.flip_pending = false;
1115 + out.front_dmabuf = false;
1116 + out.force_full_frames = 2;
1039 1117 out.buffers = [b0, b1];
1040 1118 // Bufory zero-copy sprzed zmiany trybu nie pasują już do nowego framebuffera.
1041 1119 for (fb, handles) in out.dmabuf_fbs.drain(..) {
@@ -1043,7 +1121,9 @@ impl DrmBackend {
1043 1121 release_gem(fd, &handles);
1044 1122 }
1045 1123 // Bufor kursora zostanie utworzony na nowo przy następnym ruchu.
1046 - out.cursor = None;
1124 + if let Some(cur) = out.cursor.take() {
1125 + destroy_dumb(fd, cur.handle);
1126 + }
1047 1127 Some(index)
1048 1128 }
1049 1129
@@ -1077,46 +1157,131 @@ impl DrmBackend {
1077 1157 /// ostatnich klatek: bufor docelowy był ostatnio prezentowany dwa flipy temu.
1078 1158 /// `None` = cała klatka (bezpieczny fallback).
1079 1159 pub fn present_region(&mut self, idx: usize, rgba: &[u8], region: Option<PixelRect>) -> bool {
1080 - let fd = &self.fd;
1081 - let Some(out) = self.outputs.get_mut(idx) else {
1160 + // Flipy poprzedniej klatki muszą się zakończyć, zanim nadpiszemy bufor,
1161 + // który kernel jeszcze skanuje (i zanim wyślemy kolejny — inaczej `EBUSY`).
1162 + self.settle_flips(idx);
1163 + // Framebuffery `dmabuf`, których CRTC już nie skanuje, można oddać dopiero
1164 + // teraz — po odebraniu `FLIP_COMPLETE`.
1165 + 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 {
1082 1188 return false;
1083 1189 };
1084 - let back = (out.front + 1) & 1;
1085 - let (ptr, pitch) = (out.buffers[back].ptr, out.buffers[back].pitch);
1086 - let (w, h) = (out.width as usize, out.height as usize);
1087 - let copied = match (region, out.swizzle) {
1088 - (None, true) => swizzle_into(ptr, pitch, rgba, w, h),
1089 - (None, false) => copy_rows_into(ptr, pitch, rgba, w, h),
1090 - (Some(r), true) => swizzle_region_into(ptr, pitch, rgba, w, h, r),
1091 - (Some(r), false) => copy_region_into(ptr, pitch, rgba, w, h, r),
1092 - };
1093 1190 // Rozmiar klatki renderera musi zgadzać się z trybem wyjścia. Gdy się nie
1094 1191 // zgadza (np. renderer został z poprzedniego trybu), **nie wolno** robić
1095 1192 // page-flipu: pokazalibyśmy nieodświeżony bufor, czyli migotanie.
1096 1193 if !copied {
1194 + self.outputs[idx].force_full_frames = 2;
1097 1195 if std::env::var("SELENE_STATS").is_ok() {
1098 1196 eprintln!(
1099 1197 "selene/drm: {} pominięty flip — klatka {} B, wyjście {}x{}",
1100 - out.name,
1198 + name,
1101 1199 rgba.len(),
1102 - out.width,
1103 - out.height
1200 + width,
1201 + height
1104 1202 );
1105 1203 }
1106 1204 return false;
1107 1205 }
1206 + if !self.queue_page_flip(idx, fb_id) {
1207 + // Bufor „back” nie trafił na ekran — następna klatka musi być pełna,
1208 + // inaczej damage narysuje fragment na nieaktualnej zawartości.
1209 + self.outputs[idx].force_full_frames = 2;
1210 + return false;
1211 + }
1212 + let out = &mut self.outputs[idx];
1213 + out.front = back;
1214 + out.front_dmabuf = false;
1215 + out.force_full_frames = out.force_full_frames.saturating_sub(1);
1216 + true
1217 + }
1218 +
1219 + /// Czeka, aż wyjście `idx` nie ma oczekującego flipa (z limitem czasu).
1220 + ///
1221 + /// Normalnie flaga jest już zdjęta przez `wait_flips()` w pętli kompozytora;
1222 + /// to zabezpieczenie na wypadek zgubionego zdarzenia albo wywołania
1223 + /// prezentacji poza główną pętlą.
1224 + fn settle_flips(&mut self, idx: usize) {
1225 + for _ in 0..2 {
1226 + if !self.outputs.get(idx).is_some_and(|out| out.flip_pending) {
1227 + return;
1228 + }
1229 + self.wait_flips();
1230 + }
1231 + }
1232 +
1233 + /// Zwalnia framebuffery `dmabuf`, których CRTC już nie skanuje.
1234 + ///
1235 + /// Wolno to zrobić **tylko** bez oczekującego flipa: po `FLIP_COMPLETE`
1236 + /// aktywne są albo bufory `dumb` (wtedy wszystkie fb `dmabuf` są wolne),
1237 + /// albo ostatni fb `dmabuf` (wtedy wolno zwolnić starsze, nie ten).
1238 + fn prune_dmabuf_fbs(&mut self, idx: usize) {
1239 + let Some(keep) = self
1240 + .outputs
1241 + .get(idx)
1242 + .and_then(|out| dmabuf_keep(out.flip_pending, out.front_dmabuf))
1243 + else {
1244 + return;
1245 + };
1246 + let fd = self.fd.as_fd();
1247 + let out = &mut self.outputs[idx];
1248 + while out.dmabuf_fbs.len() > keep {
1249 + if let Some((fb, handles)) = out.dmabuf_fbs.pop_front() {
1250 + destroy_fb(fd, fb);
1251 + release_gem(fd, &handles);
1252 + }
1253 + }
1254 + }
1255 +
1256 + /// Kolejkuje page-flip na CRTC wyjścia `idx`; przy przejściowym `EBUSY`
1257 + /// zbiera zaległe zdarzenia flipów i ponawia raz.
1258 + fn queue_page_flip(&mut self, idx: usize, fb_id: u32) -> bool {
1259 + let Some(crtc_id) = self.outputs.get(idx).map(|o| o.crtc_id) else {
1260 + return false;
1261 + };
1108 1262 let req = ModePageFlip {
1109 - crtc_id: out.crtc_id,
1110 - fb_id: out.buffers[back].fb_id,
1263 + crtc_id,
1264 + fb_id,
1111 1265 flags: DRM_MODE_PAGE_FLIP_EVENT,
1112 1266 reserved: 0,
1113 1267 user_data: idx as u64,
1114 1268 };
1115 - if ioctl_rw::<ModePageFlip, DRM_IOCTL_MODE_PAGE_FLIP, _>(fd, req).is_err() {
1116 - return false;
1269 + match ioctl_rw::<ModePageFlip, DRM_IOCTL_MODE_PAGE_FLIP, _>(&self.fd, req) {
1270 + Ok(_) => {
1271 + self.outputs[idx].flip_pending = true;
1272 + true
1273 + }
1274 + Err(rustix::io::Errno::BUSY) => {
1275 + self.wait_flips();
1276 + if ioctl_rw::<ModePageFlip, DRM_IOCTL_MODE_PAGE_FLIP, _>(&self.fd, req).is_ok() {
1277 + self.outputs[idx].flip_pending = true;
1278 + true
1279 + } else {
1280 + false
1281 + }
1282 + }
1283 + Err(_) => false,
1117 1284 }
1118 - out.front = back;
1119 - true
1120 1285 }
1121 1286
1122 1287 /// Prezentuje klatkę **bez kopiowania przez CPU** (zero-copy skanout).
@@ -1126,8 +1291,7 @@ impl DrmBackend {
1126 1291 /// ioctlów. Zwraca `false`, gdy sterownik odrzucił bufor — wołający robi wtedy
1127 1292 /// zwykły readback (`present`), więc zero-copy nigdy nie psuje obrazu.
1128 1293 pub fn present_dmabuf(&mut self, idx: usize, frame: &ExportedFrame) -> bool {
1129 - let fd = self.fd.as_fd();
1130 - let Some(out) = self.outputs.get_mut(idx) else {
1294 + let Some((out_w, out_h)) = self.outputs.get(idx).map(|o| (o.width, o.height)) else {
1131 1295 return false;
1132 1296 };
1133 1297 let reject = |reason: &str| {
@@ -1139,8 +1303,8 @@ impl DrmBackend {
1139 1303 }
1140 1304 false
1141 1305 };
1142 - if frame.width != out.width
1143 - || frame.height != out.height
1306 + if frame.width != out_w
1307 + || frame.height != out_h
1144 1308 || frame.planes.is_empty()
1145 1309 || frame.planes.len() > 4
1146 1310 {
@@ -1148,18 +1312,13 @@ impl DrmBackend {
1148 1312 }
1149 1313 // Framebuffery z dwóch klatek wstecz są już po flipie (na flipy czekamy
1150 1314 // na początku iteracji), więc wolno je zwolnić.
1151 - while out.dmabuf_fbs.len() >= 2 {
1152 - if let Some((fb, handles)) = out.dmabuf_fbs.pop_front() {
1153 - destroy_fb(fd, fb);
1154 - for handle in handles {
1155 - let _ = ioctl_w::<GemClose, DRM_IOCTL_GEM_CLOSE, _>(
1156 - fd,
1157 - GemClose { handle, pad: 0 },
1158 - );
1159 - }
1160 - }
1161 - }
1315 + // Zero-copy też musi poczekać na zakończenie poprzedniego flipa — inaczej
1316 + // jądro zwróci `EBUSY` i klatka przepadnie. Przy okazji zwalniamy fb,
1317 + // których CRTC już nie skanuje (tylko po `FLIP_COMPLETE`).
1318 + self.settle_flips(idx);
1319 + self.prune_dmabuf_fbs(idx);
1162 1320
1321 + let fd = self.fd.as_fd();
1163 1322 let mut handles: Vec<u32> = Vec::with_capacity(frame.planes.len());
1164 1323 for (plane_fd, _offset, _stride) in &frame.planes {
1165 1324 let request = PrimeHandle {
@@ -1176,16 +1335,18 @@ impl DrmBackend {
1176 1335 }
1177 1336 }
1178 1337
1179 - // Bufor liniowy (`modifier == DRM_FORMAT_MOD_LINEAR`) dodajemy bez flagi
1180 - // `DRM_MODE_FB_MODIFIERS` — `nvidia-drm` zwraca `EINVAL`, gdy flaga jest
1181 - // ustawiona, nawet dla zera, a bez niej przyjmuje bufor bez zastrzeżeń.
1182 - let linear = frame.modifier == 0;
1338 + // Bufor liniowy (`0`) i brak modyfikatora (`DRM_FORMAT_MOD_INVALID` / `u64::MAX`)
1339 + // dodajemy bez flagi `DRM_MODE_FB_MODIFIERS` — `nvidia-drm` i starsze sterowniki
1340 + // zwracają `EINVAL`, gdy flaga jest ustawiona dla liniowego lub nieznanego modyfikatora.
1341 + let has_modifier = frame.modifier != 0
1342 + && frame.modifier != DRM_FORMAT_MOD_INVALID
1343 + && frame.modifier != u64::MAX;
1183 1344 let mut fb_desc = ModeFbCmd2 {
1184 1345 fb_id: 0,
1185 - width: out.width,
1186 - height: out.height,
1346 + width: out_w,
1347 + height: out_h,
1187 1348 pixel_format: frame.fourcc,
1188 - flags: if linear { 0 } else { 2 },
1349 + flags: if has_modifier { 2 } else { 0 },
1189 1350 ..ModeFbCmd2::default()
1190 1351 };
1191 1352 for (i, handle) in handles.iter().enumerate() {
@@ -1194,58 +1355,124 @@ impl DrmBackend {
1194 1355 for (i, (_, offset, stride)) in frame.planes.iter().enumerate() {
1195 1356 fb_desc.pitches[i] = *stride;
1196 1357 fb_desc.offsets[i] = *offset;
1197 - if !linear {
1358 + if has_modifier {
1198 1359 fb_desc.modifier[i] = frame.modifier;
1199 1360 }
1200 1361 }
1201 - let Ok(added) = ioctl_rw::<ModeFbCmd2, DRM_IOCTL_MODE_ADDFB2, _>(fd, fb_desc) else {
1202 - release_gem(fd, &handles);
1203 - return reject("ADDFB2");
1362 + let added = match ioctl_rw::<ModeFbCmd2, DRM_IOCTL_MODE_ADDFB2, _>(fd, fb_desc) {
1363 + Ok(added) if added.fb_id != 0 => added,
1364 + _ if frame.fourcc == DRM_FORMAT_ABGR8888 => {
1365 + // Część sterowników odrzuca format z kanałem alfa (`ABGR8888`) na
1366 + // płaszczyźnie głównej, ale akceptuje identyczny w pamięci `XBGR8888`.
1367 + fb_desc.pixel_format = DRM_FORMAT_XBGR8888;
1368 + match ioctl_rw::<ModeFbCmd2, DRM_IOCTL_MODE_ADDFB2, _>(fd, fb_desc) {
1369 + Ok(added) if added.fb_id != 0 => added,
1370 + _ => {
1371 + release_gem(fd, &handles);
1372 + return reject("ADDFB2");
1373 + }
1374 + }
1375 + }
1376 + _ => {
1377 + release_gem(fd, &handles);
1378 + return reject("ADDFB2");
1379 + }
1204 1380 };
1205 - if added.fb_id == 0 {
1206 - release_gem(fd, &handles);
1207 - return reject("ADDFB2 bez fb_id");
1208 - }
1209 1381
1210 - let req = ModePageFlip {
1211 - crtc_id: out.crtc_id,
1212 - fb_id: added.fb_id,
1213 - flags: DRM_MODE_PAGE_FLIP_EVENT,
1214 - reserved: 0,
1215 - user_data: idx as u64,
1216 - };
1217 - if ioctl_rw::<ModePageFlip, DRM_IOCTL_MODE_PAGE_FLIP, _>(fd, req).is_err() {
1382 + if !self.queue_page_flip(idx, added.fb_id) {
1383 + let fd = self.fd.as_fd();
1218 1384 destroy_fb(fd, added.fb_id);
1219 1385 release_gem(fd, &handles);
1220 1386 return reject("PAGE_FLIP");
1221 1387 }
1388 + let out = &mut self.outputs[idx];
1222 1389 out.dmabuf_fbs.push_back((added.fb_id, handles));
1390 + out.front_dmabuf = true;
1391 + // Bufory `dumb` nie są już aktualne — dopiero po powrocie na readback
1392 + // trzeba będzie skopiować całą klatkę.
1393 + out.force_full_frames = 2;
1223 1394 true
1224 1395 }
1225 1396
1226 - /// Czeka na zakończenie page-flipu (zdarzenie z jądra).
1397 + /// Czeka na zakończenie wszystkich oczekujących page-flipów (zdarzenia z jądra).
1227 1398 ///
1228 - /// Po suspend/resume zdarzenie flipa potrafi nigdy nie przyjść — wcześniej
1229 - /// `read` na blokującym deskryptorze wisiał wtedy w nieskończoność i ekran
1230 - /// zostawał czarny. Dlatego czekamy przez `poll` z limitem czasu.
1231 - pub fn wait_flip(&self) {
1399 + /// Obsługuje wiele monitorów naraz (dopasowując `user_data` do indeksu wyjścia),
1400 + /// `EINTR` na `poll`/`read` oraz bezpieczny limit czasu po suspend/resume.
1401 + pub fn wait_flips(&mut self) {
1232 1402 use rustix::event::{poll, PollFd, PollFlags};
1233 - let mut fds = [PollFd::new(&self.fd, PollFlags::IN)];
1234 - match poll(&mut fds, 200) {
1235 - Ok(0) => return,
1236 - Ok(_) => {}
1237 - Err(_) => return,
1403 + use std::time::{Duration, Instant};
1404 +
1405 + if !self.outputs.iter().any(|o| o.flip_pending) {
1406 + return;
1238 1407 }
1239 - let mut buf = [0u8; 32];
1240 - loop {
1408 + let deadline = Instant::now() + Duration::from_millis(200);
1409 + let mut buf = [0u8; 1024];
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 + }
1241 1424 match rustix::io::read(&self.fd, &mut buf) {
1242 - Ok(n) if n >= 8 => {
1243 - let ty = u32::from_ne_bytes([buf[0], buf[1], buf[2], buf[3]]);
1244 - if ty == DRM_EVENT_FLIP_COMPLETE {
1245 - return;
1425 + Ok(0) => break,
1426 + Ok(n) => {
1427 + let mut offset = 0usize;
1428 + while offset + 8 <= n {
1429 + let ty = u32::from_ne_bytes([
1430 + buf[offset],
1431 + buf[offset + 1],
1432 + buf[offset + 2],
1433 + buf[offset + 3],
1434 + ]);
1435 + let len = u32::from_ne_bytes([
1436 + buf[offset + 4],
1437 + buf[offset + 5],
1438 + buf[offset + 6],
1439 + buf[offset + 7],
1440 + ]) as usize;
1441 + if len < 8 || offset + len > n {
1442 + break;
1443 + }
1444 + if ty == DRM_EVENT_FLIP_COMPLETE && len >= 16 {
1445 + let idx = u64::from_ne_bytes([
1446 + buf[offset + 8],
1447 + buf[offset + 9],
1448 + buf[offset + 10],
1449 + buf[offset + 11],
1450 + buf[offset + 12],
1451 + buf[offset + 13],
1452 + buf[offset + 14],
1453 + buf[offset + 15],
1454 + ]) as usize;
1455 + if let Some(out) = self.outputs.get_mut(idx) {
1456 + out.flip_pending = false;
1457 + }
1458 + }
1459 + offset += len;
1246 1460 }
1247 1461 }
1248 - _ => return,
1462 + Err(rustix::io::Errno::INTR | rustix::io::Errno::AGAIN) => continue,
1463 + Err(_) => break,
1464 + }
1465 + }
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;
1249 1476 }
1250 1477 }
1251 1478 }
@@ -1469,6 +1696,11 @@ fn setup_output(
1469 1696 swizzle: format == DRM_FORMAT_XRGB8888,
1470 1697 cursor: None,
1471 1698 dmabuf_fbs: std::collections::VecDeque::new(),
1699 + front_dmabuf: false,
1700 + flip_pending: false,
1701 + // Pierwsze dwie klatki po starcie zawsze w całości (bufory są świeże,
1702 + // ale historia damage jeszcze nie istnieje).
1703 + force_full_frames: 2,
1472 1704 })
1473 1705 }
1474 1706
@@ -1835,6 +2067,31 @@ mod tests {
1835 2067 }
1836 2068 }
1837 2069
2070 + /// `force_full_frames` musi wymusić całą klatkę po zero-copy/nieudanym flipie.
2071 + #[test]
2072 + fn effective_region_respects_force_full() {
2073 + let r = PixelRect {
2074 + x: 10,
2075 + y: 20,
2076 + w: 100,
2077 + h: 50,
2078 + };
2079 + assert_eq!(effective_region(0, Some(r)), Some(r));
2080 + assert_eq!(effective_region(0, None), None);
2081 + assert_eq!(effective_region(1, Some(r)), None);
2082 + assert_eq!(effective_region(2, Some(r)), None);
2083 + }
2084 +
2085 + /// Nie wolno zwalniać fb `dmabuf`, dopóki flip się nie skończy (kernel może
2086 + /// je jeszcze skanować). Gdy CRTC skanuje `dumb`, wszystkie są wolne.
2087 + #[test]
2088 + fn dmabuf_keep_waits_for_flip_complete() {
2089 + assert_eq!(dmabuf_keep(true, true), None);
2090 + assert_eq!(dmabuf_keep(true, false), None);
2091 + assert_eq!(dmabuf_keep(false, true), Some(1));
2092 + assert_eq!(dmabuf_keep(false, false), Some(0));
2093 + }
2094 +
1838 2095 /// Prostokąt wystający poza bufor musi zostać przycięty, a nie wyjść poza pamieć.
1839 2096 #[test]
1840 2097 fn present_region_clamps_to_buffer() {
@@ -242,11 +242,15 @@ impl EvdevInput {
242 242 pub fn read_events(&mut self, bounds: (f64, f64)) -> Vec<Event> {
243 243 // Najpierw odczyt (pożyczka współdzielona urządzeń), potem tłumaczenie (mutacja).
244 244 let mut decoded = Vec::new();
245 - for dev in &self.devices {
245 + let mut dead = Vec::new();
246 + for (idx, dev) in self.devices.iter().enumerate() {
246 247 let mut buf = [0u8; std::mem::size_of::<RawEvent>() * 64];
247 248 loop {
248 249 match rustix::io::read(&dev.fd, &mut buf) {
249 - Ok(0) => break,
250 + Ok(0) => {
251 + dead.push(idx);
252 + break;
253 + }
250 254 Ok(n) => {
251 255 for chunk in buf[..n].chunks_exact(std::mem::size_of::<RawEvent>()) {
252 256 if let Some(ev) = decode(chunk) {
@@ -256,10 +260,24 @@ impl EvdevInput {
256 260 }
257 261 }
258 262 }
259 - Err(_) => break, // EAGAIN lub błąd — kończymy na tym urządzeniu
263 + Err(
264 + rustix::io::Errno::NODEV
265 + | rustix::io::Errno::NXIO
266 + | rustix::io::Errno::IO
267 + | rustix::io::Errno::BADF,
268 + ) => {
269 + // Odłączone urządzenie (np. odpięta mysz USB) — usuwamy,
270 + // żeby `poll()` w pętli głównej nie kręcił się na `POLLHUP`/`POLLERR`.
271 + dead.push(idx);
272 + break;
273 + }
274 + Err(_) => break, // EAGAIN lub EINTR — kończymy na tym urządzeniu
260 275 }
261 276 }
262 277 }
278 + for idx in dead.into_iter().rev() {
279 + self.devices.swap_remove(idx);
280 + }
263 281 let mut out = Vec::new();
264 282 for (abs, ev) in decoded {
265 283 self.apply(abs, ev, bounds, &mut out);
@@ -297,6 +297,13 @@ fn main() -> Result<(), Box<dyn Error>> {
297 297
298 298 // Magistrala wejścia (wątek wyjścia → wątek protokołu) z parą gniazd do wybudzania.
299 299 let (events, mut wake_read, wake_write) = input::channel();
300 + // Kanał wybudzania pętli głównej przez wątek wyjścia (po flipie / tick_frames),
301 + // żeby `display.flush_clients()` wysłało `wl_buffer.release` i `wl_callback.done` od razu.
302 + let (mut present_wake_read, present_wake_write) =
303 + std::os::unix::net::UnixStream::pair().expect("socketpair prezentacji");
304 + let _ = present_wake_read.set_nonblocking(true);
305 + state.present.set_wake(present_wake_write);
306 + let render_wake = output::RenderWake::new();
300 307
301 308 // Wyjście: realne DRM/KMS (gdy `SELENE_BACKEND=drm`) lub nested na nadrzędnym kompozytorze.
302 309 if std::env::var("SELENE_BACKEND").as_deref() == Ok("drm") {
@@ -313,6 +320,7 @@ fn main() -> Result<(), Box<dyn Error>> {
313 320 Arc::clone(&state.overview),
314 321 Arc::clone(&state.screenshot),
315 322 Arc::clone(&state.present),
323 + Arc::clone(&render_wake),
316 324 Arc::clone(&state.night_light),
317 325 Arc::clone(&state.power_saver),
318 326 Arc::clone(&state.outputs),
@@ -386,17 +394,19 @@ fn main() -> Result<(), Box<dyn Error>> {
386 394 }
387 395 let backend_fd = display.backend().poll_fd().as_raw_fd();
388 396 let wake_fd = wake_read.as_raw_fd();
397 + let present_wake_fd = present_wake_read.as_raw_fd();
389 398
390 399 let listener = unsafe { BorrowedFd::borrow_raw(listener_fd) };
391 400 let backend = unsafe { BorrowedFd::borrow_raw(backend_fd) };
392 401 let wake = unsafe { BorrowedFd::borrow_raw(wake_fd) };
402 + let present_wake = unsafe { BorrowedFd::borrow_raw(present_wake_fd) };
393 403 let input_raw = evdev_input.as_ref().map(|e| e.fds()).unwrap_or_default();
394 404 let input_fds: Vec<BorrowedFd> = input_raw
395 405 .iter()
396 406 .map(|&r| unsafe { BorrowedFd::borrow_raw(r) })
397 407 .collect();
398 408
399 - let mut fds = Vec::with_capacity(5 + input_fds.len());
409 + let mut fds = Vec::with_capacity(6 + input_fds.len());
400 410 fds.push(rustix::event::PollFd::new(
401 411 &listener,
402 412 rustix::event::PollFlags::IN,
@@ -423,6 +433,11 @@ fn main() -> Result<(), Box<dyn Error>> {
423 433 if let Some(fd) = &clipboard_dup {
424 434 fds.push(rustix::event::PollFd::new(fd, rustix::event::PollFlags::IN));
425 435 }
436 + let present_wake_idx = fds.len();
437 + fds.push(rustix::event::PollFd::new(
438 + &present_wake,
439 + rustix::event::PollFlags::IN,
440 + ));
426 441 // Budzimy się co ~16 ms przy skrypcie wejścia (dopisane polecenia) oraz gdy
427 442 // kursor stoi w „gorącym rogu” — poświata musi rosnąć, a aktywacja nie może
428 443 // zależeć od dalszego ruchu myszy. Bez tego budzimy się najpóźniej co sekundę,
@@ -439,7 +454,19 @@ fn main() -> Result<(), Box<dyn Error>> {
439 454 } else {
440 455 idle_wait.map(|ms| ms.clamp(16, 1000) as i32).unwrap_or(-1)
441 456 };
442 - rustix::event::poll(&mut fds, poll_timeout)?;
457 + match rustix::event::poll(&mut fds, poll_timeout) {
458 + Ok(_) => {}
459 + Err(rustix::io::Errno::INTR) => continue,
460 + Err(e) => return Err(e.into()),
461 + }
462 + if fds[present_wake_idx]
463 + .revents()
464 + .contains(rustix::event::PollFlags::IN)
465 + {
466 + use std::io::Read;
467 + let mut buf = [0u8; 64];
468 + while present_wake_read.read(&mut buf).is_ok_and(|n| n > 0) {}
469 + }
443 470
444 471 // Odliczanie przytrzymania w rogu (rysowanie poświaty i ewentualna akcja).
445 472 crate::seat::tick_corner(&mut state);
@@ -522,6 +549,8 @@ fn main() -> Result<(), Box<dyn Error>> {
522 549 xwm::sync(&mut state);
523 550 // Most schowka X11 → Wayland: XWM publikuje migawkę tekstu, my rozsyłamy oferty.
524 551 crate::data::sync_x11_selection(&mut state, &handle);
552 + // Obudź wątek DRM, jeśli komit/wejście/XWM mogło zmienić scenę.
553 + render_wake.notify();
525 554 // Nowe okno/popup pod **nieruchomym** kursorem musi dostać `wl_pointer.enter`.
526 555 // Bez tego menu przeglądarki nie podświetla pozycji, dopóki nie ruszysz myszą,
527 556 // a pierwszy klik bywa traktowany jak klik poza menu.
@@ -6,8 +6,52 @@
6 6 //! (page-flip). Wejście w trybie DRM (evdev) jest kolejnym krokiem.
7 7
8 8 use std::os::unix::net::UnixStream;
9 -use std::sync::Arc;
10 -use std::time::Duration;
9 +use std::sync::{Arc, Condvar, Mutex};
10 +use std::time::{Duration, Instant};
11 +
12 +/// Sygnał wybudzania wątku DRM przez pętlę główną (commit klienta, ruch kursora, zmiana okna).
13 +///
14 +/// Zastępuje bezczynne budzenie co 2 ms: w spoczynku wątek DRM śpi do 100 ms,
15 +/// a po zdarzeniu wstaje natychmiast bez opóźnienia kolejnej klatki.
16 +pub struct RenderWake {
17 + seq: Mutex<u64>,
18 + cv: Condvar,
19 +}
20 +
21 +impl RenderWake {
22 + pub fn new() -> Arc<Self> {
23 + Arc::new(Self {
24 + seq: Mutex::new(0),
25 + cv: Condvar::new(),
26 + })
27 + }
28 +
29 + pub fn notify(&self) {
30 + let mut seq = self.seq.lock_or_recover();
31 + *seq = seq.wrapping_add(1);
32 + self.cv.notify_one();
33 + }
34 +
35 + /// Czeka maksymalnie `timeout`, aż `seq` zmieni się względem `seen`.
36 + /// Zwraca `true`, jeśli nastąpiło wybudzenie przez `notify()`.
37 + pub fn wait_timeout(&self, seen: &mut u64, timeout: Duration) -> bool {
38 + let guard = self.seq.lock_or_recover();
39 + if *guard != *seen {
40 + *seen = *guard;
41 + return true;
42 + }
43 + let (guard, _) = self
44 + .cv
45 + .wait_timeout_while(guard, timeout, |s| *s == *seen)
46 + .unwrap_or_else(|e| e.into_inner());
47 + if *guard != *seen {
48 + *seen = *guard;
49 + true
50 + } else {
51 + false
52 + }
53 + }
54 +}
11 55
12 56 use libluna_core::style::weight;
13 57 use libluna_core::{Color, Point, Rect, Size, Theme, ThemeSettings};
@@ -337,6 +381,7 @@ pub fn spawn_drm(
337 381 overview: OverviewModel,
338 382 screenshot: crate::state::ScreenshotModel,
339 383 present: Arc<crate::present::PresentQueue>,
384 + render_wake: Arc<RenderWake>,
340 385 night_light: crate::state::NightLightModel,
341 386 power_saver: crate::state::PowerSaverModel,
342 387 outputs: Outputs,
@@ -614,6 +659,7 @@ pub fn spawn_drm(
614 659 // wielosekundowej przerwie. Jądro mogło zgubić stan CRTC, a zdarzenia
615 660 // flipów sprzed snu nie dotyczą już nowych klatek.
616 661 let mut last_loop = std::time::Instant::now();
662 + let mut seen_wake = 0u64;
617 663 loop {
618 664 let now = std::time::Instant::now();
619 665 if now.duration_since(last_loop) > Duration::from_secs(2) {
@@ -624,7 +670,10 @@ pub fn spawn_drm(
624 670 if !backend.resume() {
625 671 eprintln!("selene/drm: modeset po wybudzeniu nie powiódł się — próbuję dalej");
626 672 }
627 - pending_flips = 0;
673 + if pending_flips > 0 {
674 + pending_flips = 0;
675 + present.presented();
676 + }
628 677 last_sigs = vec![None; sizes.len()];
629 678 prev_scene = vec![None; sizes.len()];
630 679 prev_damage = vec![None; sizes.len()];
@@ -652,23 +701,9 @@ pub fn spawn_drm(
652 701 last_present = now;
653 702 }
654 703 last_loop = now;
655 - // Flipy **poprzedniej** klatki zbieramy dopiero teraz: dopiero po nich
656 - // wolno pisać do bufora, który był skanowany. Dzięki temu render i
657 - // readback bieżącej klatki nakładają się na vblank poprzedniej.
658 - // Wcześniej `present` i czekanie stały obok siebie, więc każda klatka
659 - // płaciła pełny vblank, a przy dwóch monitorach (75 Hz + 60 Hz) gubiła
660 - // terminy — stąd spadki do kilkunastu klatek na sekundę.
661 - if pending_flips > 0 {
662 - let t = std::time::Instant::now();
663 - for _ in 0..pending_flips {
664 - backend.wait_flip();
665 - }
666 - ms_wait += t.elapsed().as_secs_f64() * 1000.0;
667 - pending_flips = 0;
668 - // Flipy się zakończyły — klatki są na ekranie. Dopiero teraz
669 - // oddajemy klientom bufory, których już nikt nie skanuje.
670 - present.presented();
671 - }
704 + // Flipy **poprzedniej** klatki zbieramy dopiero przed prezentacją
705 + // bieżącej (patrz niżej): render i readback nakładają się wtedy na
706 + // vblank, a nie dokładają się do okresu klatki.
672 707 // Przełączenie VT (`Ctrl+Alt+F1…F12`). Najpierw oddajemy master DRM —
673 708 // bez tego konsola jądra (fbcon) nie przejmie ekranu i nowy VT jest
674 709 // czarny. Po powrocie robimy pełny modeset; `wait_active` blokuje ten
@@ -701,7 +736,10 @@ pub fn spawn_drm(
701 736 applied_night = None;
702 737 applied_power = false;
703 738 flip_error_logged = false;
704 - pending_flips = 0;
739 + if pending_flips > 0 {
740 + pending_flips = 0;
741 + present.presented();
742 + }
705 743 last_present = std::time::Instant::now();
706 744 // Modeset zresetował płaszczyznę kursora — ładujemy ją ponownie.
707 745 hw_cursor =
@@ -813,7 +851,10 @@ pub fn spawn_drm(
813 851 last_present = std::time::Instant::now();
814 852 // Modeset odtworzył bufory — zdarzenia flipów sprzed zmiany
815 853 // trybu nie dotyczą już nowych framebufferów.
816 - pending_flips = 0;
854 + if pending_flips > 0 {
855 + pending_flips = 0;
856 + present.presented();
857 + }
817 858 // Modeset zeruje LUT gamma — night light trzeba wgrać ponownie.
818 859 applied_night = None;
819 860
@@ -1012,12 +1053,21 @@ pub fn spawn_drm(
1012 1053 }
1013 1054
1014 1055 if !any_changed && !cur_changed {
1056 + if pending_flips > 0 {
1057 + let t = std::time::Instant::now();
1058 + backend.wait_flips();
1059 + ms_wait += t.elapsed().as_secs_f64() * 1000.0;
1060 + pending_flips = 0;
1061 + present.presented();
1062 + }
1015 1063 if present.has_pending_frames() {
1016 - // Pacing ~60 Hz bez przerysowywania pulpitu.
1017 - std::thread::sleep(Duration::from_millis(16));
1018 - present.tick_frames();
1064 + // Pacing ~60 Hz bez przerysowywania pulpitu; jeśli w międzyczasie
1065 + // przyjdzie commit lub wejście, wstajemy natychmiast zamiast spać 16 ms.
1066 + if !render_wake.wait_timeout(&mut seen_wake, Duration::from_millis(16)) {
1067 + present.tick_frames();
1068 + }
1019 1069 } else {
1020 - std::thread::sleep(Duration::from_millis(2));
1070 + render_wake.wait_timeout(&mut seen_wake, Duration::from_millis(100));
1021 1071 }
1022 1072 continue;
1023 1073 }
@@ -1126,6 +1176,21 @@ pub fn spawn_drm(
1126 1176 }
1127 1177 ms_render += t_render.elapsed().as_secs_f64() * 1000.0;
1128 1178
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.
1191 + present.presented();
1192 + }
1193 +
1129 1194 let mut num_flips = 0;
1130 1195 for i in 0..sizes.len() {
1131 1196 if !changed[i] {
@@ -1926,6 +1991,23 @@ fn wallpaper_for(w: u32, h: u32) -> Option<std::sync::Arc<ImageData>> {
1926 1991 ///
1927 1992 /// Kompozytor działa dalej bez restartu — wystarczy zapis `wallpaper.conf`.
1928 1993 fn wallpaper_stamp() -> u64 {
1994 + type StampCache = Option<(Instant, u64)>;
1995 + static CACHE: std::sync::OnceLock<Mutex<StampCache>> = std::sync::OnceLock::new();
1996 + let cache = CACHE.get_or_init(|| Mutex::new(None));
1997 + {
1998 + let guard = cache.lock_or_recover();
1999 + if let Some((checked_at, stamp)) = *guard {
2000 + if checked_at.elapsed() < Duration::from_millis(500) {
2001 + return stamp;
2002 + }
2003 + }
2004 + }
2005 + let stamp = compute_wallpaper_stamp();
2006 + *cache.lock_or_recover() = Some((Instant::now(), stamp));
2007 + stamp
2008 +}
2009 +
2010 +fn compute_wallpaper_stamp() -> u64 {
1929 2011 use std::hash::{Hash, Hasher};
1930 2012 let mut hasher = std::collections::hash_map::DefaultHasher::new();
1931 2013 for var in ["LUNA_WALLPAPER", "SELENE_WALLPAPER", "SELENE_NO_WALLPAPER"] {
@@ -12,8 +12,10 @@
12 12 //! po klatce nested). Numer sekwencji chroni przed wyścigiem: wysyłamy tylko
13 13 //! zdarzenia zakolejkowane przed ostatnią prezentacją.
14 14
15 +use std::io::Write;
16 +use std::os::unix::net::UnixStream;
15 17 use std::sync::atomic::{AtomicU64, Ordering};
16 -use std::sync::{Arc, Mutex};
18 +use std::sync::{Arc, Mutex, OnceLock};
17 19 use std::time::Instant;
18 20
19 21 use wayland_server::protocol::{wl_buffer, wl_callback};
@@ -35,6 +37,10 @@ pub struct PresentQueue {
35 37 /// Numer ostatniej klatki faktycznie pokazanej (po `wait_flip`).
36 38 presented: AtomicU64,
37 39 pending: Mutex<Vec<(u64, Item)>>,
40 + /// Opcjonalny deskryptor wybudzania pętli głównej (`main.rs`), żeby
41 + /// `display.flush_clients()` wysłało `wl_buffer.release` / `wl_callback.done`
42 + /// natychmiast po flipie zamiast czekać na ruch myszy lub timeout `poll`.
43 + wake: OnceLock<UnixStream>,
38 44 }
39 45
40 46 impl PresentQueue {
@@ -44,9 +50,22 @@ impl PresentQueue {
44 50 submitted: AtomicU64::new(0),
45 51 presented: AtomicU64::new(0),
46 52 pending: Mutex::new(Vec::new()),
53 + wake: OnceLock::new(),
47 54 })
48 55 }
49 56
57 + /// Rejestruje nieblokujący zapis wybudzający pętlę główną po wysłaniu zdarzeń.
58 + pub fn set_wake(&self, wake: UnixStream) {
59 + let _ = wake.set_nonblocking(true);
60 + let _ = self.wake.set(wake);
61 + }
62 +
63 + fn notify_wake(&self) {
64 + if let Some(mut w) = self.wake.get() {
65 + let _ = w.write(&[1u8]);
66 + }
67 + }
68 +
50 69 /// Odkłada zwolnienie bufora do najbliższej prezentacji klatki, która go zastąpiła.
51 70 pub fn release_after_present(
52 71 &self,
@@ -74,10 +93,11 @@ impl PresentQueue {
74 93
75 94 /// Wątek wyjścia: klatka została pokazana — wyślij zaległe zdarzenia.
76 95 pub fn presented(&self) {
77 - let seq = self.presented.fetch_add(1, Ordering::AcqRel) + 1;
78 - // Zdarzenie może czekać tylko wtedy, gdy po jego zakolejkowaniu powstała
79 - // i została pokazana co najmniej jedna klatka. Sam `presented` bez nowego
80 - // `submitted` to wyścig z commitem — wtedy czekamy do następnego obiegu.
96 + self.presented.fetch_add(1, Ordering::AcqRel);
97 + // Zdarzenie może wyjść dopiero wtedy, gdy po jego zakolejkowaniu
98 + // została przekazana i pokazana co najmniej jedna klatka (`at < rendered`).
99 + // Porównanie wyłącznie z `submitted` chroni przed rozjazdem liczników
100 + // po `resume()` lub `set_mode()`.
81 101 let rendered = self.submitted.load(Ordering::Acquire);
82 102 let due: Vec<Item> = {
83 103 let mut pending = self.pending.lock_or_recover();
@@ -85,7 +105,7 @@ impl PresentQueue {
85 105 let mut index = 0;
86 106 while index < pending.len() {
87 107 let at = pending[index].0;
88 - if at < seq && at < rendered {
108 + if at < rendered {
89 109 due.push(pending.swap_remove(index).1);
90 110 } else {
91 111 index += 1;
@@ -93,6 +113,9 @@ impl PresentQueue {
93 113 }
94 114 due
95 115 };
116 + if due.is_empty() {
117 + return;
118 + }
96 119 // Poza blokadą: `send_event` może obudzić klienta i wejść w backend.
97 120 let now = self.start.elapsed().as_millis() as u32;
98 121 for item in due {
@@ -108,6 +131,7 @@ impl PresentQueue {
108 131 }
109 132 }
110 133 }
134 + self.notify_wake();
111 135 }
112 136
113 137 /// Czy czeka bufor do zwolnienia (wymaga prezentacji nowej klatki).
@@ -145,12 +169,16 @@ impl PresentQueue {
145 169 }
146 170 due
147 171 };
172 + if due.is_empty() {
173 + return;
174 + }
148 175 let now = self.start.elapsed().as_millis() as u32;
149 176 for item in due {
150 177 if let Item::Frame(callback) = item {
151 178 let _ = callback.send_event(wl_callback::Event::Done { callback_data: now });
152 179 }
153 180 }
181 + self.notify_wake();
154 182 }
155 183
156 184 #[cfg(test)]
@@ -173,4 +201,20 @@ mod tests {
173 201 queue.presented();
174 202 assert_eq!(queue.presented.load(Ordering::Acquire), 1);
175 203 }
204 +
205 + #[test]
206 + fn presented_wakes_poll_fd_only_when_events_are_due() {
207 + use std::io::Read;
208 + let (mut read_end, write_end) = UnixStream::pair().unwrap();
209 + read_end.set_nonblocking(true).unwrap();
210 +
211 + let queue = PresentQueue::new(std::time::Instant::now());
212 + queue.set_wake(write_end);
213 +
214 + // Brak oczekujących zdarzeń -> brak bajtu wybudzającego.
215 + queue.mark_submitted();
216 + queue.presented();
217 + let mut buf = [0u8; 8];
218 + assert!(read_end.read(&mut buf).is_err());
219 + }
176 220 }