topic Re: Code for STACK usage calculation: in S12 / MagniV Microcontrollers

Code for STACK usage calculation:

hareeshakoratik — Tue, 07 Oct 2014 13:27:51 GMT

Hi All,

First we were doing the stack usage calculation by manual as follows: (Controller is S9S12G128F0MLF LQFO48)

Using a typical bench setup, flash the software to be examined.
Attach a JTAG debugger to the JTAG connector on the PCB
Use CodeWarrior to attach to the PCB and download debugging information.
Set a breakpoint at the beginning of the function main ().
Start program execution. The breakpoint should be reached in a second or two.
Using the registers window, verify that the SP is set to 20FD. (The startup code calls the main function so that is the reason that it is not 20FF.)
In the memory window, right click and select fill. Set the fill range to 2000 thru 20FC and the fill value to some recognizable value that is not a valid program address, such as A1. Press OK and verify that the stack area has been filled with the chosen value.
Resume program execution and try to invoke as much of the possible software execution paths as you can. At least run the software for 5 minutes.
At the end of the software exercise, stop the debugger and examine the memory window for the lowest address in the range 2000 thru 20FC that is not a fill value. Subtract that address from 0x2100, convert to decimal and divide the result by 256. The resulting number is the fraction of the stack space used.

But now I want to do this stuff through code. So I have written following functions to do the same:

All functions looks fine individually, but if I call one after other, STACK is overflowing at the end of *Read_From_Stack() and Stack_Usage_Calc. even I am setting SP to top of the STACK.

Please anyone can identify what is going wrong with my code.

If anyone know / having the example/working code to calculate STACK usage, please share with me.

Function to get size of stack

extern uint16_t __SEG_SIZE_SSTACK[];

uint16_t Stack_Size_Allocated()

{

return (uint16_t)__SEG_SIZE_SSTACK;

}

Function to write known data into stack location

void Write_To_Stack()

{

static uint16_t SP_Value = 0x20FD;

asm INS

//asm LDS #$20FD

while (SP_Value > 0x2000)

{

asm LDAA #0xA1

asm PSHA //Push index register data into stack;

asm STS SP_Value

}

asm LDS #$20FD

}

Function to write known data into stack location

static uint8_t *Read_From_Stack()

{

static uint8_t Temp_Stack = 0;

static uint16_t SP_Value_Top = 0xFFFF;

static uint8_t i = 0;

static uint8_t Stack_Data[255];

static uint8_t x;

for (x = 0; x < 255; ++x)

{

Stack_Data[x] = 0xFF;

}

asm INS

while (SP_Value_Top > 0x2000)

{

asm PULA // Pull data frop top of the stack into X register

asm DES

asm STAA Temp_Stack //Temp_Stack //Data read from Stack Last Address

Stack_Data[i] = Temp_Stack;

i++;

asm DES

asm STS SP_Value_Top

}

return Stack_Data;

}

Function to calculate stack usage:

void Stack_Usage_Calc()

