Searched refs:tail (Results 1 - 12 of 12) sorted by relevance

/libcore/support/src/test/java/org/apache/harmony/security/tests/support/
H A DTestUtils.java52 String tail = Integer.toHexString(0x000000ff & data[i]);
53 if (tail.length() == 1) {
54 tail = "0" + tail;
56 System.out.print(prefix + "0x" + tail + delimiter);
/libcore/luni/src/main/java/java/util/
H A DArrayDeque.java62 * thus avoiding head and tail wrapping around to equal each
71 * arbitrary number equal to tail if the deque is empty.
76 * The index at which the next element would be added to the tail
79 private transient int tail; field in class:ArrayDeque
115 * when head and tail have wrapped around to become equal.
118 // assert head == tail;
130 tail = n;
141 if (head < tail) {
143 } else if (head > tail) {
146 System.arraycopy(elements, 0, a, headPortionLen, tail);
[all...]
/libcore/luni/src/main/java/java/util/concurrent/
H A DConcurrentLinkedQueue.java25 * The <em>tail</em> of the queue is that element that has been on the
27 * are inserted at the tail of the queue, and the queue retrieval
93 * reached in O(1) time from tail, but tail is merely an
117 * Both head and tail are permitted to lag. In fact, failing to
121 * that is, we update head/tail when the current pointer appears
124 * Since head and tail are updated concurrently and independently,
125 * it is possible for tail to lag behind head (why not)?
140 * Both head and tail may or may not point to a Node with a
142 * be null. Upon creation, both head and tail refe
218 private transient volatile Node<E> tail; field in class:ConcurrentLinkedQueue
[all...]
H A DSynchronousQueue.java115 * cancelled. But if it may be pinned as the current tail, it must
569 transient volatile QNode tail; field in class:SynchronousQueue.TransferQueue
580 tail = h;
594 * Tries to cas nt as new tail.
597 if (tail == t)
627 * advance head and tail on behalf of other stalled/slow
631 * seeing uninitialized head or tail values. This never
643 QNode t = tail;
650 if (t != tail) // inconsistent read
652 if (tn != null) { // lagging tail
[all...]
H A DConcurrentLinkedDeque.java121 * The deque object has two node references, "head" and "tail".
122 * The head and tail are only approximations to the first and last
124 * following prev pointers from head; likewise for tail. However,
125 * it is permissible for head and tail to be referring to deleted
157 * head or tail.
176 * the nodes pointed at by head/tail never get gc-unlinked, since
177 * head/tail are needed to get "back on track" by other nodes that
200 * restart traversal from tail.
234 * - head may not be reachable from the first or last node, or from tail
242 * - the last node is always O(1) reachable from tail vi
250 private transient volatile Node<E> tail; field in class:ConcurrentLinkedDeque
[all...]
H A DLinkedTransferQueue.java26 * producer. The <em>tail</em> of the queue is that element that has
83 * (unmatched) queue node (or null if empty); and "tail" that
88 * head tail
95 * tail pointers. This has led to the development of
131 * updates on head/tail fields.
134 * never versus always updating queue (head and tail) pointers.
141 * head tail
148 * similarly for "tail") is an empirical matter. We have found
155 * virtue of only sometimes updating head or tail pointers when
180 * known first unmatched node, and similarly for tail
534 private transient volatile Node tail; field in class:LinkedTransferQueue
[all...]
/libcore/luni/src/main/java/java/util/concurrent/locks/
H A DAbstractQueuedLongSynchronizer.java69 * tail. To dequeue, you just set the head field.
72 * head | | <---- | | <---- | | tail
77 * operation on "tail", so there is a simple atomic point of
98 * updated "tail" when a node's successor appears to be null.
113 * is constructed and head and tail pointers are set upon first
204 * to be null, we can scan prev's from the tail to
277 private transient volatile Node tail; field in class:AbstractQueuedLongSynchronizer
334 Node t = tail;
337 tail = head;
357 Node pred = tail;
[all...]
H A DAbstractQueuedSynchronizer.java299 * tail. To dequeue, you just set the head field.
302 * head | | <---- | | <---- | | tail
307 * operation on "tail", so there is a simple atomic point of
328 * updated "tail" when a node's successor appears to be null.
343 * is constructed and head and tail pointers are set upon first
434 * to be null, we can scan prev's from the tail to
507 private transient volatile Node tail; field in class:AbstractQueuedSynchronizer
564 Node t = tail;
567 tail = head;
587 Node pred = tail;
[all...]
/libcore/luni/src/test/java/libcore/java/util/
H A DOldTreeMapTest.java454 Map tail = tm.tailMap(objArray[900].toString());
455 assertTrue("Returned map of incorrect size : " + tail.size(), tail
458 assertTrue("Map contains incorrect entries", tail
486 assertTrue(tail instanceof Serializable);
/libcore/libdvm/src/main/java/java/lang/
H A DClass.java1287 * @param tail the second source array
1290 private static <T extends Object> T[] arraycopy(T[] result, T[] head, T[] tail) { argument
1292 System.arraycopy(tail, 0, result, head.length, tail.length);
/libcore/support/src/test/java/tests/resources/x509/
H A Dcreate.sh27 SIG_OFFSET=$(openssl asn1parse -in ${DIR}/cert-rsa.der -inform d | tail -1 | cut -f1 -d:)
92 SIG_OFFSET=$(openssl asn1parse -in ${DIR}/crl-rsa.der -inform d | tail -1 | cut -f1 -d:)
/libcore/benchmarks/libs/
H A Dcaliper.jarMETA-INF/ META-INF/MANIFEST.MF com/ com/google/ com/google/caliper/ com/google/caliper/AllocationMeasurer ...

Completed in 2849 milliseconds