| /bionic/libc/upstream-netbsd/lib/libc/include/isc/ |
| list.h | 24 #define LIST(type) struct { type *head, *tail; }
26 do { (list).head = NULL; (list).tail = NULL; } while (/*CONSTCOND*/0)
40 #define TAIL(list) ((list).tail)
49 (list).tail = (elt); \
58 if ((list).tail != NULL) \
59 (list).tail->link.next = (elt); \
62 (elt)->link.prev = (list).tail; \
64 (list).tail = (elt); \
73 INSIST((list).tail == (elt));
[all...] |
| /packages/apps/Test/connectivity/sl4n/rapidjson/include/rapidjson/ |
| encodings.h | 127 #define TAIL() COPY(); TRANS(0x70)
138 case 2: TAIL(); return result;
139 case 3: TAIL(); TAIL(); return result;
140 case 4: COPY(); TRANS(0x50); TAIL(); return result;
141 case 5: COPY(); TRANS(0x10); TAIL(); TAIL(); return result;
142 case 6: TAIL(); TAIL(); TAIL(); return result;
[all...] |
| /libcore/luni/src/main/java/java/util/concurrent/ |
| ConcurrentLinkedQueue.java | 29 * The <em>tail</em> of the queue is that element that has been on the
31 * are inserted at the tail of the queue, and the queue retrieval
97 * reached in O(1) time from tail, but tail is merely an
121 * Both head and tail are permitted to lag. In fact, failing to
125 * that is, we update head/tail when the current pointer appears
128 * Since head and tail are updated concurrently and independently,
129 * it is possible for tail to lag behind head (why not)?
144 * Both head and tail may or may not point to a Node with a
146 * be null. Upon creation, both head and tail refer to a dumm
205 private transient volatile Node<E> tail; field in class:ConcurrentLinkedQueue
[all...] |
| ConcurrentLinkedDeque.java | 119 * The deque object has two node references, "head" and "tail".
120 * The head and tail are only approximations to the first and last
122 * following prev pointers from head; likewise for tail. However,
123 * it is permissible for head and tail to be referring to deleted
155 * head or tail.
174 * the nodes pointed at by head/tail never get gc-unlinked, since
175 * head/tail are needed to get "back on track" by other nodes that
198 * restart traversal from tail.
232 * - head may not be reachable from the first or last node, or from tail
240 * - the last node is always O(1) reachable from tail via next link
248 private transient volatile Node<E> tail; field in class:ConcurrentLinkedDeque
[all...] |
| LinkedTransferQueue.java | 29 * producer. The <em>tail</em> of the queue is that element that has
85 * (unmatched) queue node (or null if empty); and "tail" that
90 * head tail
97 * tail pointers. This has led to the development of
133 * updates on head/tail fields.
136 * never versus always updating queue (head and tail) pointers.
143 * head tail
150 * similarly for "tail") is an empirical matter. We have found
157 * virtue of only sometimes updating head or tail pointers when
182 * known first unmatched node, and similarly for tail. Again, thi
534 private transient volatile Node tail; field in class:LinkedTransferQueue
[all...] |
| SynchronousQueue.java | 121 * cancelled. But if it may be pinned as the current tail, it must
567 /** Tail of queue */
568 transient volatile QNode tail; field in class:SynchronousQueue.TransferQueue
579 tail = h;
593 * Tries to cas nt as new tail.
596 if (tail == t)
597 U.compareAndSwapObject(this, TAIL, t, nt);
626 * advance head and tail on behalf of other stalled/slow
630 * seeing uninitialized head or tail values. This never
642 QNode t = tail;
[all...] |
| /libcore/luni/src/main/java/java/util/concurrent/locks/ |
| AbstractQueuedLongSynchronizer.java | 60 * Tail of the wait queue, lazily initialized. Modified only via
63 private transient volatile Node tail; field in class:AbstractQueuedLongSynchronizer
121 Node oldTail = tail;
144 Node oldTail = tail;
188 * traverse backwards from tail to find the actual
194 for (Node p = tail; p != node && p != null; p = p.prev)
221 if (h != null && h != tail) {
301 // If we are the tail, remove ourselves.
302 if (node == tail && compareAndSetTail(node, pred)) {
[all...] |
| AbstractQueuedSynchronizer.java | 292 * tail. To dequeue, you just set the head field.
295 * head | | <---- | | <---- | | tail
300 * operation on "tail", so there is a simple atomic point of
321 * updated "tail" when a node's successor appears to be null.
336 * is constructed and head and tail pointers are set upon first
427 * to be null, we can scan prev's from the tail to
529 * Tail of the wait queue, lazily initialized. Modified only via
532 private transient volatile Node tail; field in class:AbstractQueuedSynchronizer
588 Node oldTail = tail;
611 Node oldTail = tail;
[all...] |
| /external/llvm/include/llvm/TableGen/ |
| Record.h | 680 enum UnaryOp { CAST, HEAD, TAIL, EMPTY };
[all...] |
| /external/testng/ant/ |
| ivy-2.1.0.jar | |
