Great.
Now if they can actually fix the debugger to lock onto a single thread when stepping thru multithreaded code. Currently when you set a breakpoint and step, you’ll be jarringly switched back to the breakpoint when another thread hits it. The solutions now are tedious : https://visualstudio.uservoice.com/forums/121579-visual-stud...
The problem is that the normal implementation of a breakpoint/step is replace a single byte with a 0xCC opcode (INT 3), which will be hit by every thread. Making it lock onto a single thread would require a conditional breakpoint, checking the thread ID every time that code path is executed, which might potentially use a lot of CPU. I'm not sure that kind of conditional breakpoint has hardware support.
It's definitely possible to implement, but not as easy as using a regular INT 3 instruction.
Not a windows user, but the same applies to gdb. What is your proposal? If you're currently debugging a thread, breakpoints are disabled for other threads? That really doesn't seem like what people would expect by default.
It’s a UX issue, not a behavior issue, I think. What I would do is... after the user presses the “step” button, until the user presses the “continue normally” (or whatever the free run button that ends the debugger is in VS), if breakpoints are encountered in other threads, they are quietly opened in new tabs, places under the current debugger tab. Maybe flash the tab a bit to let the user know this has happened. I don’t think VS has tabs for the debugger interface, so it would need that added.
(gdb) help set scheduler-locking
Set mode for locking scheduler during execution.
off == no locking (threads may preempt at any time)
on == full locking (no thread except the current thread may run)
step == scheduler locked during every single-step operation.
In this mode, no other thread may run during a step command.
Other threads may run while stepping over a function call ('next').
It would be pretty funny if they extended it to "just my uncommitted changes." ie: I want to step through every line I have written, but skip everything else...
It is funny how long this has been an issue and how I and so many people have given up stepping in and instead jump to the actual user function, set break point, and then step over at the source location, then unset the breakpoint and continue. A bunch of crazy steps which you end up doing again and again.
Needless to say, this improvement is much welcomed!
As a developer spending hours a day in Visual Studio with C++ as primary language this is a major improvement in terms of development time. Debugging is a a time consuming task in any language, but library headers from STD and Boost slow down the process tremendously.
Although it does help, I would say its only a bit faster than actually just setting a breakpoint of where you want the code to stop, and running till then, unlike Microsoft's example which shows 85 step intos, as if people actually do that.
It depends on the purpose of your debugging. If you know exactly where you want to go then, as you say, this has diminished value. but debugging can often be exploratory, in which case this feature could be a real timesaver.
We, for example, have lots of classes and structures that are designed to the interfaces provided by the STD containers. Mix that with actual STD containers and you can spend several hours trying to find the problem. Just My Code eliminates much of that since almost always the STD is not the cause for the problem.
Not exactly the same, but you can use blackboxing [1] in the Chrome DevTools to isolate code you’ve written from library/framework code in the debugger.
With VS2017, they've moved to a faster release cadence. Fortunely, the minor releases are actually delivering significant features, like C++17 conformance.
