Keep visible practices free of frame-thread sync and request work

On Android and the web a sync runs on the frame thread, and every one
stopped the breathing circle for about 0.3 s on a Pixel 3a while a
practice was running. A practice on screen, also in its small window,
now holds back starting a sync and finishing one that began before it;
Lumi and package requests, which use the frame thread everywhere, wait
too. Scheduled work runs when the practice ends. In the background
nothing is drawn, so background practice sync continues.
This commit is contained in:
waozi committed 2026-10-09 11:25:31 -03:00
1 parent 4dd181b7f8
commit 1602d9bc01
8 files changed
+93 -18

No files matched your search

+6
View File
@@ -1151,6 +1151,12 @@ app_sync_pump :: (app: *InnerBreeze) {
app.ui.sync_requested = false
unused app_auto_sync(app)
}
// Here sync runs on the frame thread: a visible practice also waits to
// finish a request that started before it, since applying its records
// takes longer than a frame. Scheduled work runs when it ends.
if SyncOnFrameThread() && app_practice_holds_frame_work(app) {
return
}
now = GetTime()
app_sync_record_input(app, now)
app_collect_finished_sync()
+6 -2
View File
@@ -65,6 +65,7 @@ PackageNow :: () -> s64 #foreign c "now_seconds";
#import, file "../screens/settings/settings_status.zi";
#import, file "app_sync.zi";
#import, file "sync_safety.zi";
#import, file "telegram_account_flow.zi";
#import, file "../platform/telegram_bridge.zi";
#import, file "../storage/delegate_store.zi";
@@ -1523,8 +1524,11 @@ app_update_draw :: (vapp: *void, viewport: Rectangle) {
settings_sync_account_pump(app)
ActivityPump(app)
app_sync_pump(app)
app_lumi_pump(app)
PackagePump(app.enabled_apps, cast(s32)PackageNow())
// Lumi and package requests run on the frame thread on every platform.
if !app_practice_holds_frame_work(app) {
app_lumi_pump(app)
PackagePump(app.enabled_apps, cast(s32)PackageNow())
}
if app.app_choices_pending && practice_active(app) == null && app.modal.active == 0 &&
app.breathing.screen != ScreenHabitEdit && app.breathing.screen != ScreenHabitSessionEdit &&
app_diary_save() {
+27 -1
View File
@@ -1,6 +1,31 @@
#import, file "app_types.zi";
#import, file "../core/types.zi";
#import, file "sync_safety_policy.zi";
#import, file "session_screen.zi";
// Android and the web run sync on the frame thread instead of a worker.
SyncOnFrameThread :: () -> bool {
#if #defined(PLATFORM_WEB) || #defined(ANDROID_BUILD) {
return true
}
return false
}
// The practice drawn on screen, also in its small window. While the app is
// in the background nothing is drawn, so no practice holds work back.
app_visible_practice_screen :: (app: *InnerBreeze) -> s32 {
if app == null || app.backgrounded != 0 {
return ScreenStart
}
return app_session_screen(app)
}
// A visible practice animates every frame, so frame-thread work that can
// outlast a frame (finishing a request, applying its records, package
// updates) waits until the practice ends.
app_practice_holds_frame_work :: (app: *InnerBreeze) -> bool {
return SyncScreenBlocksRefresh(app_visible_practice_screen(app))
}
#program_export
app_background_sync_safe :: (app: *InnerBreeze) -> s32 {
@@ -8,7 +33,8 @@ app_background_sync_safe :: (app: *InnerBreeze) -> s32 {
return ifx BackgroundSyncSafeFields(
app.modal.active, app.habit_edit.active,
app.sync_server_url_focused, app.sync_alias_focused,
app.profile_friend_input_focused, app.breathing.screen) then 1 else 0
app.profile_friend_input_focused, app.breathing.screen,
app_visible_practice_screen(app), SyncOnFrameThread()) then 1 else 0
}
SyncUiUpdateSafe :: (app: *InnerBreeze, now: float64,
+15 -3
View File
@@ -9,6 +9,10 @@ SyncSafetyState :: struct {
alias_focused: s32
friend_input_focused: s32
screen: s32
// The running practice, also while it shows in its small window.
practice_screen: s32
// Android and the web run sync on the frame thread, not a worker.
frame_thread_transport: bool
}
SyncScreenBlocksRefresh :: (screen: s32) -> bool {
@@ -21,14 +25,20 @@ SyncInputBlocksRefresh :: (state: SyncSafetyState) -> bool {
}
BackgroundSyncSafe :: (state: SyncSafetyState) -> bool {
// Transport may exchange encrypted records during a practice. Refreshing
// its settings or screen remains a separate, deferred operation.
// A sync started on the frame thread stops every frame while it builds
// and applies encrypted records, so a running practice waits until it
// ends. A worker-thread transport may exchange records during a
// practice; refreshing settings or the screen stays deferred.
if state.frame_thread_transport && SyncScreenBlocksRefresh(state.practice_screen) {
return false
}
return state.modal_active == 0 && !SyncInputBlocksRefresh(state)
}
BackgroundSyncSafeFields :: (modal_active: s32, habit_edit_active: s32,
server_url_focused: s32, alias_focused: s32,
friend_input_focused: s32, screen: s32) -> bool {
friend_input_focused: s32, screen: s32, practice_screen: s32,
frame_thread_transport: bool) -> bool {
state: SyncSafetyState
state.modal_active = modal_active
state.habit_edit_active = habit_edit_active
@@ -36,6 +46,8 @@ BackgroundSyncSafeFields :: (modal_active: s32, habit_edit_active: s32,
state.alias_focused = alias_focused
state.friend_input_focused = friend_input_focused
state.screen = screen
state.practice_screen = practice_screen
state.frame_thread_transport = frame_thread_transport
return BackgroundSyncSafe(state)
}
+6 -12
View File
@@ -18,7 +18,6 @@
#import, file "../app/text_buffers.zi";
#import, file "../app/app_nav_state.zi";
#import, file "../app/route_types.zi";
#import, file "../app/session_screen.zi";
#import, file "../app/locale.zi";
#import, file "../practices/practice_actions.zi";
#import, file "../platform/network_transport.zi";
@@ -42,9 +41,6 @@ c :: #system_library "c";
// Telegram messages reach the app within this interval while Inbe is open.
LUMI_TELEGRAM_POLL_SECONDS :: 2
LUMI_TELEGRAM_RETRY_SECONDS :: 5
// While a practice runs, requests on Android and the web share its frame
// thread, so idle polls slow down to keep the animation smooth.
LUMI_TELEGRAM_PRACTICE_POLL_SECONDS :: 10
lumi_telegram_session: Session;
lumi_telegram_transfer: NetworkTransfer;
@@ -332,7 +328,11 @@ LumiTelegramPump :: (app: *InnerBreeze) {
}
}
}
if lumi_telegram_operation.active || storage_has_sync_account() == 0 { return }
if lumi_telegram_operation.active { return }
now := TelegramNow(null)
requested := lumi_telegram_disconnect_requested || lumi_telegram_link_requested
if !requested && now < lumi_telegram_retry { return }
if storage_has_sync_account() == 0 { return }
client := storage_get_setting_text("lumi_telegram_client")
if client.count != 64 {
bytes: [65]u8
@@ -359,13 +359,7 @@ LumiTelegramPump :: (app: *InnerBreeze) {
}
return
}
now := TelegramNow(null)
if now < lumi_telegram_retry { return }
poll_seconds := LUMI_TELEGRAM_POLL_SECONDS
if app_is_session_screen(app_session_screen(app)) {
poll_seconds = LUMI_TELEGRAM_PRACTICE_POLL_SECONDS
}
lumi_telegram_retry = now + poll_seconds
lumi_telegram_retry = now + LUMI_TELEGRAM_POLL_SECONDS
if lumi_telegram_ack != 0 {
out: Vec(u8)
BuilderPrint(*out, "{\"id\":%,\"client\":\"%\"}", lumi_telegram_ack, client)
+12
View File
@@ -34,6 +34,18 @@ Answer :: () -> s32 {
if !BackgroundSyncSafe(state) || SyncUiRefreshSafe(state, 3.0, 1.0, false) { return 14 }
state.screen = ScreenHabits
// Where sync runs on the frame thread, a running practice waits for it,
// also while the practice shows in its small window.
state.frame_thread_transport = true
if !BackgroundSyncSafe(state) { return 15 }
state.practice_screen = ScreenPracticeSession
if BackgroundSyncSafe(state) { return 16 }
state.practice_screen = ScreenMeditation
if BackgroundSyncSafe(state) { return 17 }
state.frame_thread_transport = false
if !BackgroundSyncSafe(state) { return 18 }
state.practice_screen = ScreenStart
if SyncUserIdle(2.49, 1.0, false) ||
!SyncUserIdle(2.50, 1.0, false) ||
SyncUserIdle(3.0, 1.0, true) { return 11 }
+20
View File
@@ -17,6 +17,26 @@ main(void)
app.ui.text_input_active = false;
assert(sync_safety_SyncUiUpdateSafe(&app, 20.0, 1.0, false));
/* This native build runs sync on a worker thread, so a running
practice does not hold it back. */
app.breathing.screen = ScreenSession;
assert(app_background_sync_safe(&app) == 1);
app.breathing.screen = ScreenLumi;
/* A visible practice, also in its small window, holds frame-thread
work; in the background nothing is drawn. */
assert(!sync_safety_app_practice_holds_frame_work(&app));
app.breathing.screen = ScreenSession;
assert(sync_safety_app_practice_holds_frame_work(&app));
app.breathing.screen = ScreenHabits;
app.session_window.screen = ScreenMeditation;
assert(sync_safety_app_practice_holds_frame_work(&app));
app.backgrounded = 1;
assert(!sync_safety_app_practice_holds_frame_work(&app));
app.backgrounded = 0;
app.session_window.screen = ScreenStart;
app.breathing.screen = ScreenLumi;
app.modal.active = 1;
assert(app_background_sync_safe(&app) == 0);
app.sync_alias_focused = 1;
+1
View File
@@ -76,5 +76,6 @@ cmp "$work/source/safety.zib" "$work/saved/safety.zib"
"$root/tests/sync_safety_link_test.c" \
"$work/native/app/sync_safety.c" \
"$work/native/sync_safety_policy.c" \
"$work/native/session_screen.c" \
-o "$work/native/test"
env -u DISPLAY -u WAYLAND_DISPLAY "$work/native/test"