[remibettan]

Tracked by: RSDSO-20803

Summary

Eliminates a ~1.5 s UI freeze in realsense-viewer on every option change while streaming, plus a slider snap-back regression (slider would briefly jump back to the old cached value before settling on the new one).

Three independent root causes, each fixed in its own commit, plus one peer-review-feedback commit:

1. 1fd9686 — async option-write dispatch. New option_async_setter worker takes the FW round-trip off the UI thread; last_user_set_stopwatch gate (500 ms) keeps per-frame get_option_value() polling from contending on the per-device USB lock.
2. 4fd1ff0 — async JSON config save. Moves save_processing_block_to_config_file x N + per-pp save_to_config_file (~400 ms of disk I/O) to a singleton config_save_worker with void*-keyed coalescing.
3. 28a2f8f — user-request cache for slider feedback. Locally masks the stale option_model::value with the user's just-requested value until the FW echo arrives via options_watcher / update_all_fields (capped at 2 s for FW reject/clamp).
4. 8dee2d9 — review feedback. _has_user_request atomic, dead error_message / ignore_period params dropped from set_option, LOG_WARNING for FW errors in the async setter, gate scoped to just the two paths it protects, set_option_async's redundant opt removed, config_save_worker lifted to a private nested class in subdevice-model.h, and on_chip_calib bypasses option_model for its synchronous set+verify path.

Thread-safety for rs2::config_file (recursive_mutex around all _j / on-disk access) has been split out to #15092 so it can land independently.

Each commit compiles independently.

Test plan

• Drag Exposure slider rapidly - no freeze, no snap-back
• Toggle AE / Backlight Compensation - no pause
• Slider settles to FW-applied value if clamped (cache clears on echo)
• On-chip calibration laser-emitter / thermal-loop verify still synchronous
• All commits build (Release, MSVC) on their own

[Copilot]

Copilot wasn't able to review this pull request because it exceeds the maximum number of files (300). Try reducing the number of changed files and requesting a review from Copilot again.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[Nir-Az]

.

[remibettan]

Refactored the async-write layer to rsutils::dispatcher per the suggestion (8dff3e8).

What changed

• One dispatcher per subdevice_model replaces the per-option option_async_setter threads. Single FIFO worker per sensor → cross-option ordering serialized, no more races on the per-device USB bus, fewer threads.
• option_async_setter class deleted entirely (~70 LOC).
• option_model::set_option_async is now a CAS + dispatcher::invoke. Per-option coalescing via two shared_ptr<std::atomic> members (_latest_pending_value, _has_pending_job): the action clears _has_pending_job at entry, reads back _latest_pending_value, calls endpoint->set_option, then cancellable_timer::try_sleep(200ms). A 60 Hz slider drag produces ~5 Hz of FW writes, never queues stale values, never blocks the UI thread.
• The 200 ms gate in slider_selected (restored last commit) is removed again — the dispatcher's try_sleep enforces the same floor at the right layer, uniformly across slider / checkbox / calibration paths. slider_unselected is back to a no-op.
• on_chip_calib bypass undone: set_laser_emitter_state / set_thermal_loop_state now call new option_model::set_option_sync, which invoke_and_waits through the same dispatcher — calibration writes can't interleave with concurrent UI writes anymore.

Net diff in this commit: −14 LOC across the 5 touched files (175 + / 189 −).

Lifetime safety: _set_dispatcher is declared after options_metadata in subdevice_model, so ~dispatcher stops/joins the worker before any option_model is destroyed. The dispatcher action captures only shared_ptrs — never this — so an in-flight FW call is UAF-safe regardless of option_model destruction order.

Let me know if the device-level (vs subdevice-level) variant is preferred — easy to lift the dispatcher one level up if cross-sensor serialization is wanted.

[Nir-Az]

Suggestion: tie invalidate + log to the actual FW write, and floor writes at 200 ms

Right now the three things below are decoupled from when the FW write actually happens:

