Click here to Skip to main content
12,890,424 members (52,815 online)
Click here to Skip to main content
Add your own
alternative version


23 bookmarked
Posted 5 Apr 2011

VSDebugHelper - Capture memory snapshot of a debugged process to a file

, 15 Apr 2011 CPOL
Rate this:
Please Sign up or sign in to vote.
The VsDebugHelper add-in allows to capture a buffer from the program being debugged into a data file and back.


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]);

alt text

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):

alt text

alt text


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:

alt text

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:

alt text


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Igor Okulist
United States United States
No Biography provided

You may also be interested in...

Comments and Discussions

QuestionVery Helpful Pin
tharaka_t26-Apr-12 18:58
membertharaka_t26-Apr-12 18:58 
AnswerRe: Very Helpful Pin
Igor Okulist27-Apr-12 14:41
memberIgor Okulist27-Apr-12 14:41 
GeneralRe: Very Helpful Pin
tharaka_t30-Apr-12 22:53
membertharaka_t30-Apr-12 22:53 
GeneralRe: Very Helpful Pin
Igor Okulist3-May-12 12:19
memberIgor Okulist3-May-12 12:19 
GeneralRe: Very Helpful Pin
tharaka_t7-May-12 6:40
membertharaka_t7-May-12 6:40 
GeneralRe: Very Helpful Pin
Igor Okulist9-May-12 16:57
memberIgor Okulist9-May-12 16:57 
GeneralRe: Very Helpful Pin
tharaka_t23-May-12 22:08
membertharaka_t23-May-12 22:08 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.170424.1 | Last Updated 15 Apr 2011
Article Copyright 2011 by Igor Okulist
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid