C++ tb_spinlock_leave函数代码示例

static tb_bool_t tb_aiop_rtor_poll_delo(tb_aiop_rtor_impl_t* rtor, tb_aioo_impl_t const* aioo)
{
    // check
    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;
    tb_assert_and_check_return_val(impl && impl->pfds && impl->cfds && aioo && aioo->sock, tb_false);

    // the aiop
    tb_aiop_impl_t* aiop = rtor->aiop;
    tb_assert_and_check_return_val(aiop, tb_false);

    // delo it, TODO: delo by binary search
    tb_spinlock_enter(&impl->lock.pfds);
    tb_remove_first_if(impl->pfds, tb_poll_walk_delo, (tb_pointer_t)(((tb_long_t)aioo->sock) - 1));
    tb_spinlock_leave(&impl->lock.pfds);

    // del sock => aioo
    tb_spinlock_enter(&impl->lock.hash);
    if (impl->hash) tb_hash_del(impl->hash, aioo->sock);
    tb_spinlock_leave(&impl->lock.hash);

    // spak it
    if (aiop->spak[0]) tb_socket_send(aiop->spak[0], (tb_byte_t const*)"p", 1);

    // ok
    return tb_true;
}

static tb_void_t tb_aiop_rtor_poll_exit(tb_aiop_rtor_impl_t* rtor)
{
    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;
    if (impl)
    {
        // exit pfds
        tb_spinlock_enter(&impl->lock.pfds);
        if (impl->pfds) tb_vector_exit(impl->pfds);
        impl->pfds = tb_null;
        tb_spinlock_leave(&impl->lock.pfds);

        // exit cfds
        if (impl->cfds) tb_vector_exit(impl->cfds);
        impl->cfds = tb_null;

        // exit hash
        tb_spinlock_enter(&impl->lock.hash);
        if (impl->hash) tb_hash_exit(impl->hash);
        impl->hash = tb_null;
        tb_spinlock_leave(&impl->lock.hash);

        // exit lock
        tb_spinlock_exit(&impl->lock.pfds);
        tb_spinlock_exit(&impl->lock.hash);

        // free it
        tb_free(impl);
    }
}

static tb_void_t tb_aiop_rtor_select_cler(tb_aiop_rtor_impl_t* rtor)
{
    tb_aiop_rtor_select_impl_t* impl = (tb_aiop_rtor_select_impl_t*)rtor;
    if (impl)
    {
        // free fds
        tb_spinlock_enter(&impl->lock.pfds);
        impl->sfdm = 0;
        FD_ZERO(&impl->rfdi);
        FD_ZERO(&impl->wfdi);
        FD_ZERO(&impl->efdi);
        FD_ZERO(&impl->rfdo);
        FD_ZERO(&impl->wfdo);
        FD_ZERO(&impl->efdo);
        tb_spinlock_leave(&impl->lock.pfds);

        // clear hash
        tb_spinlock_enter(&impl->lock.hash);
        if (impl->hash) tb_hash_clear(impl->hash);
        tb_spinlock_leave(&impl->lock.hash);

        // spak it
        if (rtor->aiop && rtor->aiop->spak[0]) tb_socket_send(rtor->aiop->spak[0], (tb_byte_t const*)"p", 1);
    }
}

/* //////////////////////////////////////////////////////////////////////////////////////
 * implementation
 */
