Lines Matching refs:writer
21 producer - the task that writes into the ring buffer (same as writer)
23 writer - same as producer
64 but a writer may interrupt another writer, but it must finish writing
65 before the previous writer may continue. This is very important to the
77 This is very much like a writer being preempted by an interrupt and
82 cannot preempt/interrupt a writer, but it may read/consume from the
83 buffer at the same time as a writer is writing, but the reader must be
85 and can be preempted by a writer.
87 A writer can preempt a reader, but a reader cannot preempt a writer.
89 as a writer.
112 it wants with it, as long as a writer has left that page.
192 When the writer leaves the page, it simply goes into the ring buffer
209 The commit page only is updated by the outermost writer in the
210 writer stack. A writer that preempts another writer will not move the
214 in the ring buffer and passed back to the writer. When the writer
227 +---------+ <--- given back to writer (current commit)
252 +---------+ <--- given back to second writer
256 After second writer commits:
269 When the first writer commits:
410 UPDATE - the page being pointed to is being updated by a writer
568 writer may move the tail page. The way this is done is that the writer
572 move the head page, until the writer is finished with the move.
574 This eliminates any races that the reader can have on the writer. The reader
575 must spin, and this is why the reader cannot preempt the writer.
662 by the outermost writer (the writer that was preempted).
663 This means that the commit will not move while a writer is moving the
703 tail page (moved by nested writer)
713 been moved forward, the writer will just try again to reserve storage
736 But if a nested writer preempts here, it will see that the next
742 The nested writer will set the new head page pointer.
752 But it will not reset the update back to normal. Only the writer
764 After the nested writer finishes, the outermost writer will convert
781 (first writer)
801 Next writer comes in, and sees the update and sets up the new
804 (second writer)
814 The nested writer moves the tail page forward. But does not set the old
815 update page to NORMAL because it is not the outermost writer.
825 Another writer preempts and sees the page after the tail page is a head page.
828 (third writer)
838 The writer will move the head page forward:
841 (third writer)
851 But now that the third writer did change the HEAD flag to UPDATE it
855 (third writer)
866 Then it will move the tail page, and return back to the second writer.
869 (second writer)
880 The second writer will fail to move the tail page because it was already
882 It will return to the first writer.
885 (first writer)
895 The first writer cannot know atomically if the tail page moved
900 (first writer)
910 Since the cmpxchg returns the old value of the pointer the first writer
916 (first writer)
931 (first writer)
941 Now the writer can update the head page. This is also why the head page must
942 remain in UPDATE and only reset by the outermost writer. This prevents
946 (first writer)