critical section function
[Platform]

Determine the current interrupts enabled state.

This function can be called to determine whether or not interrupts are currently enabled.

Note:

NOTE: This function works for both cortex-A and cortex-M, although the underlyng implementation differs.

Returns:

true if interrupts are enabled, false otherwise

Definition at line 29 of file mbed_critical.c.

Atomic compare and set.

It compares the contents of a memory location to a given value and, only if they are the same, modifies the contents of that memory location to a given new value. This is done as a single atomic operation. The atomicity guarantees that the new value is calculated based on up-to-date information; if the value had been updated by another thread in the meantime, the write would fail due to a mismatched expectedCurrentValue.

Refer to https://en.wikipedia.org/wiki/Compare-and-set [which may redirect you to the article on compare-and swap].

Parameters:

	ptr	The target memory location.
[in,out]	expectedCurrentValue	A pointer to some location holding the expected current value of the data being set atomically. The computed 'desiredValue' should be a function of this current value.

Note:

: This is an in-out parameter. In the failure case of atomic_cas (where the destination isn't set), the pointee of expectedCurrentValue is updated with the current value.

Parameters:

[in]

desiredValue

The new value computed based on '*expectedCurrentValue'.

Returns:

true if the memory location was atomically updated with the desired value (after verifying that it contained the expectedCurrentValue), false otherwise. In the failure case, exepctedCurrentValue is updated with the new value of the target memory location.

pseudocode: function cas(p : pointer to int, old : pointer to int, new : int) returns bool { if *p != *old { *old = *p return false } *p = new return true }

Note:

: In the failure case (where the destination isn't set), the value pointed to by expectedCurrentValue is still updated with the current value. This property helps writing concise code for the following incr:

function incr(p : pointer to int, a : int) returns int { done = false value = *p // This fetch operation need not be atomic. while not done { done = atomic_cas(p, &value, value + a) // *value gets updated automatically until success } return value + a }

Definition at line 322 of file mbed_critical.c.

Atomic compare and set.

It compares the contents of a memory location to a given value and, only if they are the same, modifies the contents of that memory location to a given new value. This is done as a single atomic operation. The atomicity guarantees that the new value is calculated based on up-to-date information; if the value had been updated by another thread in the meantime, the write would fail due to a mismatched expectedCurrentValue.

Refer to https://en.wikipedia.org/wiki/Compare-and-set [which may redirect you to the article on compare-and swap].

Parameters:

	ptr	The target memory location.
[in,out]	expectedCurrentValue	A pointer to some location holding the expected current value of the data being set atomically. The computed 'desiredValue' should be a function of this current value.

Note:

: This is an in-out parameter. In the failure case of atomic_cas (where the destination isn't set), the pointee of expectedCurrentValue is updated with the current value.

Parameters:

[in]

desiredValue

The new value computed based on '*expectedCurrentValue'.

Returns:

true if the memory location was atomically updated with the desired value (after verifying that it contained the expectedCurrentValue), false otherwise. In the failure case, exepctedCurrentValue is updated with the new value of the target memory location.

pseudocode: function cas(p : pointer to int, old : pointer to int, new : int) returns bool { if *p != *old { *old = *p return false } *p = new return true }

Note:

: In the failure case (where the destination isn't set), the value pointed to by expectedCurrentValue is still updated with the current value. This property helps writing concise code for the following incr:

function incr(p : pointer to int, a : int) returns int { done = false value = *p // This fetch operation need not be atomic. while not done { done = atomic_cas(p, &value, value + a) // *value gets updated automatically until success } return value + a }

Definition at line 123 of file mbed_critical.c.

Atomic compare and set.

It compares the contents of a memory location to a given value and, only if they are the same, modifies the contents of that memory location to a given new value. This is done as a single atomic operation. The atomicity guarantees that the new value is calculated based on up-to-date information; if the value had been updated by another thread in the meantime, the write would fail due to a mismatched expectedCurrentValue.

Refer to https://en.wikipedia.org/wiki/Compare-and-set [which may redirect you to the article on compare-and swap].

Parameters:

	ptr	The target memory location.
[in,out]	expectedCurrentValue	A pointer to some location holding the expected current value of the data being set atomically. The computed 'desiredValue' should be a function of this current value.

Note:

: This is an in-out parameter. In the failure case of atomic_cas (where the destination isn't set), the pointee of expectedCurrentValue is updated with the current value.

Parameters:

[in]

desiredValue

The new value computed based on '*expectedCurrentValue'.

Returns:

true if the memory location was atomically updated with the desired value (after verifying that it contained the expectedCurrentValue), false otherwise. In the failure case, exepctedCurrentValue is updated with the new value of the target memory location.

pseudocode: function cas(p : pointer to int, old : pointer to int, new : int) returns bool { if *p != *old { *old = *p return false } *p = new return true }

Note:

: In the failure case (where the destination isn't set), the value pointed to by expectedCurrentValue is still updated with the current value. This property helps writing concise code for the following incr:

function incr(p : pointer to int, a : int) returns int { done = false value = *p // This fetch operation need not be atomic. while not done { done = atomic_cas(p, &value, value + a) // *value gets updated automatically until success } return value + a }

Definition at line 136 of file mbed_critical.c.

Atomic compare and set.

It compares the contents of a memory location to a given value and, only if they are the same, modifies the contents of that memory location to a given new value. This is done as a single atomic operation. The atomicity guarantees that the new value is calculated based on up-to-date information; if the value had been updated by another thread in the meantime, the write would fail due to a mismatched expectedCurrentValue.

Refer to https://en.wikipedia.org/wiki/Compare-and-set [which may redirect you to the article on compare-and swap].

Parameters:

	ptr	The target memory location.
[in,out]	expectedCurrentValue	A pointer to some location holding the expected current value of the data being set atomically. The computed 'desiredValue' should be a function of this current value.

Note:

: This is an in-out parameter. In the failure case of atomic_cas (where the destination isn't set), the pointee of expectedCurrentValue is updated with the current value.

Parameters:

[in]

desiredValue

The new value computed based on '*expectedCurrentValue'.

Returns:

true if the memory location was atomically updated with the desired value (after verifying that it contained the expectedCurrentValue), false otherwise. In the failure case, exepctedCurrentValue is updated with the new value of the target memory location.

pseudocode: function cas(p : pointer to int, old : pointer to int, new : int) returns bool { if *p != *old { *old = *p return false } *p = new return true }

Note:

: In the failure case (where the destination isn't set), the value pointed to by expectedCurrentValue is still updated with the current value. This property helps writing concise code for the following incr:

function incr(p : pointer to int, a : int) returns int { done = false value = *p // This fetch operation need not be atomic. while not done { done = atomic_cas(p, &value, value + a) // *value gets updated automatically until success } return value + a }

Definition at line 111 of file mbed_critical.c.

Atomic decrement.

Parameters:

valuePtr	Target memory location being decremented.
delta	The amount being decremented in bytes.

Returns:

The new decremented value.

Note:

The type of the pointer argument is not taken into account and the pointer is decremented by bytes

Definition at line 333 of file mbed_critical.c.

Atomic decrement.

Parameters:

valuePtr	Target memory location being decremented.
delta	The amount being decremented.

Returns:

The new decremented value.

Definition at line 185 of file mbed_critical.c.

Atomic decrement.

Parameters:

valuePtr	Target memory location being decremented.
delta	The amount being decremented.

Returns:

The new decremented value.

Definition at line 194 of file mbed_critical.c.

Atomic decrement.

Parameters:

valuePtr	Target memory location being decremented.
delta	The amount being decremented.

Returns:

The new decremented value.

Definition at line 176 of file mbed_critical.c.

Atomic increment.

Parameters:

valuePtr	Target memory location being incremented.
delta	The amount being incremented in bytes.

Returns:

The new incremented value.

Note:

The type of the pointer argument is not taken into account and the pointer is incremented by bytes.

Definition at line 329 of file mbed_critical.c.

Atomic increment.

Parameters:

valuePtr	Target memory location being incremented.
delta	The amount being incremented.

Returns:

The new incremented value.

Definition at line 157 of file mbed_critical.c.

Atomic increment.

Parameters:

valuePtr	Target memory location being incremented.
delta	The amount being incremented.

Returns:

The new incremented value.

Definition at line 166 of file mbed_critical.c.

Atomic increment.

Parameters:

valuePtr	Target memory location being incremented.
delta	The amount being incremented.

Returns:

The new incremented value.

Definition at line 148 of file mbed_critical.c.

Mark the start of a critical section.

This function should be called to mark the start of a critical section of code.

Note:

NOTES: 1) The use of this style of critical section is targetted at C based implementations. 2) These critical sections can be nested. 3) The interrupt enable state on entry to the first critical section (of a nested set, or single section) will be preserved on exit from the section. 4) This implementation will currently only work on code running in privileged mode.

Definition at line 54 of file mbed_critical.c.

Mark the end of a critical section.

This function should be called to mark the end of a critical section of code.

Note:

NOTES: 1) The use of this style of critical section is targetted at C based implementations. 2) These critical sections can be nested. 3) The interrupt enable state on entry to the first critical section (of a nested set, or single section) will be preserved on exit from the section. 4) This implementation will currently only work on code running in privileged mode.

Definition at line 79 of file mbed_critical.c.

Determine if this code is executing from an interrupt.

This function can be called to determine if the code is running on interrupt context.

Note:

NOTE: This function works for both cortex-A and cortex-M, although the underlyng implementation differs.

Returns:

true if in an isr, false otherwise

Definition at line 38 of file mbed_critical.c.