tb_pointer_t tb_allocator_malloc_(tb_allocator_ref_t allocator, tb_size_t size __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(allocator, tb_null);
// enter
tb_spinlock_enter(&allocator->lock);
// malloc it
tb_pointer_t data = tb_null;
if (allocator->malloc) data = allocator->malloc(allocator, size __tb_debug_args__);
else if (allocator->large_malloc) data = allocator->large_malloc(allocator, size, tb_null __tb_debug_args__);
// check
tb_assertf(data, "malloc(%lu) failed!", size);
tb_assertf(!(((tb_size_t)data) & (TB_POOL_DATA_ALIGN - 1)), "malloc(%lu): unaligned data: %p", size, data);
// leave
tb_spinlock_leave(&allocator->lock);
#ifdef __tb_alloc_trace__
tb_trace_w("tb_allocator_malloc_(%p): %lu", data, size, func_, line_, file_);
#endif
// ok?
return data;
}
tb_pointer_t tb_allocator_malloc0_(tb_allocator_ref_t allocator, tb_size_t size __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(allocator, tb_null);
#ifdef __tb_alloc_trace__
tb_trace_w("tb_allocator_malloc0_(): %lu", size, func_, line_, file_);
#endif
// malloc it
tb_pointer_t data = tb_allocator_malloc_(allocator, size __tb_debug_args__);
#ifdef __tb_alloc_trace__
tb_trace_w("tb_allocator_malloc0_(%p): %lu", data, size, func_, line_, file_);
#endif
// clear it
if (data) tb_memset_(data, 0, size);
// ok?
return data;
}
/* //////////////////////////////////////////////////////////////////////////////////////
* implementation
*/
tb_bool_t tb_android_init(JavaVM* jvm)
{
// check
if (!jvm)
{
// warning
tb_trace_w("the java machine be not inited, please pass it to the tb_init function!");
}
// init it
tb_atomic_set(&g_jvm, (tb_size_t)jvm);
// ok
return tb_true;
}
tb_void_t tb_timer_exit(tb_timer_ref_t timer)
{
// check
tb_timer_impl_t* impl = (tb_timer_impl_t*)timer;
tb_assert_and_check_return(impl);
// stop it
tb_atomic_set(&impl->stop, 1);
// wait loop exit
tb_size_t tryn = 10;
while (tb_atomic_get(&impl->work) && tryn--) tb_msleep(500);
// warning
if (!tryn && tb_atomic_get(&impl->work)) tb_trace_w("[timer]: the loop has been not exited now!");
// post event
tb_spinlock_enter(&impl->lock);
tb_event_ref_t event = impl->event;
tb_spinlock_leave(&impl->lock);
if (event) tb_event_post(event);
// enter
tb_spinlock_enter(&impl->lock);
// exit heap
if (impl->heap) tb_heap_exit(impl->heap);
impl->heap = tb_null;
// exit pool
if (impl->pool) tb_fixed_pool_exit(impl->pool);
impl->pool = tb_null;
// exit event
if (impl->event) tb_event_exit(impl->event);
impl->event = tb_null;
// leave
tb_spinlock_leave(&impl->lock);
// exit lock
tb_spinlock_exit(&impl->lock);
// exit it
tb_free(impl);
}
static __tb_inline__ tb_bool_t xm_version_check(tb_hize_t build)
{
// the version oly for link the static vtag string
tb_version_t const* version = tb_version(); tb_used(version);
// ok
if ((build / 100) == (XM_VERSION_BUILD / 100))
{
tb_trace_d("version: %s", XM_VERSION_STRING);
return tb_true;
}
else
{
tb_trace_w("version: %s != %llu", XM_VERSION_STRING, build);
}
// no
return tb_false;
}
static __tb_inline__ tb_bool_t tb_version_check(tb_hize_t build)
{
#ifdef TB_CONFIG_INFO_HAVE_VERSION
// the version oly for link the static vtag string
tb_version_t const* version = tb_version(); tb_used(version);
#endif
// ok
if ((build / 100) == (TB_VERSION_BUILD / 100))
{
tb_trace_d("version: %s", TB_VERSION_STRING);
return tb_true;
}
else
{
tb_trace_w("version: %s != %llu", TB_VERSION_STRING, build);
}
// no
return tb_false;
}
tb_pointer_t tb_allocator_ralloc_(tb_allocator_ref_t allocator, tb_pointer_t data, tb_size_t size __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(allocator, tb_null);
// enter
tb_spinlock_enter(&allocator->lock);
// ralloc it
tb_pointer_t data_new = tb_null;
if (allocator->ralloc) data_new = allocator->ralloc(allocator, data, size __tb_debug_args__);
else if (allocator->large_ralloc) data_new = allocator->large_ralloc(allocator, data, size, tb_null __tb_debug_args__);
// failed? dump it
#ifdef __tb_debug__
if (!data_new)
{
// trace
tb_trace_e("ralloc(%p, %lu) failed! at %s(): %lu, %s", data, size, func_, line_, file_);
// dump data
tb_pool_data_dump((tb_byte_t const*)data, tb_true, "[large_allocator]: [error]: ");
// abort
tb_abort();
}
#endif
// check
tb_assertf(!(((tb_size_t)data_new) & (TB_POOL_DATA_ALIGN - 1)), "ralloc(%lu): unaligned data: %p", size, data);
// leave
tb_spinlock_leave(&allocator->lock);
#ifdef __tb_alloc_trace__
tb_trace_w("tb_allocator_ralloc_(%p): %lu (%p)", data_new, size, data, func_, line_, file_);
#endif
// ok?
return data_new;
}
tb_bool_t tb_allocator_free_(tb_allocator_ref_t allocator, tb_pointer_t data __tb_debug_decl__)
{
// check
tb_assert_and_check_return_val(allocator, tb_false);
// enter
tb_spinlock_enter(&allocator->lock);
// free it
tb_bool_t ok = tb_false;
if (allocator->free) ok = allocator->free(allocator, data __tb_debug_args__);
else if (allocator->large_free) ok = allocator->large_free(allocator, data __tb_debug_args__);
// failed? dump it
#ifdef __tb_debug__
if (!ok)
{
// trace
tb_trace_e("free(%p) failed! at %s(): %lu, %s", data, func_, line_, file_);
// dump data
tb_pool_data_dump((tb_byte_t const*)data, tb_true, "[large_allocator]: [error]: ");
// abort
tb_abort();
}
#endif
// leave
tb_spinlock_leave(&allocator->lock);
#ifdef __tb_alloc_trace__
tb_trace_w("tb_allocator_free_(%p)", data, func_, line_, file_);
#endif
// ok?
return ok;
}
