https://github.com/shilangyu/register-transformations

Showcases the transformations needed to go from one wait-free register to a different one.
https://github.com/shilangyu/register-transformations

atomicity concurrent-computing registers wait-free

Last synced: 8 months ago
JSON representation

Showcases the transformations needed to go from one wait-free register to a different one.

• Host: GitHub
• URL: https://github.com/shilangyu/register-transformations
• Owner: shilangyu
• License: mit
• Created: 2024-01-28T00:13:43.000Z (about 2 years ago)
• Default Branch: main
• Last Pushed: 2024-02-11T21:13:09.000Z (about 2 years ago)
• Last Synced: 2025-03-14T17:12:38.919Z (about 1 year ago)
• Topics: atomicity, concurrent-computing, registers, wait-free
• Language: TypeScript
• Homepage: http://github.shilangyu.dev/register-transformations/
• Size: 275 KB
• Stars: 2
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

          
# Register transformations

Showcases the transformations needed to go from one wait-free register to a different one. Configure the base registers and the target output register to see the needed transformation. [See website here](https://github.shilangyu.dev/register-transformations).

![Showcase of the site](demo.png)

## What is a wait-free register?

A register is a shared-object with two atomic operations: read and write. It is shared across many threads. A [wait-free](https://en.wikipedia.org/wiki/Non-blocking_algorithm#Wait-freedom) operation is an operation such that when invoked we have a guarantee that it will eventually be completed.

A register can come in many flavors, but here we consider those that have three characteristics:

1. **Value**: _binary_ (can represent two state), _multivalue_ (can represent many values)

2. **Interface**: _SRSW_ (single reader, single writer), _MRSW_ (multiple reader, single writer), _MRMW_ (multiple reader, multiple writer)

3. **Type**: _safe_ (a read that is concurrent with a write can return anything), _regular_ (a read that is concurrent with a write can return the value being written or the previously written value), _atomic_ (all operations appear to be executed instantaneously)

This website shows how to construct a stronger register using weaker ones.