本文整理汇总了C++中tb_spinlock_leave函数的典型用法代码示例。如果您正苦于以下问题:C++ tb_spinlock_leave函数的具体用法?C++ tb_spinlock_leave怎么用?C++ tb_spinlock_leave使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了tb_spinlock_leave函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: tb_aiop_rtor_poll_delo
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;
}
示例2: tb_aiop_rtor_poll_exit
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);
}
}
示例3: tb_aiop_rtor_select_cler
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);
}
}
示例4: tb_aiop_rtor_select_addo
/* //////////////////////////////////////////////////////////////////////////////////////
* 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;
}
示例5: tb_aicp_exit
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;
}
示例6: tb_timer_delay
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;
}
示例7: tb_timer_top
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;
}
示例8: tb_thread_pool_task_post_list
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;
}
示例9: tb_pool_dump
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);
}
示例10: tb_aico_init
/* //////////////////////////////////////////////////////////////////////////////////////
* 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;
}
示例11: tb_aico_exit
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);
}
示例12: tb_native_memory_init
/* //////////////////////////////////////////////////////////////////////////////////////
* 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;
}
示例13: tb_native_memory_ralloc
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;
}
}
示例14: tb_aiop_rtor_poll_post
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;
}
示例15: tb_pool_exit
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);
}