static tb_bool_t tb_aiop_rtor_select_addo(tb_aiop_rtor_impl_t* rtor, tb_aioo_impl_t const* aioo)
{
    // check
    tb_aiop_rtor_select_impl_t* impl = (tb_aiop_rtor_select_impl_t*)rtor;
    tb_assert_and_check_return_val(impl && rtor->aiop && aioo && aioo->sock, tb_false);

    // the aiop
    tb_aiop_impl_t* aiop = rtor->aiop;
    tb_assert_and_check_return_val(aiop, tb_false);

    // check size
    tb_spinlock_enter(&impl->lock.hash);
    tb_size_t size = tb_hash_size(impl->hash);
    tb_spinlock_leave(&impl->lock.hash);
    tb_assert_and_check_return_val(size < FD_SETSIZE, tb_false);

    // add sock => aioo
    tb_bool_t ok = tb_false;
    tb_spinlock_enter(&impl->lock.hash);
    if (impl->hash) 
    {
        tb_hash_set(impl->hash, aioo->sock, aioo);
        ok = tb_true;
    }
    tb_spinlock_leave(&impl->lock.hash);
    tb_assert_and_check_return_val(ok, tb_false);

    // the fd
    tb_long_t fd = ((tb_long_t)aioo->sock) - 1;

    // the code
    tb_size_t code = aioo->code;

    // enter
    tb_spinlock_enter(&impl->lock.pfds);

    // update fd max
    if (fd > (tb_long_t)impl->sfdm) impl->sfdm = (tb_size_t)fd;
    
    // init fds
    if (code & (TB_AIOE_CODE_RECV | TB_AIOE_CODE_ACPT)) FD_SET(fd, &impl->rfdi);
    if (code & (TB_AIOE_CODE_SEND | TB_AIOE_CODE_CONN)) FD_SET(fd, &impl->wfdi);
    FD_SET(fd, &impl->efdi);

    // leave
    tb_spinlock_leave(&impl->lock.pfds);

    // spak it
    if (aiop->spak[0] && code) tb_socket_send(aiop->spak[0], (tb_byte_t const*)"p", 1);

    // ok?
    return ok;
}

tb_bool_t tb_aicp_exit(tb_aicp_ref_t aicp)
{
    // check
    tb_aicp_impl_t* impl = (tb_aicp_impl_t*)aicp;
    tb_assert_and_check_return_val(impl, tb_false);

    // kill all first
    tb_aicp_kill_all((tb_aicp_ref_t)impl);

    // wait all exiting
    if (tb_aicp_wait_all((tb_aicp_ref_t)impl, 5000) <= 0) 
    {
        // wait failed, trace left aicos
        tb_spinlock_enter(&impl->lock);
        if (impl->pool) tb_fixed_pool_walk(impl->pool, tb_aicp_walk_wait, tb_null);
        tb_spinlock_leave(&impl->lock);
        return tb_false;
    }
   
    // kill loop
    tb_aicp_kill((tb_aicp_ref_t)impl);

    // wait workers exiting 
    tb_hong_t time = tb_mclock();
    while (tb_atomic_get(&impl->work) && (tb_mclock() < time + 5000)) tb_msleep(500);

    // exit proactor
    if (impl->ptor)
    {
        tb_assert(impl->ptor && impl->ptor->exit);
        impl->ptor->exit(impl->ptor);
        impl->ptor = tb_null;
    }

    // exit aico pool
    tb_spinlock_enter(&impl->lock);
    if (impl->pool) tb_fixed_pool_exit(impl->pool);
    impl->pool = tb_null;
    tb_spinlock_leave(&impl->lock);

    // exit lock
    tb_spinlock_exit(&impl->lock);

    // free impl
    tb_free(impl);

    // ok
    return tb_true;
}

tb_size_t tb_timer_delay(tb_timer_ref_t timer)
{
    // check
    tb_timer_impl_t* impl = (tb_timer_impl_t*)timer;
    tb_assert_and_check_return_val(impl && impl->heap, -1);

    // stoped?
    tb_assert_and_check_return_val(!tb_atomic_get(&impl->stop), -1);

    // enter
    tb_spinlock_enter(&impl->lock);

    // done
    tb_size_t delay = -1; 
    if (tb_heap_size(impl->heap))
    {
        // the task
        tb_timer_task_impl_t const* task_impl = (tb_timer_task_impl_t const*)tb_heap_top(impl->heap);
        if (task_impl)
        {
            // the now
            tb_hong_t now = tb_timer_now(impl);

            // the delay
            delay = task_impl->when > now? (tb_size_t)(task_impl->when - now) : 0;
        }
    }

    // leave
    tb_spinlock_leave(&impl->lock);

    // ok?
    return delay;
}

