AVR Freaks

As I said:

-- Read that article.  I think section 2) is the pertinent one.

-- Post a counter-example.  I'll be happy to look at it and discuss.

Sorry Lee, but I believe Steve is correct. The scenario being discussed is main() calls a function that reads the variable once and only once. In that case, the value could not have been cached in a register since the function does not preserve local values between calls. Therefore the first access of that variable in that function must read the actual current value of that variable since there is no place else to get that value from. Only if there are more than one read of that variable could the compiler say "I already know that value, so I don't have to read it again". However, this argument only holds true if you can ensure that the function has not been inlined. If that is the case, then all bets are off.

Does the C compiler know or care?

In this example it is very possible that such a simple function might be inlined, so as stated above, this might not work as you expect. However if you put that function in a different file than where it is called from, it should be fine without the volatile. But the benefits of not using volatile in this case is exactly 0.

Without volatile, GCC's optimizer may very well look at an assignment and determine that it really isn't worth doing the store 'cause apparently the result isn't used anywhere.

That is an argument for writing to a variable. If a read value really isn't used, then there is no harm the compiler can do by eliminating the assignment. Where it would be a problem is when "variable" is really some hardware register that is affected (and possibly change its value) simply by accessing it.

So I do believe that there are some rather limited circumstances that volatile is not necessary, but those would be few and far between.

I did not say that there is any real reason to not make it volatile, just that there are some circumstances that it might not be strictly necessary. The only time I could see that it might make code more efficient is when some places in the code need the current value of the variable on every read, but other places you only want the current value on the first read. But the way to do that is to use volatile and then do the caching yourself by putting that first read into a local variable.

Sorry Lee, but I believe Steve is correct. The scenario being discussed is main() calls a function that reads the variable once and only once. In that case, the value could not have been cached in a register since the function does not preserve local values between calls. Therefore the first access of that variable in that function must read the actual current value of that variable since there is no place else to get that value from. Only if there are more than one read of that variable could the compiler say "I already know that value, so I don't have to read it again". However, this argument only holds true if you can ensure that the function has not been inlined. If that is the case, then all bets are off.

The below test shows the compiler inlining the function, and only doing one read even though it is in a loop.  "volatile needed", right?

//---Includes
#include <avr/io.h>                    // Include AVR device-specific IO definitions
#include <avr/interrupt.h>

unsigned char flag;
unsigned char my_flag;


unsigned char Fetch_flag()   {
	return flag;
}
int main(void) 
{
for (unsigned char i = 0; i < 10; i++)	
	{
	my_flag = Fetch_flag();
	}

	PORTB = my_flag;
	while(1);
	return 0;
}

ISR(TIMER0_OVF_vect) {
	flag++;
}

00000048 <main>:
unsigned char flag;
unsigned char my_flag;


unsigned char Fetch_flag()   {
	return flag;
  48:	80 91 60 00 	lds	r24, 0x0060
  4c:	80 93 61 00 	sts	0x0061, r24
for (unsigned char i = 0; i < 10; i++)	
	{
	my_flag = Fetch_flag();
	}

	PORTB = my_flag;
  50:	88 bb       	out	0x18, r24	; 24
  52:	ff cf       	rjmp	.-2      	; 0x52 <main+0xa>

00000054 <__vector_6>:
	while(1);
	return 0;
}

ISR(TIMER0_OVF_vect) {
  54:	1f 92       	push	r1
  56:	0f 92       	push	r0
  58:	0f b6       	in	r0, 0x3f	; 63
  5a:	0f 92       	push	r0
  5c:	11 24       	eor	r1, r1
  5e:	8f 93       	push	r24
	flag++;
  60:	80 91 60 00 	lds	r24, 0x0060
  64:	8f 5f       	subi	r24, 0xFF	; 255
  66:	80 93 60 00 	sts	0x0060, r24
}
  6a:	8f 91       	pop	r24
  6c:	0f 90       	pop	r0
  6e:	0f be       	out	0x3f, r0	; 63
  70:	0f 90       	pop	r0
  72:	1f 90       	pop	r1
  74:	18 95       	reti

With "volatile unsigned char flag;", it is read each loop iteration.

So, is Steve still correct?

Now, with "noinline" you are safe; see below.  So is Steve right or not?  In the end it seems easier to follow Cliff's FAQ#2.

00000048 <Fetch_flag>:
unsigned char my_flag;


__attribute__ ((noinline)) unsigned char Fetch_flag()   {
	return flag;
}
  48:	80 91 60 00 	lds	r24, 0x0060
  4c:	08 95       	ret

0000004e <main>:
int main(void) 
{
  4e:	ca e0       	ldi	r28, 0x0A	; 10
for (unsigned char i = 0; i < 10; i++)	
	{
	my_flag = Fetch_flag();
  50:	fb df       	rcall	.-10     	; 0x48 <Fetch_flag>
  52:	80 93 61 00 	sts	0x0061, r24
  56:	c1 50       	subi	r28, 0x01	; 1
__attribute__ ((noinline)) unsigned char Fetch_flag()   {
	return flag;
}
int main(void) 
{
for (unsigned char i = 0; i < 10; i++)	
  58:	d9 f7       	brne	.-10     	; 0x50 <main+0x2>
	{
	my_flag = Fetch_flag();
	}

	PORTB = my_flag;
  5a:	88 bb       	out	0x18, r24	; 24
  5c:	ff cf       	rjmp	.-2      	; 0x5c <main+0xe>

0000005e <__vector_6>:
	while(1);
	return 0;
}

ISR(TIMER0_OVF_vect) {
  5e:	1f 92       	push	r1
  60:	0f 92       	push	r0
  62:	0f b6       	in	r0, 0x3f	; 63
  64:	0f 92       	push	r0
  66:	11 24       	eor	r1, r1
  68:	8f 93       	push	r24
	flag++;
  6a:	80 91 60 00 	lds	r24, 0x0060
  6e:	8f 5f       	subi	r24, 0xFF	; 255
  70:	80 93 60 00 	sts	0x0060, r24
}
  74:	8f 91       	pop	r24
  76:	0f 90       	pop	r0
  78:	0f be       	out	0x3f, r0	; 63
  7a:	0f 90       	pop	r0
  7c:	1f 90       	pop	r1
  7e:	18 95       	reti

Kicking off another thread wander - "bool"? really?

[steve17 did say that he wasn't a C person, so I treated it as pseudocode.  But anyway...]

Get into the new millennium, Cliff...

 

2 An object declared as type _Bool is large enough to store the values 0 and 1
 

On the other hand, if I forget, it's nice to know it might work anyway.

Say, what?!?  It only "works" in your contrived case, and then only if the noinline was added.  If you have taken that many precautions, how could you "forget?

I learned long ago to have my peripheral registers marked as volatile. 

??? What "peripheral register" is this?  If indeed AVR8 and GCC, all the I/O registers are already volatile.

I suppose if you are a C++ person, everything is a function.  For my simpleminded C approach, I'd never have a one-line function to fetch/check a register.  But then again, I don't count on "inline".

Certainly a contrived example in the light of all of my AVR8 C work.  YMMV.