Skip to content

Releases: neosmart/rsevents-extra

rsevents-extra 0.2.1

08 Oct 01:29
Compare
Choose a tag to compare
  • A new public method Semaphore::count() has been added to query the available concurrency without affecting the state of the semaphore.
  • Cross-core coherence and instruction ordering was previously insufficiently
    guaranteed; this is fixed in this release by directly using Ordering::Acquire and Ordering::Release instead of relying on the AutoResetEvent (access to which is sometimes elided as an optimization) to provide those guarantees.

rsevents-extra 0.2.0

01 Sep 18:00
Compare
Choose a tag to compare

This release upgrades to the latest version (0.3.1) of rsevents, and implements the newly updated and expanded rsevents::Awaitable trait ((see the rsevents 0.3.x changelog for more info)[https://github.com/neosmart/rsevents/releases/tag/0.3.1]).

  • The biggest feature of this release is a new Semaphore type, which is an attempt at modeling a truly safe semaphore for rust (something lacking from the standard library). Semaphore is built on an rsevents auto-reset event, and uses that under-the-hood to efficiently wait for a Semaphore to become available when its concurrency limit has been reached.
  • The new Semaphore type attempts to bridge the "standard" usage of a sempahore wherein the concurrency count is manually incremented (when the semaphore is "released") with rust's concepts of ownership and RAII-friendly guard types. Please provide feedback on your usage of Semaphore so we can refine the API together!
  • The rsevents_extra types are now static friendly with const fn new() initializers so they can be declared and used as global/local static variables without requiring the usage of lazy_static or once_cell.

rsevents-extra 0.1.0

01 Sep 17:59
Compare
Choose a tag to compare

This is the initial release of the rsevents-extra crate, providing a home for custom synchronization types built on top of rsevents.

Currently, there is just one synchronization type in this crate: a countdown event that allows blocking until a predetermined number of tasks/operations have completed asynchronous processing by one or more other threads in parallel.