Files
breeze/tests/storage_settings_threads_behavior.zi
T
waozi d25420e61d Check the account keys from the settings cache
Every frame asked whether this device holds an account by reading its
public and private keys, values too long for the settings cache, so each
frame queried SQLite and copied kilobytes: a twentieth of a Lumi frame on
the Moto. The cache now remembers a long value as present without its
bytes, and the account check asks only whether each key is present.
2026-10-19 14:34:13 -03:00

131 lines
5.2 KiB
Ziran

#import "byte_text_linux"
#import, file "storage_test_support.zi";
#import, file "../src/app/text_buffers.zi";
#import, file "../src/storage/data.zi";
#import, file "../src/storage/state.zi";
#import, file "../src/storage/db.zi";
#import, file "../src/storage/storage_settings.zi";
// Background sync workers save their session through settings write batches
// while another worker does the same. One thread's batch must never absorb
// another thread's: the thread that began the transaction would then return
// without committing and leave the connection held after it exits, which
// stopped every later database call, including the app's frame loop.
c :: #system_library "c";
ThreadRoutine :: #type (*void) -> *void #c_call;
thread_create :: (thread: *usize, attributes: *void, routine: ThreadRoutine,
argument: *void) -> s32 #foreign c "pthread_create";
thread_join :: (thread: usize, result: **void) -> s32 #foreign c "pthread_join";
alarm :: (seconds: u32) -> u32 #foreign c "alarm";
pause_microseconds :: (microseconds: u32) -> s32 #foreign c "usleep";
first_in_batch: s32;
second_started: s32;
second_done: s32;
wait_for_flag :: (flag: *s32, milliseconds: s32) -> bool {
waited: s32 = 0
while flag.* == 0 && waited < milliseconds {
unused pause_microseconds(1000)
waited += 1
}
return flag.* != 0
}
first_writer :: (argument: *void) -> *void {
unused argument
storage_settings_begin_write()
storage_set_setting_text("thread_first", "one")
first_in_batch = 1
unused wait_for_flag(*second_started, 1000)
// Give the second thread time to reach its own batch before this ends.
unused pause_microseconds(200000)
storage_settings_end_write()
return null
}
second_writer :: (argument: *void) -> *void {
unused argument
unused wait_for_flag(*first_in_batch, 2000)
second_started = 1
storage_settings_begin_write()
storage_set_setting_text("thread_second", "two")
storage_settings_end_write()
second_done = 1
return null
}
test_concurrent_batches_commit_and_release :: () {
root := make_root("threads")
check_true("init threaded settings", storage_init(root) != 0)
first_routine: ThreadRoutine = first_writer
second_routine: ThreadRoutine = second_writer
first_thread: usize
second_thread: usize
check_int("start first writer", thread_create(*first_thread, null, first_routine, null), 0)
check_int("start second writer", thread_create(*second_thread, null, second_routine, null), 0)
finished := wait_for_flag(*second_done, 5000)
check_true("second batch finishes after the first thread ends its batch", finished)
if !finished {
// The connection is held by an exited thread; joining would hang.
return
}
unused thread_join(first_thread, null)
unused thread_join(second_thread, null)
check_int("no batch remains open", storage_state_handle().settings_write_depth, 0)
// The connection is free for this thread too, and both batches committed.
storage_settings_begin_write()
storage_set_setting_text("thread_main", "three")
storage_settings_end_write()
storage_close()
check_true("reopen threaded settings", storage_init(root) != 0)
check_true("first thread's setting committed", storage_get_setting_text("thread_first") == "one")
check_true("second thread's setting committed", storage_get_setting_text("thread_second") == "two")
check_true("main thread's setting committed", storage_get_setting_text("thread_main") == "three")
storage_close()
}
test_unmatched_end_releases_connection :: () {
root := make_root("unmatched")
check_true("init unmatched settings", storage_init(root) != 0)
storage_settings_end_write()
storage_set_setting_text("after_unmatched_end", "ok")
check_true("connection usable after an unmatched end", storage_get_setting_text("after_unmatched_end") == "ok")
storage_close()
}
// A value too long for the settings cache is still read whole, and its
// presence comes from the cache until stored data changes.
test_long_values_are_read_and_present :: () {
root := make_root("long")
check_true("init long settings", storage_init(root) != 0)
long_value: [700]u8
for at: cast(s32)0..698 { long_value[at] = cast(u8)(97 + at % 26) }
long_value[699] = 0
long := TextFromBytes(long_value[:699])
storage_set_setting_text("long_key", long)
check_true("long setting is present", storage_setting_present("long_key"))
check_true("long setting reads whole", storage_get_setting_text("long_key") == long)
check_true("long setting reads whole again", storage_get_setting_text("long_key") == long)
check_true("missing setting is absent", !storage_setting_present("missing_key"))
storage_set_setting_text("missing_key", "now")
check_true("a write makes a setting present", storage_setting_present("missing_key"))
storage_close()
}
#program_export
Check :: () -> s32 {
guard := support_begin("/tmp/inbe-storage-settings-threads-zi-test/")
if guard != 0 {
return guard
}
// A deadlock must fail the test instead of hanging it.
unused alarm(60)
test_concurrent_batches_commit_and_release()
test_unmatched_end_releases_connection()
test_long_values_are_read_and_present()
return failures
}