tb_hize_t tb_timer_top(tb_timer_ref_t timer)
{
    // check
    tb_timer_impl_t* impl = (tb_timer_impl_t*)timer;
    tb_assert_and_check_return_val(impl && impl->heap, -1);

    // stoped?
    tb_assert_and_check_return_val(!tb_atomic_get(&impl->stop), -1);

    // enter
    tb_spinlock_enter(&impl->lock);

    // done
    tb_hize_t when = -1; 
    if (tb_heap_size(impl->heap))
    {
        // the task
        tb_timer_task_impl_t const* task_impl = (tb_timer_task_impl_t const*)tb_heap_top(impl->heap);
        if (task_impl) when = task_impl->when;
    }

    // leave
    tb_spinlock_leave(&impl->lock);

    // ok?
    return when;
}

tb_size_t tb_thread_pool_task_post_list(tb_thread_pool_ref_t pool, tb_thread_pool_task_t const* list, tb_size_t size)
{
    // check
    tb_thread_pool_impl_t* impl = (tb_thread_pool_impl_t*)pool;
    tb_assert_and_check_return_val(impl && list, 0);

    // init the post size
    tb_size_t post_size = 0;

    // enter
    tb_spinlock_enter(&impl->lock);

    // done
    tb_size_t ok = 0;
    if (!impl->bstoped)
    {
        for (ok = 0; ok < size; ok++)
        {
            // post task
            tb_thread_pool_job_t* job = tb_thread_pool_jobs_post_task(impl, &list[ok], &post_size);
            tb_assert_and_check_break(job);
        }
    }

    // leave
    tb_spinlock_leave(&impl->lock);

    // post the workers
    if (ok && post_size) tb_thread_pool_worker_post(impl, post_size);

    // ok?
    return ok;
}

tb_void_t tb_pool_dump(tb_pool_ref_t pool)
{
    // check
    tb_pool_impl_t* impl = (tb_pool_impl_t*)pool;
    tb_assert_and_check_return(impl);

    // uses allocator?
    if (impl->allocator)
    {
        // dump it
        tb_allocator_dump(impl->allocator);
        return ;
    }

    // check
    tb_assert_and_check_return(impl->large_pool && impl->small_pool);

    // enter
    tb_spinlock_enter(&impl->lock);

    // dump pool
    tb_small_pool_dump(impl->small_pool);

    // leave
    tb_spinlock_leave(&impl->lock);
}

/* //////////////////////////////////////////////////////////////////////////////////////
 * implementation
 */
tb_aico_ref_t tb_aico_init(tb_aicp_ref_t aicp)
{
    // check
    tb_aicp_impl_t* aicp_impl = (tb_aicp_impl_t*)aicp;
    tb_assert_and_check_return_val(aicp_impl && aicp_impl->pool, tb_null);

    // enter 
    tb_spinlock_enter(&aicp_impl->lock);

    // make aico
    tb_aico_impl_t* aico = (tb_aico_impl_t*)tb_fixed_pool_malloc0(aicp_impl->pool);

    // init aico
    if (aico)
    {
        aico->aicp      = aicp;
        aico->type      = TB_AICO_TYPE_NONE;
        aico->handle    = tb_null;
        aico->state     = TB_STATE_CLOSED;

        // init timeout 
        tb_size_t i = 0;
        tb_size_t n = tb_arrayn(aico->timeout);
        for (i = 0; i < n; i++) aico->timeout[i] = -1;
    }

    // leave 
    tb_spinlock_leave(&aicp_impl->lock);
    
    // ok?
    return (tb_aico_ref_t)aico;
}

