Lines Matching refs:it

64 but a writer may interrupt another writer, but it must finish writing
82 cannot preempt/interrupt a writer, but it may read/consume from the
105 to read from the buffer, if its page is empty (like it is on start-up),
106 it will swap its page with the head_page. The old reader page will
112 it wants with it, as long as a writer has left that page.
115 show the head page in the buffer, it is for demonstrating a swap
192 When the writer leaves the page, it simply goes into the ring buffer
215 is finished writing data into that position, it commits the write.
218 transaction. If another write happens it must finish before continuing
283 preempted another write is committed, it only becomes a pending commit
316 and a reader swaps out a page, it will be swapping out the commit page.
388 But when a swap takes place, it will use the most recent head page.
432 When the tail page meets the head pointer, it will use cmpxchg to
459 When the reader tries to swap the page with the ring buffer, it
496 It does a cmpxchg with the pointer to the previous head page to make it
571 not be able to swap the head page from the buffer, nor will it be able to
629 tail page may make it all the way around the buffer and meet the commit
658 before pushing the head page. If it is, then it can be assumed that the
664 tail page. The reader cannot swap the reader page if it is also being
667 it will never go back on it unless a reader does another swap with the
685 The above will update the tail page if it is still pointing to the expected
686 page. If this fails, a nested write pushed it forward, the current write
687 does not need to push it.
736 But if a nested writer preempts here, it will see that the next
737 page is a head page, but it is also nested. It will detect that
738 it is nested and will save that information. The detection is the
739 fact that it sees the UPDATE flag instead of a HEADER or NORMAL
752 But it will not reset the update back to normal. Only the writer
753 that converted a pointer from HEAD to UPDATE will convert it back
815 update page to NORMAL because it is not the outermost writer.
826 It changes it from HEAD to UPDATE.
851 But now that the third writer did change the HEAD flag to UPDATE it
852 will convert it to normal:
866 Then it will move the tail page, and return back to the second writer.
880 The second writer will fail to move the tail page because it was already
881 moved, so it will try again and add its data to the new tail page.
896 while it updates the HEAD page. It will then update the head page to
897 what it thinks is the new head page.
911 will see it succeeded in updating the pointer from NORMAL to HEAD.
913 if the tail page is either where it use to be or on the next page:
926 If tail page != A and tail page != B, then it must reset the pointer
927 back to NORMAL. The fact that it only needs to worry about nested
928 writers means that it only needs to check this after setting the HEAD page.