Lines Matching refs:expiration
133 * callout expiration timely. It also favors cancellations.
140 * a callout list that has the same expiration so we can avoid
141 * allocating a callout list and inserting the expiration into
154 * of expiration.
213 * If the next expiration of the cyclic is way out into \
316 * Find a callout list that corresponds to an expiration and matching flags.
319 callout_list_get(callout_table_t *ct, hrtime_t expiration, int flags, int hash)
344 if ((cl->cl_expiration == expiration) &&
354 * expiration.
360 hrtime_t expiration;
362 expiration = cl->cl_expiration;
364 if ((nextcl == NULL) || (expiration < nextcl->cl_expiration)) {
370 if (expiration < nextcl->cl_expiration) {
393 * expiration.
397 * entered, the cyclic will be programmed for the earliest expiration
440 hrtime_t expiration, now;
485 expiration = cl->cl_expiration + delta;
486 if (expiration <= 0)
487 expiration = CY_INFINITY;
488 cl->cl_expiration = expiration;
495 * We need to return the expiration to help program the cyclic.
498 * Else, we return the expiration of the earliest callout in the queue.
584 * Move an expiration from the bottom of the heap to its correct place
610 * We have an expiration later than our parent; we're done.
644 * First, copy the expiration and callout list pointer to the bottom
654 * expiration.
658 * entered, the cyclic will be programmed for the earliest expiration
666 * Move an expiration from the top of the heap to its correct place
697 * our expiration against that of our left child.
706 * the expiration of the children to determine which
712 * We'll now compare our expiration to its expiration.
730 * no right child). We'll now compare our expiration
731 * to its expiration. If ours is the earlier one, we're done.
751 hrtime_t now, expiration, next;
770 expiration = heap->ch_expiration;
771 hash = CALLOUT_CLHASH(expiration);
773 ASSERT(expiration == cl->cl_expiration);
788 if (expiration > now)
792 * Move the callout list for this expiration to the
827 next = expiration + callout_tolerance;
830 expiration = next;
833 (void) cyclic_reprogram(ct->ct_cyclic, expiration);
835 return (expiration);
856 * new expiration to the caller so he can reprogram the cyclic accordingly.
863 hrtime_t expiration, now;
934 expiration = cl->cl_expiration + delta;
935 if (expiration <= 0)
936 expiration = CY_INFINITY;
937 heap[i].ch_expiration = expiration;
938 cl->cl_expiration = expiration;
955 * We need to return the expiration to help program the cyclic.
958 * Else, return the expiration of the earliest callout in the heap.
981 hrtime_t expiration, hrtime_t resolution, int flags)
1044 * Compute the expiration hrtime.
1047 interval = expiration - now;
1049 interval = expiration;
1050 expiration += now;
1055 * Align expiration to the specified resolution.
1058 expiration += resolution - 1;
1059 expiration = (expiration / resolution) * resolution;
1062 if (expiration <= 0) {
1064 * expiration hrtime overflow has occurred. Just set the
1065 * expiration to infinity.
1067 expiration = CY_INFINITY;
1101 hash = CALLOUT_CLHASH(expiration);
1105 * Try to see if a callout list already exists for this expiration.
1107 cl = callout_list_get(ct, expiration, clflags, hash);
1119 * inserted a callout list with the same expiration.
1127 cl->cl_expiration = expiration;
1132 * expiration. If not, expand the heap.
1147 * inserted a callout list with the same expiration.
1161 * This is a new expiration. So, insert it into the heap.
1162 * This will also reprogram the cyclic, if the expiration
1187 "timeout:%K(%p) in %llx expiration, cp %p", func, arg, expiration,
1306 hrtime_t expiration;
1318 expiration = cl->cl_expiration;
1346 expiration -= gethrtime();
1349 expiration);
1350 return (expiration < 0 ? 0 : expiration);
1545 * 1. We want to quickly find the next earliest expiration to program