tb_void_t tb_small_pool_dump(tb_small_pool_ref_t pool)
{
// check
tb_small_pool_impl_t* impl = (tb_small_pool_impl_t*)pool;
tb_assert_and_check_return(impl && impl->large_pool);
// trace
tb_trace_i("");
// dump fixed pool
tb_size_t i = 0;
tb_size_t n = tb_arrayn(impl->fixed_pool);
for (i = 0; i < n; i++)
{
// exists?
if (impl->fixed_pool[i])
{
// check it
tb_fixed_pool_walk(impl->fixed_pool[i], tb_small_pool_item_check, (tb_cpointer_t)impl->fixed_pool[i]);
// dump it
tb_fixed_pool_dump(impl->fixed_pool[i]);
}
}
}
tb_bool_t tb_transfer_pool_exit(tb_transfer_pool_ref_t pool)
{
// check
tb_transfer_pool_impl_t* impl = (tb_transfer_pool_impl_t*)pool;
tb_assert_and_check_return_val(impl, tb_false);
// trace
tb_trace_d("exit: ..");
// kill it first
tb_transfer_pool_kill(pool);
// wait all
if (tb_transfer_pool_wait_all(pool, 5000) <= 0)
{
// trace
tb_trace_e("exit: wait failed!");
return tb_false;
}
// enter
tb_spinlock_enter(&impl->lock);
// check
tb_assert(!tb_list_entry_size(&impl->work));
// exit the work list
tb_list_entry_exit(&impl->work);
// exit the idle list
tb_list_entry_exit(&impl->idle);
// exit pool
if (impl->pool)
{
// exit all task
tb_fixed_pool_walk(impl->pool, tb_transfer_pool_walk_exit, tb_null);
// exit it
tb_fixed_pool_exit(impl->pool);
impl->pool = tb_null;
}
// leave
tb_spinlock_leave(&impl->lock);
// exit lock
tb_spinlock_exit(&impl->lock);
// exit it
tb_free(pool);
// trace
tb_trace_d("exit: ok");
// ok
return tb_true;
}
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_void_t tb_thread_pool_task_kill_all(tb_thread_pool_ref_t pool)
{
// check
tb_thread_pool_impl_t* impl = (tb_thread_pool_impl_t*)pool;
tb_assert_and_check_return(impl);
// enter
tb_spinlock_enter(&impl->lock);
// kill all jobs
if (!impl->bstoped && impl->jobs_pool)
tb_fixed_pool_walk(impl->jobs_pool, tb_thread_pool_jobs_walk_kill_all, tb_null);
// leave
tb_spinlock_leave(&impl->lock);
}
tb_void_t tb_aicp_kill_all(tb_aicp_ref_t aicp)
{
// check
tb_aicp_impl_t* impl = (tb_aicp_impl_t*)aicp;
tb_assert_and_check_return(impl);
// trace
tb_trace_d("kill: all: ..");
// kill all
if (!tb_atomic_fetch_and_set(&impl->kill_all, 1))
{
tb_spinlock_enter(&impl->lock);
if (impl->pool) tb_fixed_pool_walk(impl->pool, tb_aicp_walk_kill, impl);
tb_spinlock_leave(&impl->lock);
}
}
tb_void_t tb_thread_pool_dump(tb_thread_pool_ref_t pool)
{
// check
tb_thread_pool_impl_t* impl = (tb_thread_pool_impl_t*)pool;
tb_assert_and_check_return(impl);
// enter
tb_spinlock_enter(&impl->lock);
// dump workers
if (impl->worker_size)
{
// trace
tb_trace_i("");
tb_trace_i("workers: size: %lu, maxn: %lu", impl->worker_size, impl->worker_maxn);
// walk
tb_size_t i = 0;
for (i = 0; i < impl->worker_size; i++)
{
// the worker
tb_thread_pool_worker_t* worker = &impl->worker_list[i];
tb_assert_and_check_break(worker);
// dump worker
tb_trace_i(" worker: id: %lu, stoped: %ld", worker->id, (tb_long_t)tb_atomic_get(&worker->bstoped));
}
// trace
tb_trace_i("");
// dump all jobs
if (impl->jobs_pool)
{
// trace
tb_trace_i("jobs: size: %lu", tb_fixed_pool_size(impl->jobs_pool));
// dump jobs
tb_fixed_pool_walk(impl->jobs_pool, tb_thread_pool_jobs_walk_dump_all, tb_null);
}
}
// leave
tb_spinlock_leave(&impl->lock);
}
tb_void_t tb_thread_pool_kill(tb_thread_pool_ref_t pool)
{
// check
tb_thread_pool_impl_t* impl = (tb_thread_pool_impl_t*)pool;
tb_assert_and_check_return(impl);
// enter
tb_spinlock_enter(&impl->lock);
// kill it
tb_size_t post = 0;
if (!impl->bstoped)
{
// trace
tb_trace_d("kill: ..");
// stoped
impl->bstoped = tb_true;
// kill all workers
tb_size_t i = 0;
tb_size_t n = impl->worker_size;
for (i = 0; i < n; i++) tb_atomic_set(&impl->worker_list[i].bstoped, 1);
// kill all jobs
if (impl->jobs_pool) tb_fixed_pool_walk(impl->jobs_pool, tb_thread_pool_jobs_walk_kill_all, tb_null);
// post it
post = impl->worker_size;
}
// leave
tb_spinlock_leave(&impl->lock);
// post the workers
if (post) tb_thread_pool_worker_post(impl, post);
}
tb_void_t tb_fixed_pool_clear(tb_fixed_pool_ref_t pool)
{
// check
tb_fixed_pool_impl_t* impl = (tb_fixed_pool_impl_t*)pool;
tb_assert_and_check_return(impl);
// exit items
if (impl->func_exit) tb_fixed_pool_walk(pool, tb_fixed_pool_item_exit, (tb_pointer_t)impl);
// exit the current slot first
if (impl->current_slot) tb_fixed_pool_slot_exit(impl, impl->current_slot);
impl->current_slot = tb_null;
// exit the partial slots
tb_iterator_ref_t partial_iterator = tb_list_entry_itor(&impl->partial_slots);
if (partial_iterator)
{
// walk it
tb_size_t itor = tb_iterator_head(partial_iterator);
while (itor != tb_iterator_tail(partial_iterator))
{
// the slot
tb_fixed_pool_slot_t* slot = (tb_fixed_pool_slot_t*)tb_iterator_item(partial_iterator, itor);
tb_assert_and_check_break(slot);
// save next
tb_size_t next = tb_iterator_next(partial_iterator, itor);
// exit data
tb_fixed_pool_slot_exit(impl, slot);
// next
itor = next;
}
}
// exit the full slots
tb_iterator_ref_t full_iterator = tb_list_entry_itor(&impl->full_slots);
if (full_iterator)
{
// walk it
tb_size_t itor = tb_iterator_head(full_iterator);
while (itor != tb_iterator_tail(full_iterator))
{
// the slot
tb_fixed_pool_slot_t* slot = (tb_fixed_pool_slot_t*)tb_iterator_item(full_iterator, itor);
tb_assert_and_check_break(slot);
// save next
tb_size_t next = tb_iterator_next(full_iterator, itor);
// exit data
tb_fixed_pool_slot_exit(impl, slot);
// next
itor = next;
}
}
// clear item count
impl->item_count = 0;
// clear current slot
impl->current_slot = tb_null;
// clear partial slots
tb_list_entry_clear(&impl->partial_slots);
// clear full slots
tb_list_entry_clear(&impl->full_slots);
}
tb_void_t tb_fixed_pool_clear(tb_fixed_pool_ref_t self)
{
// check
tb_fixed_pool_t* pool = (tb_fixed_pool_t*)self;
tb_assert_and_check_return(pool);
// exit items
if (pool->func_exit) tb_fixed_pool_walk(self, tb_fixed_pool_item_exit, (tb_pointer_t)pool);
// exit the partial slots
tb_iterator_ref_t partial_iterator = tb_list_entry_itor(&pool->partial_slots);
if (partial_iterator)
{
// walk it
tb_size_t itor = tb_iterator_head(partial_iterator);
while (itor != tb_iterator_tail(partial_iterator))
{
// the slot
tb_fixed_pool_slot_t* slot = (tb_fixed_pool_slot_t*)tb_iterator_item(partial_iterator, itor);
tb_assert_and_check_break(slot);
// check
tb_assert(slot != pool->current_slot);
// save next
tb_size_t next = tb_iterator_next(partial_iterator, itor);
// exit slot
tb_fixed_pool_slot_exit(pool, slot);
// next
itor = next;
}
}
// exit the full slots
tb_iterator_ref_t full_iterator = tb_list_entry_itor(&pool->full_slots);
if (full_iterator)
{
// walk it
tb_size_t itor = tb_iterator_head(full_iterator);
while (itor != tb_iterator_tail(full_iterator))
{
// the slot
tb_fixed_pool_slot_t* slot = (tb_fixed_pool_slot_t*)tb_iterator_item(full_iterator, itor);
tb_assert_and_check_break(slot);
// check
tb_assert(slot != pool->current_slot);
// save next
tb_size_t next = tb_iterator_next(full_iterator, itor);
// exit slot
tb_fixed_pool_slot_exit(pool, slot);
// next
itor = next;
}
}
// clear current slot
if (pool->current_slot && pool->current_slot->pool)
tb_static_fixed_pool_clear(pool->current_slot->pool);
// clear item count
pool->item_count = 0;
// clear partial slots
tb_list_entry_clear(&pool->partial_slots);
// clear full slots
tb_list_entry_clear(&pool->full_slots);
}
