![]() The BSD timecounter code for instance appears to use a similar technique. Each time interrupt updates the time of the day there may be many readers of the time for operating system internal use and applications, but writes are relatively infrequent and only occur one at a time. This was first applied to system time counter updating. In a case where the pointers themselves must be updated or changed, using read-copy-update synchronization is preferred. Updating the memory block being pointed-to is fine using seqlocks, but updating the pointer itself is not allowed. The technique will not work for data that contains pointers, because any writer could invalidate a pointer that a reader has already followed. The drawback is that if there is too much write activity or the reader is too slow, they might livelock (and the readers may starve). Because of these two factors, seqlocks are more efficient than traditional read–write locks for the situation where there are many readers and few writers. Also, writers do not wait for readers, whereas with traditional read–write locks they do, leading to potential resource starvation in a situation where there are a number of readers (because the writer must wait for there to be no readers). ![]() The reader never blocks, but it may have to retry if a write is in progress this speeds up the readers in the case where the data was not modified, since they do not have to acquire the lock as they would with a traditional read–write lock. In either case readers simply retry (using a loop) until they read the same even sequence number before and after. If the sequence numbers are different, a writer has changed the data while it was being read. If the sequence number is odd on either occasion, a writer had taken the lock while the data was being read and it may have changed. Readers read the sequence number before and after reading the shared data. In addition to updating the shared data, the writer increments the sequence number, both after acquiring the lock and before releasing the lock. The lock is to support synchronization between two writers and the counter is for indicating consistency in readers. A seqlock consists of storage for saving a sequence number in addition to a lock. It is a reader–writer consistent mechanism which avoids the problem of writer starvation. The first implementation was in the x86-64 time code where it was needed to synchronize with user space where it was not possible to use a real lock. The seqlocks were developed by Stephen Hemminger and originally called frlocks, based on earlier work by Andrea Arcangeli. The semantics stabilized as of version 2.5.59, and they are present in the 2.6.x stable kernel series. ( August 2011) ( Learn how and when to remove this template message)Ī seqlock (short for sequence lock) is a special locking mechanism used in Linux for supporting fast writes of shared variables between two parallel operating system routines. Please help to improve this article by introducing more precise citations. This article includes a list of references, related reading, or external links, but its sources remain unclear because it lacks inline citations.
0 Comments
Leave a Reply. |
AuthorWrite something about yourself. No need to be fancy, just an overview. ArchivesCategories |