{

//uint8_t *Stack_Used =0; /* a pointer to an int */

static uint8_t Stack_Used_Count = 0;

static uint8_t Stack_Not_Used_Count = 0;

static uint8_t i = 0;

static uint8_t Stack_Size = 255;

static uint16_t Stack_Usage = 0;

static uint8_t *Stack_Used; /* a pointer to an int */

//Stack_Size = Stack_Size_Allocated();

Stack_Used = Read_From_Stack();

for (i=0; i<Stack_Size ; ++i)

{

if (*(Stack_Used + i) == 0xA1)

{

Stack_Used_Count++;

}

else

{

Stack_Not_Used_Count++; //Stack is not used, No Count, do nothing

}

Stack_Usage = ((Stack_Used_Count/Stack_Size)*100); //It gives Stack usage in % by our BMS

}

Thanks in advance

Regards,

Hareesha.

Re: Code for STACK usage calculation:

hareeshakoratik — Tue, 14 Oct 2014 15:44:55 GMT

Hi All,

Here is the correct working code.

Mistake in previous code is, I was incrementing SP to 0x20FF from 0x20F9. Actually first 3 bytes were used by start up code and another 3 bytes were used by main function. But I was over writing that stack data with my known value so that code was not returning to calling functions. Solution is, we need to read and store the SP into a variable at the entry of function and same SP should be re -loaded at the end of the function. And main is, we are not supposed to touch the content of stack memory which is used by start-up code and main function.

Following is correct working code for STACK usage calculation. Let me know if anyone need any information regarding the same. Correct me if I am wrong anywhere.

**********************************************************************

* DEFINES AND CONSTANTS

**********************************************************************

uint8_t Stack_Usage_Min = 100; /* Minimum STACK usage in precentage */

uint8_t Stack_Usage_Max = 0; /* Maximum STACK usage in precentage */

extern uint16_t __SEG_SIZE_SSTACK[];

Function to get the size of stack

uint16_t Get_Stack_Size_Allocated()

{

return (uint16_t)__SEG_SIZE_SSTACK;

}

Function to get lower start address of the stack

uint16_t Get_Stack_Start_Address()

{

return (uint16_t)__SEG_START_SSTACK;

}

**********************************************************************

* GLOBAL FUNCTIONS

**********************************************************************

Function to write known data into stack location

void Write_To_Stack()

{

/* Declare static variables.*/

/* Follwoing variables are made as static, because test case variables are not supposed to save

on STACK along with main draiver variables*/

static uint16_t SP_Value;

static uint16_t SP_Value_Initial;

DisableInterrupts

asm STS SP_Value_Initial /* Store initial SP into a variable, restore at the end of function */

asm STS SP_Value /* Store SP value into a variable */

while (SP_Value > 0x2000)

{

asm LDAA #0xA1 /* Load 0xA1 into A register*/

asm PSHA /* Push index register data into stack.*/

asm STS SP_Value /* Store SP into a variable */

}

asm LDS SP_Value_Initial /* Load SP from a variable. It will give control back to main function*/

EnableInterrupts

}

Function to evaluate stack usage.

void Eval_Stack_Usage()

{

/* Declare static variables.*/

/* Follwoing variables are made as static, because test case variables are not supposed to save

on STACK along with main draiver variables*/

static uint16_t SP_Value_Lower;

static uint16_t SP_Value_Initial;

static uint8_t Stack_Not_Used_Count;

static uint16_t Stack_Size;

static uint8_t SP_Data;

static uint8_t Stack_Usage;

/*Initilize static variables.*/

SP_Value_Lower = Get_Stack_Start_Address();

Stack_Not_Used_Count = 0;

Stack_Size = Get_Stack_Size_Allocated();

SP_Data = 0x00;

Stack_Usage = 0;

DisableInterrupts

asm STS SP_Value_Initial /* Store initial SP into a variable, restore at the end of function.*/

asm LDS SP_Value_Lower /* Load SP with lower address of STACK.*/

asm PULA /* Pull data frop SP location into A register.*/

asm STAA SP_Data /* Store data read from register A into a variable.*/

while (SP_Data == 0xA1) /* If content of stack memory is equal to A1.*/

{

++Stack_Not_Used_Count; /*increment count by 1;*/

asm PULA /* Pull data frop SP location into A register, whih increases SP by 1*/

asm STAA SP_Data /*Store data read from register A into a variable.*/

}

asm LDS SP_Value_Initial /* Load SP from a variable. It will give control back to calling function*/

EnableInterrupts

Stack_Usage = (((Stack_Size - Stack_Not_Used_Count)*100)/Stack_Size); /* It gives Stack usage in % by our BMS.*/

if (Stack_Usage_Min > Stack_Usage)

{

Stack_Usage_Min = Stack_Usage;

}

if (Stack_Usage_Max < Stack_Usage)

{

Stack_Usage_Max = Stack_Usage;

}