Hash array mapped trie - Wikipedia
This article may be too technical for most readers to understand. Please help improve it to make it understandable to non-experts, without removing the technical details. (October 2019) (Learn how and when to remove this message) A hash array mapped trie[1] (HAMT) is an implementation of an associative array that combines the characteristics of a hash table and an array mapped trie.[1] It is a ref
GitHub - google/nsync: nsync is a C library that exports various synchronization primitives, such as mutexes
nsync is a C library that exports various synchronization primitives: locks condition variables run-once initialization waitable counter (useful for barriers) waitable bit (useful for cancellation, or other conditions) It is not an offical Google product. nsync may be desirable in place of pthread primitives in some cases: - nsync locks are reader-writer locks (but are as efficient as mutexes). -
Basics of Futexes - Eli Bendersky's website
The futex (short for "Fast userspace mutex") mechanism was proposed by Linux contributors from IBM in 2002 [1]; it was integrated into the kernel in late 2003. The main idea is to enable a more efficient way for userspace code to synchronize multiple threads, with minimal kernel involvement. In this post I want to provide a basic overview of futexes, how they work, and how they're used to implemen
Non-blocking algorithm - Wikipedia
In computer science, an algorithm is called non-blocking if failure or suspension of any thread cannot cause failure or suspension of another thread;[1] for some operations, these algorithms provide a useful alternative to traditional blocking implementations. A non-blocking algorithm is lock-free if there is guaranteed system-wide progress, and wait-free if there is also guaranteed per-thread pro
Progressive Locks : fast, upgradable read/write locks
Context A few years after I created the Elastic Binary Trees (ebtree), I started to get some feedback from users who needed to use them in multi-threaded environments, asking if an MT-safe version was available. By then, nothing was available, and all I could suggest them was to place some locks around all the tree manipulation code. While this generally works well, it was sub-optimal because thes
Communicating sequential processes - Wikipedia
In computer science, communicating sequential processes (CSP) is a formal language for describing patterns of interaction in concurrent systems.[1] It is a member of the family of mathematical theories of concurrency known as process algebras, or process calculi, based on message passing via channels. CSP was highly influential in the design of the occam programming language[1][2] and also influen
Spinlocks and Read-Write Locks
Spinlocks and Read-Write Locks Most parallel programming in some way will involve the use of locking at the lowest levels. Locks are primitives that provide mutual exclusion that allow data structures to remain in consistent states. Without locking, multiple threads of execution may simultaneously modify a data structure. Without a carefully thought out (and usually complex) lock-free algorithm, t
Restartable sequences [LWN.net]
LWN.net needs you!Without subscribers, LWN would simply not exist. Please consider signing up for a subscription and helping to keep LWN publishing Concurrent code running in user space is subject to almost all of the same constraints as code running in the kernel. One of those is that cross-CPU operations tend to ruin performance, meaning that data access should be done on a per-CPU basis wheneve
PRINCIPIA Limited
セミナー 形式手法に関するセミナーを開催しています． 詳細につきましてはセミナーのページをご覧ください． SyncStitch: A Model Checker based on the Process Algebra CSP SyncStitch is a model checker based on the process algebra CSP (Communicating Sequential Processes). By using SyncStitch, you can check six types of properties of the system you are developping: Deadlocks Divergences (also known as livelocks) Refinement relation on traces semantics (sa
The Little Book of Semaphores – Green Tea Press
by Allen B. Downey Download The Little Book of Semaphores in PDF. The Little Book of Semaphores is a free (in both senses of the word) textbook that introduces the principles of synchronization for concurrent programming. In most computer science curricula, synchronization is a module in an Operating Systems class. OS textbooks present a standard set of problems with a standard set of solutions, b
Thread Safety Analysis — Clang 19.0.0git documentation
Thread Safety Analysis¶ Introduction¶ Clang Thread Safety Analysis is a C++ language extension which warns about potential race conditions in code. The analysis is completely static (i.e. compile-time); there is no run-time overhead. The analysis is still under active development, but it is mature enough to be deployed in an industrial setting. It is being developed by Google, in collaboration wit
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
Notes on concurrency bugs
GitHub - stephennancekivell/go-future: A futures concurrency library in go
GitHub - tokio-rs/loom: Concurrency permutation testing tool for Rust.
GitHub - shiyanhui/libcsp: A concurrency C library 10x faster than Golang.
Detecting and handling split locks [LWN.net]
The 5-year journey to bring restartable sequences to Linux - EfficiOS
GitHub - samanbarghi/uThreads: A concurrent user-level thread library implemented in C++
GitHub - facebook/infer: A static analyzer for Java, C, C++, and Objective-C
Go Concurrency Patterns: Pipelines and cancellation - The Go Programming Language
