Lines Matching refs:cur
223 * URI_HASH_UNLINK(cur, new, hp, puri, uri) - unlink the uri_desc_t
225 * list member of *puri for the uri_hash_ab[] cur. After unlinking
226 * check for cur hash empty, if so make new cur. Note, as this macro
228 * RW_WRITER, futher as it can change the new hash to cur any access
291 #define URI_HASH_UNLINK(cur, new, hp, puri, uri) { \
297 if (atomic_dec_32_nv(&uri_hash_cnt[(cur)]) == 0 && \
299 kmem_free(uri_hash_ab[cur], \
300 sizeof (uri_hash_t) * uri_hash_sz[cur]); \
301 uri_hash_ab[(cur)] = NULL; \
302 uri_hash_lru[(cur)] = NULL; \
305 uri_hash_lru[(cur)] = (hp); \
312 uint32_t cur = uri_hash_which;
316 uri_hash_sz[cur] = P2Ps[URI_HASH_N_INIT];
317 uri_hash_overflow[cur] = P2Ps[URI_HASH_N_INIT] * URI_HASH_AVRG;
318 uri_hash_ab[cur] = kmem_zalloc(sizeof (uri_hash_t) * uri_hash_sz[cur],
320 uri_hash_lru[cur] = uri_hash_ab[cur];
344 uint32_t cur;
350 cur = uri_hash_which;
351 new = cur ? 0 : 1;
357 hp = &uri_hash_ab[cur][0];
358 pend = &uri_hash_ab[cur][uri_hash_sz[cur]];
374 "Avrg=%d\nCount by bucket:", cur != new ? "CUR" : "NEW",
375 uri_hash_sz[cur], nz != 0 ? ((tot * 10 + 5) / nz) / 10 : 0);
389 if (cur != new && uri_hash_ab[new] != NULL) {
390 cur = new;
401 uint32_t cur;
408 cur = uri_hash_which;
409 new = cur ? 0 : 1;
411 for (ix = 0; ix < uri_hash_sz[cur]; ix++) {
412 hp = &uri_hash_ab[cur][ix];
428 if (ret != -1 && cur != new && uri_hash_ab[new] != NULL) {
429 cur = new;
527 uint32_t cur;
532 cur = uri_hash_which;
533 new = cur ? 0 : 1;
537 URI_HASH_IX(hix, cur);
538 hp = &uri_hash_ab[cur][hix];
548 URI_HASH_UNLINK(cur, new, hp, puri, uri);
553 if (cur != new && uri_hash_ab[new] != NULL) {
558 cur = new;
573 uint32_t cur = uri_hash_which;
574 uint32_t new = cur ? 0 : 1;
587 URI_HASH_IX(hix, cur);
589 uri_hash_cnt[cur] < uri_hash_overflow[cur]) {
600 atomic_inc_32(&uri_hash_cnt[cur]);
601 hp = &uri_hash_ab[cur][hix];
627 * not overflow the cur hash to much.
634 cur = uri_hash_which;
635 new = cur ? 0 : 1;
644 uri_hash_n[new] = uri_hash_n[cur] + 1;
650 uri_hash_n[new] = uri_hash_n[cur];
666 * not overflow the cur hash to much.
683 hp = &uri_hash_ab[cur][hix];
685 URI_HASH_MIGRATE(cur, hp, new);
693 for (hix = 0; hix < uri_hash_sz[cur]; hix++) {
694 hp = &uri_hash_ab[cur][hix];
696 URI_HASH_MIGRATE(cur, hp, new);
711 * Last, check to see if last cur hash chain has been
712 * migrated, if so free cur hash and make new hash cur.
714 if (uri_hash_cnt[cur] == 0) {
721 uri_hash_cnt[cur] == 0 && uri_hash_ab[new] != 0) {
722 kmem_free(uri_hash_ab[cur],
723 sizeof (uri_hash_t) * uri_hash_sz[cur]);
724 uri_hash_ab[cur] = NULL;
725 uri_hash_lru[cur] = NULL;
746 uint32_t cur;
753 cur = uri_hash_which;
754 new = cur ? 0 : 1;
758 URI_HASH_IX(hix, cur);
759 hp = &uri_hash_ab[cur][hix];
840 atomic_dec_32(&uri_hash_cnt[cur]);
908 if (cur != new && uri_hash_ab[new] != NULL) {
913 cur = new;
949 uint32_t cur;
955 cur = uri_hash_which;
956 new = cur ? 0 : 1;
958 hp = uri_hash_lru[cur];
960 pend = &uri_hash_ab[cur][uri_hash_sz[cur]];
983 URI_HASH_UNLINK(cur, new, hp, puri, uri);
984 if (cur == uri_hash_which) {
987 hp = uri_hash_ab[cur];
989 uri_hash_lru[cur] = hp;
998 hp = uri_hash_ab[cur];
1001 if (cur != new && uri_hash_ab[new] != NULL) {
1006 cur = new;