what are the implications of volatile....

Hi,

Code:

---

unsigned int value=0; //Following is my declarations

//Following is my timer handler which will be executed every 0.2 seconds

void Timer_handler(void* pvMsg, uint8 u8MsgLen)
{
  ///To check the volitality of the variable
  if(value<254)
  {
      vPrintf("\r\ncheck the volitality value :%d",value);
      value++;
  }
  else
  {
        value = 0;
  }
  once = TRUE;
  //Will create a timer
  (void)CreateTimer(Timer_handler, &u8Msg1, 0, 200, &u8TimerId1);
}

---

Here i have declared the variable "value" as normal automatic varibale.

and the ouput is :

1
2

Why is it that the compiler not optimising the variable?

Isn't this(timer handler) main usage of volatile variable?

Thanks

What do you mean "not optimising".

There's no reason for you to declare value as volatile in this code. The compiler is able to see where the variable is modified, so it is able to do the right thing.

Your once variable on the other hand is different.

Code:

---

int once = 0;

int main ( ) {
  (void)CreateTimer(Timer_handler, &u8Msg1, 0, 200, &u8TimerId1);
  while ( !once ) {
  }
}

---

Making once volatile would be a good idea, since the compiler cannot detect any modification of once.
Without the qualifier, the compiler might generate while(1) instead, based on the known information at compile time.

Quote:

---

Originally Posted by Salem

The compiler is able to see where the variable is modified, so it is able to do the right thing.

---

I didn't get this point

By changing the code to mode didn't work eithier

Code:

---

unsigned int once =0; //Following is my declarations

//Following is my timer handler which will be executed every 0.2 seconds
void Timer_handler(void* pvMsg, uint8 u8MsgLen)
{
  vPrintf("\r\ncheck the volitality in sw_later once :%d",once);
  once = 1;
  vPrintf("\r\ncheck the volitality in later once :%d",once);
  //Will create a timer
  (void)CreateTimer(Timer_handler, &u8Msg1, 0, 200, &u8TimerId1);
}

main()
{
 (void)CreateTimer(Timer_handler, &u8Msg1, 0, 200, &u8TimerId1);
while(1)
 if(once)
 {
    switch(State)
    {
        case TX_ST:
        //SendData();
        State = RX_ST;
        break;
        default:
        vPrintf("\n\rdefault");
        break ;
    }
    once = 0;  Is this what you mean by detecting modifications ?
   
  }
}

---

Ouput :
check the volitality in sw_later once = 0
check the volitality in later once = 1

My code survied without being declared "once"as volatile.

> vPrintf("\r\ncheck the volitality in sw_later once :%d",once);
It's not going to remember "in a special place" the old value of once, when re-invoking the interrupt handler.

It only matters in cases like this

Code:

---

while ( once ) {
  printf("%d\n", once );
}

---

Here, once is 'read-only' for the duration of the loop, so the compiler is free to copy once to some "special place" as an optimisation, and thus lead to incorrect assumptions.

By declaring it volatile (in this case), you force the compiler to always check the variable, and not assume that it is constant from inspecting the code.

Where will the optimised variables stored?

Will they be stored in registers(for microcontrollers) or the cache memory(in highend Processors)?If so the registers are limited to store all the optimised variables?

Thanks in advance

OSdev is not the way to learn a language. Get a basic understanding, of both processor architecture, and coding, first.

Optimized values are usually just hard-coded numbers in the instructions.