[lldb-dev] Is there support for command queuing/asynchronicity in lldb?

[Kuba Ober]

Do lldb internals support/make it possible to queue commands
for remote debugging, and to have the results of the same
reported asynchronously?

This is needed for good user experience on targets that
are being debugged remotely or via JTAG and similar debugging
dongles. Quite often such connections are slow and the
commands can take very long to execute.

Ideally, the user or the IDE should not be expected to
know to split long-running commands into smaller pieces/

Specifically, I’m thinking of following features:

1. Submit a command for execution asynchronously -
it returns right away, and the result(s) are reported lated.

2. Get partial results from asynchronous command execution
as it progresses. For example, during a long memory read
it’d be nice to get periodic notifications as each “chunk”
of data comes in.

3. Specification of partial ordering between commands.
The default would be to have totally ordered command execution
as is the case right now, but sometimes this can be relaxed.

Again, think of a very long running memory dump - several
megabytes of stuff being read, it can take dozens of seconds
on slow dongles or slow network connections. If the user
(or an IDE) wants, the subsequent commands can be given
with relaxed ordering such that they don’t have to be delayed
until the memory read finishes. Say that a user wants to change
a register while the memory is dumped, or request a smaller
read somewhere else that could finish much sooner.

This would provide for good interactive user experience in IDEs.


Any thoughts/hints/input?

Cheers, Kuba Ober