[lldb-dev] Breakpoint + callback performance ... Can it be faster?

[Benjamin Dicken via lldb-dev]

I recently started using lldb to write a basic instrumentation tool for
tracking the values of variables at various code-points in a program. I've
been working with lldb for less than two weeks, so I am pretty new. Though,
I have used and written llvm passes in the past, so I'm familiar with the
clang/llvm/lldb ecosystem.

I have a very early prototype of the tool up and running, using the C++
API. The user can specify either an executable to run or an already-running
PID to attach to. The user also supplies a file+line_number at which a
breakpoint (with a callback) is placed. For testing/prototyping purposes,
the breakpoint callback just increments a counter and then immediately
returns false. Eventually, more interesting things will happen in this
callback.

I've noticed that just the action of hitting a breakpoint and invoking the
callback is very expensive. I did some instruction-count collection by
running this lldb tool on a simple test program, and placing the
breakpoint+callback at different points in the program, causing it to get
triggered different amounts of times. I used `perf stat -e instructions
...` to gather instruction exec counts for each run. After doing a little
math, it appears that I'm incurring 1.0 - 1.1 million instruction execs per
breakpoint.

This amount of slowdown is prohibitively expensive for my needs, because I
want to place callbacks in hot portions of the "inferior" program.

Is there a way to make this faster? Is it possible to create
"lighter-weight" breakpoints? I really like the lldb API (though the
documentation is lacking in some places), but if this performance hit can't
be mitigated, it may be unusable for me.

For reference, this is the callback function:

```
static int cb_count = 0;
bool SimpleCallback (
    void *baton,
    lldb::SBProcess &process,
    lldb::SBThread &thread,
    lldb::SBBreakpointLocation &location) {
  //TODO: Eventually do more interesting things...
  cb_count++;
  return false;
}
```

And here is how I set it up to be called back:

```
lldb::SBBreakpoint bp1 =
debugger_data->target.BreakpointCreateByLocation(file_name, line_no);
if (!bp1.IsValid()) std::cerr << "invalid breakpoint";
bp1.SetCallback(SimpleCallback, 0);
```

-Benjamin
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/lldb-dev/attachments/20160816/dfbfee9b/attachment.html>