fix(lcm): segfault at cleanup

[paul-nechifor]

Problem

Example broken runs:

• https://github.com/dimensionalOS/dimos/actions/runs/24213436690/job/70687932372
• https://github.com/dimensionalOS/dimos/actions/runs/24174044062/job/70551592227

Closes DIM-XXX

Solution

Breaking Changes

How to Test

Contributor License Agreement

• I have read and approved the CLA.

[greptile-apps]

Greptile Summary

This PR fixes a segfault during cleanup of LCMService caused by the main thread deleting the C++ LCM object (via stop()) while the LCM loop thread was still executing inside handle_timeout(). The fix defers LCM cleanup to the _lcm_loop finally block, so stop() only calls _cleanup_owned_lcm() directly when the thread has already exited; if join() times out and the thread is still alive, cleanup is left entirely to the loop. The new tests cover the timeout-race scenario, self-stopping from within the LCM thread, and concurrent publish/subscribe/unsubscribe operations.

Confidence Score: 5/5

Safe to merge — the race condition root cause is correctly identified and fixed, and the fix is well-tested.

The fix is targeted and correct: stop() now defers LCM cleanup to the loop thread's finally block when the thread is still alive, eliminating the race that caused the segfault. _cleanup_owned_lcm() is idempotent (guarded by self.l is not None), so double-cleanup is also safe. The new tests cover the timeout race, self-stop deadlock, and external LCM lifetime. No P0 or P1 issues found.

No files require special attention.

Important Files Changed

Filename	Overview
dimos/protocol/service/lcmservice.py	Core fix: added _cleanup_owned_lcm() helper and reworked stop() to avoid racing with the LCM loop thread during teardown; cleanup is deferred to the loop's finally block when the thread is still alive.
dimos/protocol/service/test_lcmservice.py	Comprehensive new tests added: BlockingLCM for synchronisation, test_stop_timeout_preserves_lcm_until_loop_exits for the race-condition scenario, and test_stop_from_within_lcm_thread for self-stop deadlock prevention.
dimos/protocol/pubsub/impl/lcmpubsub.py	Minor defensive guard added to publish() and subscribe() to log an error and return early when self.l is None after cleanup.

Sequence Diagram

sequenceDiagram
    participant Main as Main Thread
    participant LoopThread as LCM Loop Thread
    participant LCMObj as C++ LCM Object

    Main->>Main: _stop_event.set()
    Main->>LoopThread: thread.join(timeout)

    alt Thread exits before timeout
        LoopThread->>LoopThread: stop_event detected, exits while loop
        LoopThread->>LCMObj: _cleanup_owned_lcm() - del self.l
        LoopThread->>LoopThread: self._thread = None
        Main-->>Main: join returns, thread not alive
        Main->>Main: skip _cleanup_owned_lcm()
    else Thread still in handle_timeout when timeout expires
        Main-->>Main: join timed out, thread.is_alive() == True
        Main->>Main: SKIP _cleanup_owned_lcm() - key fix avoids segfault
        LoopThread->>LoopThread: handle_timeout returns, loop exits
        LoopThread->>LCMObj: _cleanup_owned_lcm() - del self.l
        LoopThread->>LoopThread: self._thread = None
    end

Loading

_{Reviews (1): Last reviewed commit: "fix(lcm): segfault at cleanup" | Re-trigger Greptile}

[leshy]

can we get a
python -m pytest -svm tool dimos/protocol/pubsub/benchmark/test_benchmark.py -k lcm
before and after? just to confirm there are no perf changes

[leshy]