Skip to content

Releases: RusPiRo/ruspiro-lock

Release v0.5.0

25 Dec 11:28
a198eb5
Compare
Choose a tag to compare

Release Notes

🍈 v0.5.0

  • 🔧 Maintenance

    • Enable the crate to build with the latest nightly version and also fix this in the rust-toolchain.toml file.
    • use Rust edition 2021
    • Rename the RWLock functions that provides a write lock from lock to write. This corresponds to read lock provided by the read functions.

Release v0.4.3

25 Dec 10:25
cad9de2
Compare
Choose a tag to compare

Release Notes

🍑 v0.4.3

  • 🔧 Maintenance

    • Adjust the usage of Send and Sync trait bounds for the sync versions of Mutex and RWLock based on a comment on the rust user forums that the actual usage might not be sound.

Release v0.4.2

23 Apr 16:38
0104de4
Compare
Choose a tag to compare

Release Notes

🍑 v0.4.2

This is a maintenance release only - migrating the pipeline to github actions.

v0.4.1

13 Nov 20:54
4118b28
Compare
Choose a tag to compare

Release Notes

🍑 v0.4.1

  • 💡 Features

    • provide method into_inner for the Mutex, RWLock and their async variation to be able move the contained the sealed data out of the locks.

v0.4.0

25 Sep 09:13
659f835
Compare
Choose a tag to compare

Release Notes

🍑 v0.4.0

This version provides a major refactoring to introduce commonly used names for the different kinds of locks. Datalock becomes Mutex and DataRWlock becomes RWLock. With a feature gate also async versions of those locks are introduced.

  • 💡 Features

    • Provide async mutex and semaphore versions
  • 🔧 Maintenance

    • Rename DataLock to Mutex
    • Rename DataRWLock to RWLock
    • Introducing the enhances travis-ci pipeline to build and publish this crate
    • pipeline build with an older nightly version due to this issue

v0.3.3

28 May 18:41
9622536
Compare
Choose a tag to compare

Changelog

v0.3.3

💡 Features

Introduce a DataRWLock that enhances the DataLock in a way that in addition to mutual exclusive access a read-only access is also possible.

🔧 Maintenance

The Semaphore does now support counter of type u32 instead of u16.
Flag some of the lock functions to allow the compiler to inline them as port of the optimization to increase performance
Use cargo-make for convinient and reliable cross platform build execution to reduce maintenance efforts for local and CI builds.

🕵️ Fixes

Fix issues with Semaphore, DataLock and Spinlock that sometimes does not released a protected resource due to missing data memory and data syncronisation barriers not used as pointed out in this document: http://infocenter.arm.com/help/topic/com.arm.doc.dht0008a/DHT0008A_arm_synchronization_primitives.pdf

v0.3.2

23 Jan 19:35
327d5b4
Compare
Choose a tag to compare

Release Notes

🥕 v0.3.2

  • 🔧 Maintenance

    • Remove the dependency to the interrupts. Locking will no longer disable/re-enable interrupt handling globally.
      Usage of blocking locks need to avoided inside interrupt handler to mitigate the risk of deadlocks.

v0.3.1

02 Jan 14:29
07d2a39
Compare
Choose a tag to compare

🥕 v0.3.1 Release Notes

  • 💡 Features

    Introduce a blocking lock function for the DataLock.
  • 🔧 Maintenance

    • Apply code quality improvements based on clippy
    • remove ruspiro_pi3 feature gate as it is not needed/used
  • 📖 Documentation

    • Adjust documentation to reflect the current state of developments

RusPiRo lock features enabled for Aarch64

11 Dec 19:27
5bdb7ef
Compare
Choose a tag to compare

Release Notes

This version now supports the aarch32 and aarch64 target architectures.
It also intoduces a special DataLock structure that is a preparation to cross core synchronizations channels to savely transfer data between them.

Introduce new DataLock

27 Aug 12:42
add1c7a
Compare
Choose a tag to compare

Release Notes

This release introduces the new DataLock that allows non-blocking cross core secure access to the data guarded by this lock.

When ever an atomic lock operation is executed (ldrex/strex) the interrupts are now globally disabled and re-enabled after this operation. This prevents deadlock situations when an interrupt occurs just in the middle of atomic access to something.