synchronized / atomic operation?

[dirkarnez]

May i ask is there a safe way / practice to read shared variable? It seems Circle has some built-in ways (read locks CSemaphore or CMutex or others?) Pseudocode:

while (true)
{
	// reading the variable
}

void interrupt () {
	// updating the variable
}

I did this and i get EXCEPTION_SYNCHRONOUS. Thank you so much!

[rsta2]

Circle provides functions for the atomic access to int variables (in <circle/ atomic.h>) and spin locks (in <circle/spinlock.h>) for synchronization. You can also disable the interrupt (using EnterCritical(), in <circle/ synchronize.h>), but this is normally not recommended, because it only works with single-core applications. If one uses tasks, there are more possible synchronization objects. It depends on the structure of your data and the operations, that you want to do with it, when you want to decide, which synchronization method to use. Sometimes you do not need one of these methods (e.g. when a boolean flag is only set from the interrupt handler and read from the main loop), but you should declare it as "volatile", because the compiler may generate code otherwise, which reads the variable only once from the main loop and will not see, when the interrupt handler sets the flag later. I would need more information about your data and the operations on it, if you need more info.

[rsta2]

I think in your case a volatile int variable is enough. You set it in the interrupt handler and read and reset it in the main loop. The only thing, which can happen, is that you loose a button press, if there is another press before the reset, which shouldn't be a problem, because you can press again.

If you don't want this, you can use AtomicIncrement() from the interrupt handler to count the number of button presses in the variable and AtomicExchange() from the main loop to read the number of arrived button presses and reset it to zero in an atomic operation.

Tasks are normally used, when there are multiple operations running (pseudo) parallel. I think this is not necessary here, but you could have a look at sample/19-tasks for an example.

[dirkarnez]

May i have your suggestion on how to do the following logic atomically? Pseudocode:

int a = 0;
a = (a + 1) % 3;

Currently my code is:

AtomicSet(&a, (AtomicGet(&a) + 1) % 3); 

I am so weak at concurrent programming, thank you so much for the help!

[rsta2]

This cannot be implemented with Atomic*(), I mean it can, but it won't be atomic. ;) You need a spin lock here.

[dirkarnez]

I had this feeling that it won't be atomic hahahaha, omg gonna check spin lock out :P

[dirkarnez]

May i know what about EnterCritical as in lib/synchronize64.cpp? Is spin lock a better solution?

[dirkarnez]

Thank you so much! I just learned there is AtomicIncrement!

[rsta2]

I suggest to use always spin locks, so you are sure if you move to multi-core. In fact CSpinLock::Acquire() degrades to EnterCritical(), if ARM_ALLOW_MULTI_CORE is not defined. Thus there is no real difference in using EnterCritical() directly.

[dirkarnez]

thank you so much i see!