Introduction
At times I need to look into a processing step of a pipeline, either to identify a performance improvement or as part of impact analysis. If the step is covered by a unit test, then it is a bit easier to analyze, but alas, this is not always the case.
In such instances, a general approach is to isolate a buffer of data being processed and extract it to a data file. Then the data can be analyzed separately or the data can be used to create a unit test. In the latter case, the unit test can be used to test the performance improvement.
There are generally two ways of capturing the buffer: either modify the source code to add the data dump procedure (e.g., fopen
/fwrite
/fclose
), or restart the debug session with WinDBG and using the writemem extension.
Both of the above methods are robust but inefficient as both require restarting of the debug session and one of them requires recompilation of the sources, which may be time consuming.
Hence the VsDebugHelper add-in was born. The VsDebugHelper add-in allows to capture a buffer from the program being debugged into a data file and back.
Using the VsDebugHelper Add-in
The steps to use the add-in are rather simple:
- Make sure VsDebugHelper is loaded by checking Tools\Addin manager...
- Start debugging the application and break on the desired location
- Use one or more of the commands from VsDebugHelper
Once loaded, the plug-in adds two commands to the Visual Studio environment, which can be executed from the Visual Studio Command Window.
VsDebugHelper Commands
The following commands are inspired by the WinDBG extension, and provide the following functionality:
- writemem - Write memory to file
Usage: writemem <filename> <address> <length>
- filename - destination file name.
- address - starting address of the buffer.
- length - length of the data to be copied.
- readmem - Read memory from file
Usage: readmem <filename> <address> <length>
- filename - source file name.
- address - starting address of the buffer.
- length - length of the data to be copied.
Note: To see the effect of readmem in Visual Studio, you need to 'step' after readmem is called.
Both the address and length arguments can be variable names or an expression.
VsDebugHelper Example Usage
Here is an example of how VsDebugHelper can capture a buffer of pixels:
std::auto_ptr<lum8> grayPixels(new lum8[width*height]);
...
std::auto_ptr<rgba> colorPixels(new rgba[width*height]);
...
Note that the arguments are variables and expressions of expressions, which are evaluated by the debugger. If you run into any issues, first double check that all expressions can be resolved in the Watch window.
And here is how the raw data is displayed by an external viewer (IrfranView):
Installation
Installation by Direct Download
Proceed with the download and install at the top of the article. After the installation, confirm the add-in is installed and set to be loaded at startup, as shown below:
Installation Through Extension Manager
Alternately, the add-in can be installed from within Visual Studio through the use of the Extension Manager as shown below:
Add-in Internals
Visual Studio has a number of extensibility technologies, but useful documentation is very difficult to find. Additionally, there is significant disconnect as to what is available to managed extensions vs. unmanaged extensions. It is rather clear that Visual Studio is an unmanaged application, yet there is no information on how to interact from an unmanaged add-in. And interestingly enough, extensibility functionality for 'Visualizer' has been clearly cut off.
Besides being a nuisance, the above boils down to an issue that there is no way to work through Visual Studio to modify a region of memory. Hence when the readmem command is used (to load a buffer from file), the Watch and Memory window displays will be out of sync with the actual memory contents.
Overall, the sequence of execution is pretty simple. Visual Studio calls the CommandTarget
interface and its implementation will dispatch the call to the ICommand
implementation based on the command string. The ICommand
implementation is responsible for parsing the command parameters and etc. A simplified diagram is shown below:
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.