Return to ngx_event_timer.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / nginx / src / event

Annotation of embedaddon/nginx/src/event/ngx_event_timer.c, revision 1.1

1.1     ! misho       1: 
        !             2: /*
        !             3:  * Copyright (C) Igor Sysoev
        !             4:  * Copyright (C) Nginx, Inc.
        !             5:  */
        !             6: 
        !             7: 
        !             8: #include <ngx_config.h>
        !             9: #include <ngx_core.h>
        !            10: #include <ngx_event.h>
        !            11: 
        !            12: 
        !            13: #if (NGX_THREADS)
        !            14: ngx_mutex_t  *ngx_event_timer_mutex;
        !            15: #endif
        !            16: 
        !            17: 
        !            18: ngx_thread_volatile ngx_rbtree_t  ngx_event_timer_rbtree;
        !            19: static ngx_rbtree_node_t          ngx_event_timer_sentinel;
        !            20: 
        !            21: /*
        !            22:  * the event timer rbtree may contain the duplicate keys, however,
        !            23:  * it should not be a problem, because we use the rbtree to find
        !            24:  * a minimum timer value only
        !            25:  */
        !            26: 
        !            27: ngx_int_t
        !            28: ngx_event_timer_init(ngx_log_t *log)
        !            29: {
        !            30:     ngx_rbtree_init(&ngx_event_timer_rbtree, &ngx_event_timer_sentinel,
        !            31:                     ngx_rbtree_insert_timer_value);
        !            32: 
        !            33: #if (NGX_THREADS)
        !            34: 
        !            35:     if (ngx_event_timer_mutex) {
        !            36:         ngx_event_timer_mutex->log = log;
        !            37:         return NGX_OK;
        !            38:     }
        !            39: 
        !            40:     ngx_event_timer_mutex = ngx_mutex_init(log, 0);
        !            41:     if (ngx_event_timer_mutex == NULL) {
        !            42:         return NGX_ERROR;
        !            43:     }
        !            44: 
        !            45: #endif
        !            46: 
        !            47:     return NGX_OK;
        !            48: }
        !            49: 
        !            50: 
        !            51: ngx_msec_t
        !            52: ngx_event_find_timer(void)
        !            53: {
        !            54:     ngx_msec_int_t      timer;
        !            55:     ngx_rbtree_node_t  *node, *root, *sentinel;
        !            56: 
        !            57:     if (ngx_event_timer_rbtree.root == &ngx_event_timer_sentinel) {
        !            58:         return NGX_TIMER_INFINITE;
        !            59:     }
        !            60: 
        !            61:     ngx_mutex_lock(ngx_event_timer_mutex);
        !            62: 
        !            63:     root = ngx_event_timer_rbtree.root;
        !            64:     sentinel = ngx_event_timer_rbtree.sentinel;
        !            65: 
        !            66:     node = ngx_rbtree_min(root, sentinel);
        !            67: 
        !            68:     ngx_mutex_unlock(ngx_event_timer_mutex);
        !            69: 
        !            70:     timer = (ngx_msec_int_t) (node->key - ngx_current_msec);
        !            71: 
        !            72:     return (ngx_msec_t) (timer > 0 ? timer : 0);
        !            73: }
        !            74: 
        !            75: 
        !            76: void
        !            77: ngx_event_expire_timers(void)
        !            78: {
        !            79:     ngx_event_t        *ev;
        !            80:     ngx_rbtree_node_t  *node, *root, *sentinel;
        !            81: 
        !            82:     sentinel = ngx_event_timer_rbtree.sentinel;
        !            83: 
        !            84:     for ( ;; ) {
        !            85: 
        !            86:         ngx_mutex_lock(ngx_event_timer_mutex);
        !            87: 
        !            88:         root = ngx_event_timer_rbtree.root;
        !            89: 
        !            90:         if (root == sentinel) {
        !            91:             return;
        !            92:         }
        !            93: 
        !            94:         node = ngx_rbtree_min(root, sentinel);
        !            95: 
        !            96:         /* node->key <= ngx_current_time */
        !            97: 
        !            98:         if ((ngx_msec_int_t) (node->key - ngx_current_msec) <= 0) {
        !            99:             ev = (ngx_event_t *) ((char *) node - offsetof(ngx_event_t, timer));
        !           100: 
        !           101: #if (NGX_THREADS)
        !           102: 
        !           103:             if (ngx_threaded && ngx_trylock(ev->lock) == 0) {
        !           104: 
        !           105:                 /*
        !           106:                  * We cannot change the timer of the event that is being
        !           107:                  * handled by another thread.  And we cannot easy walk
        !           108:                  * the rbtree to find next expired timer so we exit the loop.
        !           109:                  * However, it should be a rare case when the event that is
        !           110:                  * being handled has an expired timer.
        !           111:                  */
        !           112: 
        !           113:                 ngx_log_debug1(NGX_LOG_DEBUG_EVENT, ev->log, 0,
        !           114:                                "event %p is busy in expire timers", ev);
        !           115:                 break;
        !           116:             }
        !           117: #endif
        !           118: 
        !           119:             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
        !           120:                            "event timer del: %d: %M",
        !           121:                            ngx_event_ident(ev->data), ev->timer.key);
        !           122: 
        !           123:             ngx_rbtree_delete(&ngx_event_timer_rbtree, &ev->timer);
        !           124: 
        !           125:             ngx_mutex_unlock(ngx_event_timer_mutex);
        !           126: 
        !           127: #if (NGX_DEBUG)
        !           128:             ev->timer.left = NULL;
        !           129:             ev->timer.right = NULL;
        !           130:             ev->timer.parent = NULL;
        !           131: #endif
        !           132: 
        !           133:             ev->timer_set = 0;
        !           134: 
        !           135: #if (NGX_THREADS)
        !           136:             if (ngx_threaded) {
        !           137:                 ev->posted_timedout = 1;
        !           138: 
        !           139:                 ngx_post_event(ev, &ngx_posted_events);
        !           140: 
        !           141:                 ngx_unlock(ev->lock);
        !           142: 
        !           143:                 continue;
        !           144:             }
        !           145: #endif
        !           146: 
        !           147:             ev->timedout = 1;
        !           148: 
        !           149:             ev->handler(ev);
        !           150: 
        !           151:             continue;
        !           152:         }
        !           153: 
        !           154:         break;
        !           155:     }
        !           156: 
        !           157:     ngx_mutex_unlock(ngx_event_timer_mutex);
        !           158: }