Add sentry__bgworker_submit_at for absolute timestamps

Extract the core submission logic into submit_at which takes an absolute
execute_after time. submit and submit_delayed become thin wrappers.

Use submit_at in bgworker_delayed_tasks to pin all tasks to a single
base timestamp, making the test ordering deterministic regardless of OS
preemption between submissions.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jpnurmi

src/sentry_sync.c

@@ -470,14 +470,27 @@ sentry__bgworker_submit(sentry_bgworker_t *bgw,
     sentry_task_exec_func_t exec_func, void (*cleanup_func)(void *task_data),
     void *task_data)
 {
-    return sentry__bgworker_submit_delayed(
-        bgw, exec_func, cleanup_func, task_data, 0);
+    SENTRY_DEBUG("submitting task to background worker thread");
+    return sentry__bgworker_submit_at(
+        bgw, exec_func, cleanup_func, task_data, sentry__monotonic_time());
 }
 
 int
 sentry__bgworker_submit_delayed(sentry_bgworker_t *bgw,
     sentry_task_exec_func_t exec_func, void (*cleanup_func)(void *task_data),
     void *task_data, uint64_t delay_ms)
+{
+    SENTRY_DEBUGF("submitting %" PRIu64
+                  " ms delayed task to background worker thread",
+        delay_ms);
+    return sentry__bgworker_submit_at(bgw, exec_func, cleanup_func, task_data,
+        sentry__monotonic_time() + delay_ms);
+}
+
+int
+sentry__bgworker_submit_at(sentry_bgworker_t *bgw,
+    sentry_task_exec_func_t exec_func, void (*cleanup_func)(void *task_data),
+    void *task_data, uint64_t execute_after)
 {
     sentry_bgworker_task_t *task = SENTRY_MAKE(sentry_bgworker_task_t);
     if (!task) {
@@ -488,18 +501,11 @@ sentry__bgworker_submit_delayed(sentry_bgworker_t *bgw,
     }
     task->next_task = NULL;
     task->refcount = 1;
-    task->execute_after = sentry__monotonic_time() + delay_ms;
+    task->execute_after = execute_after;
     task->exec_func = exec_func;
     task->cleanup_func = cleanup_func;
     task->task_data = task_data;
 
-    if (delay_ms > 0) {
-        SENTRY_DEBUGF("submitting %" PRIu64
-                      " ms delayed task to background worker thread",
-            delay_ms);
-    } else {
-        SENTRY_DEBUG("submitting task to background worker thread");
-    }
     sentry__mutex_lock(&bgw->task_lock);
 
     if (!bgw->first_task) {

src/sentry_sync.h

@@ -471,24 +471,23 @@ const char *sentry__bgworker_get_thread_name(sentry_bgworker_t *bgw);
 /**
  * This will submit a new task to the background thread.
  *
+ * The `_delayed` variant delays execution by the specified delay in
+ * milliseconds, and the `_at` variant executes after the specified monotonic
+ * timestamp. The latter is mostly useful for testing to ensure deterministic
+ * ordering of tasks regardless of OS preemption between submissions.
+ *
  * Takes ownership of `data`, freeing it using the provided `cleanup_func`.
  * Returns 0 on success.
  */
 int sentry__bgworker_submit(sentry_bgworker_t *bgw,
     sentry_task_exec_func_t exec_func, void (*cleanup_func)(void *task_data),
     void *task_data);
-
-/**
- * This will submit a new delayed task to the background thread.
- *
- * Execution is deferred by `delay_ms` milliseconds.
- *
- * Takes ownership of `data`, freeing it using the provided `cleanup_func`.
- * Returns 0 on success.
- */
 int sentry__bgworker_submit_delayed(sentry_bgworker_t *bgw,
     sentry_task_exec_func_t exec_func, void (*cleanup_func)(void *task_data),
     void *task_data, uint64_t delay_ms);
+int sentry__bgworker_submit_at(sentry_bgworker_t *bgw,
+    sentry_task_exec_func_t exec_func, void (*cleanup_func)(void *task_data),
+    void *task_data, uint64_t execute_after);
 
 /**
  * This function will iterate through all the current tasks of the worker

tests/unit/test_sync.c

@@ -234,6 +234,12 @@ SENTRY_TEST(bgworker_delayed_tasks)
     sentry_bgworker_t *bgw = sentry__bgworker_new(&os, NULL);
     TEST_ASSERT(!!bgw);
 
+    // submit_at with a fixed base so ordering is deterministic regardless
+    // of OS preemption between submissions (submit_delayed reads the clock
+    // per call, so a pause between calls could shift execute_after values
+    // and change the expected sort order)
+    uint64_t base = sentry__monotonic_time();
+
     // all tasks sorted by execute_after: immediate (0) first, then delayed
     // by deadline
     //
@@ -248,21 +254,21 @@ SENTRY_TEST(bgworker_delayed_tasks)
     //   i(1) i(6) i(7) i(8) d50(2) d100(3) d150(4) d200(5)
     //   i(1) i(6) i(7) i(8) d50(2) d75(9) d100(3) d150(4) d200(5)
     //   i(1) i(6) i(7) i(8) i(10) d50(2) d75(9) d100(3) d150(4) d200(5)
-    sentry__bgworker_submit(bgw, record_order_task, NULL, (void *)1);
-    sentry__bgworker_submit_delayed(
-        bgw, record_order_task, NULL, (void *)3, 100);
-    sentry__bgworker_submit(bgw, record_order_task, NULL, (void *)6);
-    sentry__bgworker_submit_delayed(
-        bgw, record_order_task, NULL, (void *)2, 50);
-    sentry__bgworker_submit(bgw, record_order_task, NULL, (void *)7);
-    sentry__bgworker_submit_delayed(
-        bgw, record_order_task, NULL, (void *)5, 200);
-    sentry__bgworker_submit_delayed(
-        bgw, record_order_task, NULL, (void *)4, 150);
-    sentry__bgworker_submit(bgw, record_order_task, NULL, (void *)8);
-    sentry__bgworker_submit_delayed(
-        bgw, record_order_task, NULL, (void *)9, 75);
-    sentry__bgworker_submit(bgw, record_order_task, NULL, (void *)10);
+    sentry__bgworker_submit_at(bgw, record_order_task, NULL, (void *)1, base);
+    sentry__bgworker_submit_at(
+        bgw, record_order_task, NULL, (void *)3, base + 100);
+    sentry__bgworker_submit_at(bgw, record_order_task, NULL, (void *)6, base);
+    sentry__bgworker_submit_at(
+        bgw, record_order_task, NULL, (void *)2, base + 50);
+    sentry__bgworker_submit_at(bgw, record_order_task, NULL, (void *)7, base);
+    sentry__bgworker_submit_at(
+        bgw, record_order_task, NULL, (void *)5, base + 200);
+    sentry__bgworker_submit_at(
+        bgw, record_order_task, NULL, (void *)4, base + 150);
+    sentry__bgworker_submit_at(bgw, record_order_task, NULL, (void *)8, base);
+    sentry__bgworker_submit_at(
+        bgw, record_order_task, NULL, (void *)9, base + 75);
+    sentry__bgworker_submit_at(bgw, record_order_task, NULL, (void *)10, base);
 
     sentry__bgworker_start(bgw);
     TEST_CHECK_INT_EQUAL(sentry__bgworker_flush(bgw, 5000), 0);