tb_void_t tb_aico_exit(tb_aico_ref_t aico)
{
    // check
    tb_aico_impl_t* impl = (tb_aico_impl_t*)aico;
    tb_aicp_impl_t* aicp_impl = (tb_aicp_impl_t*)impl->aicp;
    tb_assert_and_check_return(impl && aicp_impl && aicp_impl->pool);

    // wait closing?
    tb_size_t tryn = 15;
    while (tb_atomic_get(&impl->state) != TB_STATE_CLOSED && tryn--)
    {
        // trace
        tb_trace_d("exit[%p]: type: %lu, handle: %p, state: %s: wait: ..", aico, tb_aico_type(aico), impl->handle, tb_state_cstr(tb_atomic_get(&impl->state)));
    
        // wait some time
        tb_msleep(200);
    }

    // check
    tb_assert_abort(tb_atomic_get(&impl->state) == TB_STATE_CLOSED);
    tb_check_return(tb_atomic_get(&impl->state) == TB_STATE_CLOSED);

    // enter 
    tb_spinlock_enter(&aicp_impl->lock);

    // trace
    tb_trace_d("exit[%p]: type: %lu, handle: %p, state: %s: ok", aico, tb_aico_type(aico), impl->handle, tb_state_cstr(tb_atomic_get(&impl->state)));
    
    // free it
    tb_fixed_pool_free(aicp_impl->pool, aico);

    // leave 
    tb_spinlock_leave(&aicp_impl->lock);
}

/* //////////////////////////////////////////////////////////////////////////////////////
 * implementation
 */
tb_bool_t tb_native_memory_init()
{   
    // enter
    tb_spinlock_enter_without_profiler(&g_lock);

    // done
    tb_bool_t ok = tb_false;
    do
    {
        // have been inited?
        tb_check_break_state(!g_heap, ok, tb_true);

        // make heap
        g_heap = (tb_handle_t)HeapCreate(0, 0, 0);
        tb_check_break(g_heap);

        // ok
        ok = tb_true;

    } while (0);

    // leave
    tb_spinlock_leave(&g_lock);

    // ok?
    return ok;
}

tb_pointer_t tb_native_memory_ralloc(tb_pointer_t data, tb_size_t size)
{
    // no size? free it
    if (!size) 
    {
        tb_native_memory_free(data);
        return tb_null;
    }
    // no data? malloc it
    else if (!data) return tb_native_memory_malloc(size);
    // realloc it
    else 
    {
        // enter 
        tb_spinlock_enter_without_profiler(&g_lock);

        // realloc
        if (g_heap) data = (tb_pointer_t)HeapReAlloc((HANDLE)g_heap, 0, data, (SIZE_T)size);

        // leave
        tb_spinlock_leave(&g_lock);

        // ok?
        return data;
    }
}

static tb_bool_t tb_aiop_rtor_poll_post(tb_aiop_rtor_impl_t* rtor, tb_aioe_t const* aioe)
{
    // check
    tb_aiop_rtor_poll_impl_t* impl = (tb_aiop_rtor_poll_impl_t*)rtor;
    tb_assert_and_check_return_val(impl && impl->pfds && impl->cfds && aioe, tb_false);

    // the aiop
    tb_aiop_impl_t* aiop = rtor->aiop;
    tb_assert_and_check_return_val(aiop, tb_false);

    // the aioo
    tb_aioo_impl_t* aioo = (tb_aioo_impl_t*)aioe->aioo;
    tb_assert_and_check_return_val(aioo, tb_false);

    // save aioo
    aioo->code = aioe->code;
    aioo->priv = aioe->priv;

    // sete it, TODO: sete by binary search
    tb_spinlock_enter(&impl->lock.pfds);
    tb_walk_all(impl->pfds, tb_poll_walk_sete, (tb_pointer_t)aioe);
    tb_spinlock_leave(&impl->lock.pfds);

    // spak it
    if (aiop->spak[0]) tb_socket_send(aiop->spak[0], (tb_byte_t const*)"p", 1);

    // ok
    return tb_true;
}

tb_void_t tb_pool_exit(tb_pool_ref_t pool)
{
    // check
    tb_pool_impl_t* impl = (tb_pool_impl_t*)pool;
    tb_assert_and_check_return(impl);

    // uses allocator?
    if (impl->allocator)
    {
        // exit it
        tb_allocator_free(impl->allocator, impl);
        return ;
    }

    // enter
    tb_spinlock_enter(&impl->lock);

    // exit small pool
    if (impl->small_pool) tb_small_pool_exit(impl->small_pool);
    impl->small_pool = tb_null;

    // leave
    tb_spinlock_leave(&impl->lock);

    // exit lock
    tb_spinlock_exit(&impl->lock);

    // exit pool
    if (impl->large_pool) tb_large_pool_free(impl->large_pool, impl);
}