PRODUCT : Borland C++ NUMBER : 1036 VERSION : 3.1 OS : DOS DATE : October 19, 1993 PAGE : 1/5 TITLE : Determining the amount of stack used at runtime. The following program provides an example on how to determine how the amount of stack not being used by an application. The example also determine the amount of the near heap that has been used. This is accomplished by making a call at the beginning of the program to a function that will mark all of the stack space not currently in use with the character 0xFF. Just before the program exits, a call is made to another function that will count the number of unchanged 0xFF bytes on the stack. When trying to determine the amount of the near heap that was used calloc should be used rather than malloc to allocate the memory because calloc will initialize the memory allocated to all zeros so it will later be apparent that that memory was allocated even if the values were never changed. This method is not a 100% guaranteed one, but it will work most of the time. Its reliablity can be determined by understanding how it performs its task and what problems that may inccur with a particular program. For instance it may prove necessary to change the character used to mark the unused stack space. It is also important to note that when attempting to change the stack size in a near memory model one must change the value of _heaplen or DGROUP will always be 64K regardless of the value of _stklen. In order to use these function you need to place the following prototypes in the source file you will be calling them from: void init_stack_count(void); void stack_count(void); To determine the amount of unused stack you must first make an initial call to: init_stack_count(); at the beginning of the program and just before exiting the program another call is required to: stack_count(); The amount of unused stack space will be printed on the screen. If you need to determine the amount of the near heap used in order to adjust the stack in the near memory model then the symbol _HEAP_ must be defined in this module. You can do this by adding the statement: PRODUCT : Borland C++ NUMBER : 1036 VERSION : 3.1 OS : DOS DATE : October 19, 1993 PAGE : 2/5 TITLE : Determining the amount of stack used at runtime. #define _HEAP_ at file scope (outside any function definition) in this source file. Then this souce file must be compiled and linked into your program as if it were any other module in your program. #include #include #include #include #include #define SIZE_OF_EMULATOR 415 // Account for floating // point emulator #define FILL_CHAR 0xFF // Character used to mark // the stack #pragma warn -aus // Turn off unecessary #pragma warn -use // warnings / ************************************************************* \ | Marks all possible stack space not currently in use by | | setting the values to 0xff. | \ ************************************************************* / void init_stack_count(void) { char far *sp; // far memory model stack // pointer char near *nsp; // near memory model stack // pointer extern unsigned __brklvl; // Internal variable marking // top of // the near heap. #if defined(__COMPACT__) || \ defined(__LARGE__) || \ defined(__HUGE__) #undef _HEAP_ sp = MK_FP( _SS, _SP - 1 ); // initialize sp to point to PRODUCT : Borland C++ NUMBER : 1036 VERSION : 3.1 OS : DOS DATE : October 19, 1993 PAGE : 3/5 TITLE : Determining the amount of stack used at runtime. // the next available space on // the stack. while( sp > (char far *)SIZE_OF_EMULATOR ) //Check // for stack overflow { *sp = FILL_CHAR; // Initialize unused stack // space sp--; } #else // similar for near data // memory model nsp = (char *) _SP - 1; // Initialize pointer while( nsp > (char *)__brklvl)// Check for stack overflow { *nsp = FILL_CHAR; // Assign fill character nsp--; // advance pointer } #endif return; } / ************************************************************* \ | Goes though stack space counting unused (unmodified) | | values meaning that space on the stack was not used. | \ ************************************************************* / void stack_count( void ) { unsigned count= 0; // Amount of unused stack // space unsigned mcount = 0; // Amount of used Heap space char far *sp; // Far memory model pointer char *nsp; // Near memory model pointer #if defined(__COMPACT__) || \ defined(__LARGE__) || \ defined(__HUGE__) sp = MK_FP( _SS, SIZE_OF_EMULATOR+1); // Initialize the // pointer PRODUCT : Borland C++ NUMBER : 1036 VERSION : 3.1 OS : DOS DATE : October 19, 1993 PAGE : 4/5 TITLE : Determining the amount of stack used at runtime. if( _SP > SIZE_OF_EMULATOR ) // Check for stack // overflow { while( sp < MK_FP(_SS,_SP) ) // Check for stack // overflow { if( *sp != (char) FILL_CHAR ) // compare pointer //value to // fill character break; count++; // count unused // stack space sp++; // increment pointer } } #else extern unsigned __brklvl; // End of near heap extern unsigned __heapbase; // Beginning of near heap if( _SP > __brklvl ) // Check for stack // overflow { nsp = (char *) __brklvl + 1; while( nsp < (char *)_SP ) // While we don't run // into the // current stack. { if( *nsp != (char) FILL_CHAR && count < 3) // Count near heap used mcount++; // else count unused // stack else if( *(nsp + 1) == (char)FILL_CHAR && *(nsp + 2) == (char) FILL_CHAR ) count++; // Count unused bytes nsp++; } } count += 2; #endif #ifdef _HEAP_ // print amount of used // stack PRODUCT : Borland C++ NUMBER : 1036 VERSION : 3.1 OS : DOS DATE : October 19, 1993 PAGE : 5/5 TITLE : Determining the amount of stack used at runtime. printf("\nHeap Used = %u bytes", (__brklvl - __heapbase + mcount)); #endif // print amount of unused // stack printf("\nStack not used = %u bytes" , count); return; } DISCLAIMER: You have the right to use this technical information subject to the terms of the No-Nonsense License Statement that you received with the Borland product to which this information pertains.