• Invalidate — if (invalidate_flag) *invalidate_flag = true; is set unconditionally on the UI thread at dispatch time, i.e. before the queued set_option runs. So subdevice_model::update() can reset next_option = 0 and re-poll all options from FW while the write is still in flight, reading back the old value.
• Log — model.add_log(... "Setting " << opt << " to " << value) is throttled to ~5 Hz inside slider_selected, independent of whether a FW write was actually issued.
• FW write spacing — the action's try_sleep floor is currently 50 ms (commit 33ec131), so writes can go out at ~20 Hz. Note the 200 ms last_set_stopwatch gate in slider_selected only throttles add_log, not the FW write.

The pre-PR behavior was: invalidate + log happened only after set_option returned OK (an actual FW write), and the 200 ms ignore_period gate kept writes/invalidates to ~5 Hz. I'd like to restore that with the async setter:

1. At most one FW write per 200 ms.
2. Invalidate only after the write was sent to FW.
3. Log only when the set is actually called, with the value that was sent.

All three should be driven by the worker action. We can reuse the option_async_state channel that already carries last_error back to the UI thread via draw_option.

1. Raise the FW-write floor back to 200 ms in the action (it's currently 50 ms at line 895, not absent):

c.try_sleep( std::chrono::milliseconds( 200 ) );   // currently 50 ms

2. Extend option_async_state to report a completed write:

struct option_async_state
{
    std::mutex   mutex;
    std::string  last_error;
    bool         did_write = false;   // a FW write was actually performed
    float        written_value = 0.f; // the value that was sent to FW
};

3. In the worker lambda, record the write on success (next to the existing error handling):

if( ! err_msg.empty() )
{
    std::lock_guard< std::mutex > lk( state->mutex );
    state->last_error = err_msg;
    has_user_request->store( false );
}
else
{
    std::lock_guard< std::mutex > lk( state->mutex );
    state->did_write     = true;
    state->written_value = v;
}

4. Remove the four unconditional UI-thread invalidate lines (draw_slider, draw_checkbox, draw_combobox, slider_selected) and the throttled log in slider_selected.

5. Drain the new flags in draw_option (already on the UI thread, already swapping last_error):

std::string async_err;
bool  did_write = false;
float written_value = 0.f;
{
    std::lock_guard< std::mutex > lk( _async_state->mutex );
    async_err.swap( _async_state->last_error );
    did_write     = _async_state->did_write;
    written_value = _async_state->written_value;
    _async_state->did_write = false;
}
// ... existing async_err -> error_message handling ...
if( did_write )
{
    if( invalidate_flag )
        *invalidate_flag = true;
    model.add_log( rsutils::string::from() << "Setting " << opt << " to " << written_value );
}

This keeps the write to *invalidate_flag / _options_invalidated and add_log on the UI thread (no data race, no UAF — the worker only touches the shared _async_state), and because the dispatcher coalesces, a 60 Hz drag collapses to ~1 FW write / 200 ms, each producing exactly one invalidate + one log — matching the old gated cadence.

Note: a successful write is also echoed per-option via options_watcher → update_value, so the only thing invalidate adds is the cross-option re-poll (e.g. AE → exposure/gain coupling). That's the bit we want to keep firing only after FW actually applied the value.

[remibettan]

Done in 3bfeda3 - followed the plan you laid out almost verbatim:

1. FW-write floor back to 200 ms in the action's c.try_sleep.
2. option_async_state extended with did_write + written_value.
3. Worker lambda records both on the success branch (else of the existing error capture), under the same _async_state->mutex.
4. Removed the four unconditional UI-thread *invalidate_flag = true; lines - draw_slider (edit-field submit), draw_checkbox, draw_combobox, slider_selected. Also removed the throttled add_log in slider_selected.
5. draw_option drains did_write / written_value in the same swap that already handles last_error, then fires *invalidate_flag = true; and model.add_log("Setting " << opt << " to " << written_value) only when an actual FW write completed.

Result: a 60 Hz slider drag now produces ~5 Hz of FW writes, each producing exactly one invalidate + one log - matching the pre-PR gated cadence. Cross-option re-polls (AE ? exposure/gain) only fire after the FW has actually applied the value.

Kept the leading add_log("Setting X to Y (label)") lines in draw_checkbox / draw_combobox / draw_slider edit-field as-is - they fire on user intent and carry the human-readable label, which the did_write log doesn't. Happy to remove those too if you'd prefer a single log per FW write.

[Nir-Az]

Looks great!