如何在 Visual Studio 中测量 C 程序的函数堆栈大小？

Question

I have a very large C project that currently exists in a Visual Studio solution. I am using Visual Studio 2015. Each component of the project is contained within its own Visual Studio Project. Each component has an "init" and a "run" function that is called in a while loop. I have one component in particular where I want to measure the stack size of its "run" function. Ideally, I'd change a specific parameter to that run function and see how it impacts memory further down the line (so run multiple profiling's). For GCC, I've found that you can use fstack-usage, and that yields almost exactly what I'd want: the memory consumption (ie stack size) of each function in the program. Most solutions I've found online however apply to Linux systems only. I'd also strongly prefer to not migrate my VS solution to a different platform.

In VS, however, I haven't found a tool, API, or anything similar. The VS Performance Profiler kind of does what I want it to, but it doesn't give the memory of each function, just the memory of the entire process, which isn't ideal for profiling a component-based project. Is there a tool or method in Visual Studio where I can measure the function stack size for all possible functions? I don't mind having to write my own tool but I'd prefer something relatively simple.

I should state here as well that I don't want the entire process memory, or the call stack size. Ie it should print out something like this:

Function Name | Stack Size
--------------|------------
a_Run         | 10.5 KB
b_Run         |  5.7 KB

Thanks!

Answer 1

A quite hugly/hacky way could be to detect the start of the call stack just before calling the run function and put a watermark in a fixed range from the start. Then when run is finished, walking again the watermarked memory range, and detecting where the watermark is still present vs where it's been replaced by the actual stack usage of the run function.

To detect the start of stack you can do:

// before calling run
#define MAX_CALL_STACK 1024
volatile int start; // declare just before calling run
// fill from &start to something with a known pattern.
// the trick is to ensure no other stack allocation is performed here
register int i;
register int &add = &start;
for (i = 0 i<MAX_CALL_STACK ;i++)
{
  *add = 0xdeadbeef; a++;
}    
run(); // this will replace deadbeaf values up to a given address
printf ("run call stack start address:0x%p",(void*)&start);

The compiled watermarking code shall be checked to ensure it indeed uses registers and does not declare any other local variable before calling run.

I did not show how to detect the expanse of 0xdeadbeef but this shall not be that complex.