/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */ tb_list_ref_t tb_list_init(tb_size_t grow, tb_element_t element) { // check tb_assert_and_check_return_val(element.size && element.data && element.dupl && element.repl, tb_null); // done tb_bool_t ok = tb_false; tb_list_t* list = tb_null; do { // using the default grow if (!grow) grow = TB_LIST_GROW; // make self list = tb_malloc0_type(tb_list_t); tb_assert_and_check_break(list); // init element list->element = element; // init iterator list->itor.mode = TB_ITERATOR_MODE_FORWARD | TB_ITERATOR_MODE_REVERSE; list->itor.priv = tb_null; list->itor.step = element.size; list->itor.size = tb_list_itor_size; list->itor.head = tb_list_itor_head; list->itor.last = tb_list_itor_last; list->itor.tail = tb_list_itor_tail; list->itor.prev = tb_list_itor_prev; list->itor.next = tb_list_itor_next; list->itor.item = tb_list_itor_item; list->itor.copy = tb_list_itor_copy; list->itor.comp = tb_list_itor_comp; list->itor.remove = tb_list_itor_remove; list->itor.remove_range = tb_list_itor_remove_range; // init pool, item = entry + data list->pool = tb_fixed_pool_init(tb_null, grow, sizeof(tb_list_entry_t) + element.size, tb_null, tb_list_item_exit, (tb_cpointer_t)list); tb_assert_and_check_break(list->pool); // init head tb_list_entry_init_(&list->head, 0, sizeof(tb_list_entry_t) + element.size, tb_null); // ok ok = tb_true; } while (0); // failed? if (!ok) { // exit it if (list) tb_list_exit((tb_list_ref_t)list); list = tb_null; } // ok? return (tb_list_ref_t)list; }
/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */ gb_mesh_face_list_ref_t gb_mesh_face_list_init(tb_element_t element) { // check tb_assert_and_check_return_val(element.data && element.dupl && element.repl, tb_null); // done tb_bool_t ok = tb_false; gb_mesh_face_list_impl_t* impl = tb_null; do { // make list impl = tb_malloc0_type(gb_mesh_face_list_impl_t); tb_assert_and_check_break(impl); // init element impl->element = element; // init pool, item = face + data impl->pool = tb_fixed_pool_init(tb_null, GB_MESH_FACE_LIST_GROW, sizeof(gb_mesh_face_t) + element.size, tb_null, gb_mesh_face_exit, (tb_cpointer_t)impl); tb_assert_and_check_break(impl->pool); // init head tb_list_entry_init_(&impl->head, 0, sizeof(gb_mesh_face_t) + element.size, tb_null); // init order impl->order = GB_MESH_ORDER_INSERT_TAIL; // ok ok = tb_true; } while (0); // failed? if (!ok) { // exit it if (impl) gb_mesh_face_list_exit((gb_mesh_face_list_ref_t)impl); impl = tb_null; } // ok? return (gb_mesh_face_list_ref_t)impl; }
/* ////////////////////////////////////////////////////////////////////////////////////// * implementation */ gb_mesh_edge_list_ref_t gb_mesh_edge_list_init(tb_element_t element) { // check tb_assert_and_check_return_val(element.data && element.dupl && element.repl, tb_null); // done tb_bool_t ok = tb_false; gb_mesh_edge_list_impl_t* impl = tb_null; do { // make list impl = tb_malloc0_type(gb_mesh_edge_list_impl_t); tb_assert_and_check_break(impl); // init element impl->element = element; // init order impl->order = GB_MESH_ORDER_INSERT_TAIL; // init edge size impl->edge_size = tb_align_cpu(sizeof(gb_mesh_edge_t) + element.size); // init iterator impl->itor.mode = TB_ITERATOR_MODE_FORWARD | TB_ITERATOR_MODE_REVERSE | TB_ITERATOR_MODE_READONLY; impl->itor.priv = tb_null; impl->itor.step = impl->edge_size << 1; impl->itor.size = gb_mesh_edge_itor_size; impl->itor.head = gb_mesh_edge_itor_head; impl->itor.last = gb_mesh_edge_itor_last; impl->itor.tail = gb_mesh_edge_itor_tail; impl->itor.prev = gb_mesh_edge_itor_prev; impl->itor.next = gb_mesh_edge_itor_next; impl->itor.item = gb_mesh_edge_itor_item; // init pool, item = (edge + data) + (edge->sym + data) impl->pool = tb_fixed_pool_init(tb_null, GB_MESH_EDGE_LIST_GROW, impl->edge_size << 1, tb_null, gb_mesh_edge_exit, (tb_cpointer_t)impl); tb_assert_and_check_break(impl->pool); // init head edge impl->head[0].sym = &impl->head[1]; impl->head[1].sym = &impl->head[0]; // init edge list gb_mesh_edge_init(impl->head); // ok ok = tb_true; } while (0); // failed? if (!ok) { // exit it if (impl) gb_mesh_edge_list_exit((gb_mesh_edge_list_ref_t)impl); impl = tb_null; } // ok? return (gb_mesh_edge_list_ref_t)impl; }
tb_thread_pool_ref_t tb_thread_pool_init(tb_size_t worker_maxn, tb_size_t stack) { // done tb_bool_t ok = tb_false; tb_thread_pool_impl_t* impl = tb_null; do { // make pool impl = tb_malloc0_type(tb_thread_pool_impl_t); tb_assert_and_check_break(impl); // init lock if (!tb_spinlock_init(&impl->lock)) break; // computate the default worker maxn if be zero if (!worker_maxn) worker_maxn = tb_processor_count() << 2; tb_assert_and_check_break(worker_maxn); // init thread stack impl->stack = stack; // init workers impl->worker_size = 0; impl->worker_maxn = worker_maxn; // init jobs pool impl->jobs_pool = tb_fixed_pool_init(tb_null, TB_THREAD_POOL_JOBS_POOL_GROW, sizeof(tb_thread_pool_job_t), tb_null, tb_null, tb_null); tb_assert_and_check_break(impl->jobs_pool); // init jobs urgent tb_list_entry_init(&impl->jobs_urgent, tb_thread_pool_job_t, entry, tb_null); // init jobs waiting tb_list_entry_init(&impl->jobs_waiting, tb_thread_pool_job_t, entry, tb_null); // init jobs pending tb_list_entry_init(&impl->jobs_pending, tb_thread_pool_job_t, entry, tb_null); // init semaphore impl->semaphore = tb_semaphore_init(0); tb_assert_and_check_break(impl->semaphore); // register lock profiler #ifdef TB_LOCK_PROFILER_ENABLE tb_lock_profiler_register(tb_lock_profiler(), (tb_pointer_t)&impl->lock, TB_TRACE_MODULE_NAME); #endif // ok ok = tb_true; } while (0); // failed? if (!ok) { // exit it if (impl) tb_thread_pool_exit((tb_thread_pool_ref_t)impl); impl = tb_null; } // ok? return (tb_thread_pool_ref_t)impl; }