自学教程：C++ tb_mclock函数代码示例

/* ////////////////////////////////////////////////////////////////////////////////////// * test */static tb_void_t tb_find_int_test(){    __tb_volatile__ tb_size_t i = 0;    __tb_volatile__ tb_size_t n = 1000;    // init data    tb_long_t* data = (tb_long_t*)tb_nalloc0(n, sizeof(tb_long_t));    tb_assert_and_check_return(data);        // init iterator    tb_array_iterator_t array_iterator;    tb_iterator_ref_t   iterator = tb_array_iterator_init_long(&array_iterator, data, n);    // make    for (i = 0; i < n; i++) data[i] = i;    // find    tb_size_t itor = tb_iterator_tail(iterator);    tb_hong_t time = tb_mclock();    for (i = 0; i < n; i++) itor = tb_find_all(iterator, (tb_pointer_t)data[800]);    time = tb_mclock() - time;    // item    tb_long_t item = itor != tb_iterator_tail(iterator)? (tb_long_t)tb_iterator_item(iterator, itor) : 0;    // time    tb_trace_i("tb_find_int_all[%ld ?= %ld]: %lld ms", item, data[800], time);    // free    tb_free(data);}

static tb_void_t tb_fixed_test_sin(){#if 1    __tb_volatile__ tb_int_t    i = 0;    __tb_volatile__ tb_int_t    n = 10000000 / 360;    __tb_volatile__ tb_fixed_t  r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        for (i = 0; i < 360; i++)            r = tb_fixed_sin(tb_fixed_test_angle[i]);    }    t = tb_mclock() - t;    for (i = 0; i < 360; i++)    {        r = tb_fixed_sin(tb_fixed_test_angle[i]);        tb_printf("[fixed]: sin(%f) = %f, angle: %d/n", tb_fixed_to_float(tb_fixed_test_angle[i]), tb_fixed_to_float(r), i);    }    tb_printf("[fixed]: sin(0 - 360), %lld ms/n", t);#else    tb_int_t i = 0;    for (i = 0; i < 360; i++)    {        tb_printf(",/t0x%x/n", tb_float_to_fixed(i * TB_DOUBLE_PI / 180));    }#endif}

static tb_void_t tb_float_test_atan(){    __tb_volatile__ tb_long_t   i = 0;    __tb_volatile__ tb_long_t   n = 10000000 / 100;    __tb_volatile__ tb_float_t  r = 0;    __tb_volatile__ tb_float_t  a = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        for (i = -50; i <= 50; i++)        {            a = tb_float_test_atan_a[i + 50];            r = tb_atanf(a);        }    }    t = tb_mclock() - t;    for (i = -50; i <= 50; i++)    {        a = tb_float_test_atan_a[i + 50];        r = tb_atanf(a);        tb_printf("[float]: atan(%f) = %f/n", (a), (r));    }    tb_printf("[float]: atan, %lld ms/n", t);}

static tb_void_t tb_float_test_sin(){#if 1    __tb_volatile__ tb_long_t       i = 0;    __tb_volatile__ tb_long_t       n = 10000000 / 360;    __tb_volatile__ tb_float_t      r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        for (i = 0; i < 360; i++)            r = tb_sinf(tb_float_test_angle[i]);    }    t = tb_mclock() - t;    for (i = 0; i < 360; i++)    {        r = tb_sinf(tb_float_test_angle[i]);        tb_printf("[float]: sin(%f) = %f, angle: %ld/n", (tb_float_test_angle[i]), (r), i);    }    tb_printf("[float]: sin(0 - 360), %lld ms/n", t);#else    tb_long_t i = 0;    for (i = 0; i < 360; i++)    {        tb_printf(",/t%f/n", (i * TB_PI / 180));    }#endif}

static tb_size_t tb_vector_insert_tail_test(){    // init    tb_vector_ref_t vector = tb_vector_init(TB_VECTOR_GROW_SIZE, tb_element_long());    tb_assert_and_check_return_val(vector, 0);    __tb_volatile__ tb_size_t i = 0;    __tb_volatile__ tb_size_t n = 10000;    tb_hong_t t = tb_mclock();    for (i = 0; i < n; i++) tb_vector_insert_tail(vector, (tb_pointer_t)0xf);    t = tb_mclock() - t;    // time    tb_trace_i("tb_vector_insert_tail(%lu): %lld ms, size: %lu, maxn: %lu", n, t, tb_vector_size(vector), tb_vector_maxn(vector));    // check    tb_assert(tb_vector_size(vector) == n);    tb_assert(tb_vector_head(vector) == (tb_pointer_t)0xf);    tb_assert(tb_vector_last(vector) == (tb_pointer_t)0xf);    // clear it    tb_vector_clear(vector);    tb_assert(!tb_vector_size(vector));    // exit    tb_vector_exit(vector);    return n / ((tb_uint32_t)(t) + 1);}

static tb_size_t tb_vector_nreplace_last_test(){    // init    tb_vector_ref_t vector = tb_vector_init(TB_VECTOR_GROW_SIZE, tb_element_long());    tb_assert_and_check_return_val(vector, 0);    tb_size_t n = 10000;    tb_vector_ninsert_head(vector, (tb_pointer_t)0xf, n);    tb_hong_t t = tb_mclock();    tb_vector_nreplace_last(vector, (tb_pointer_t)0xd, n);    t = tb_mclock() - t;    // time    tb_trace_i("tb_vector_nreplace_last(%lu): %lld ms, size: %lu, maxn: %lu", n, t, tb_vector_size(vector), tb_vector_maxn(vector));    // check    tb_assert(tb_vector_size(vector) == n);    tb_assert(tb_vector_head(vector) == (tb_pointer_t)0xd);    tb_assert(tb_vector_last(vector) == (tb_pointer_t)0xd);    // exit    tb_vector_exit(vector);    return n / ((tb_uint32_t)(t) + 1);}

/* ////////////////////////////////////////////////////////////////////////////////////// * test */static tb_void_t tb_sort_int_test_perf(tb_size_t n){    __tb_volatile__ tb_size_t i = 0;    // init data    tb_long_t* data = (tb_long_t*)tb_nalloc0(n, sizeof(tb_long_t));    tb_assert_and_check_return(data);    // init iterator    tb_array_iterator_t array_iterator;    tb_iterator_ref_t   iterator = tb_iterator_make_for_long(&array_iterator, data, n);    // make    tb_random_clear(tb_null);    for (i = 0; i < n; i++) data[i] = tb_random_range(tb_null, TB_MINS16, TB_MAXS16);    // sort    tb_hong_t time = tb_mclock();    tb_sort_all(iterator, tb_null);    time = tb_mclock() - time;    // time    tb_trace_i("tb_sort_int_all: %lld ms", time);    // check    for (i = 1; i < n; i++) tb_assert_and_check_break(data[i - 1] <= data[i]);    // free    tb_free(data);}

static tb_void_t tb_test_wcsnlen(tb_wchar_t const* s, tb_size_t size){    __tb_volatile__ tb_long_t   n = 1000000;    __tb_volatile__ tb_long_t   r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_wcsnlen(s, size);    }    t = tb_mclock() - t;    tb_wprintf(L"%lld ms, tb_test_wcsnlen(%s, %ld) = %d/n", t, s, size, r);}

static tb_void_t tb_test_wcsnicmp(tb_wchar_t const* s1, tb_wchar_t const* s2, tb_size_t size){    __tb_volatile__ tb_long_t   n = 1000000;    __tb_volatile__ tb_long_t   r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_wcsnicmp(s1, s2, size);    }    t = tb_mclock() - t;    tb_wprintf(L"%lld ms, tb_test_wcsnicmp(%s, %s, %u) = %ld/n", t, s1, s2, size, r);}

static tb_void_t tb_fixed_test_exp(tb_fixed_t x){    __tb_volatile__ tb_int_t    n = 10000000;    __tb_volatile__ tb_fixed_t  r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_fixed_exp(x);    }    t = tb_mclock() - t;    tb_printf("[fixed]: exp(%f) = %f, %lld ms/n", tb_fixed_to_float(x), tb_fixed_to_float(r), t);}

static tb_void_t tb_fixed_test_ilog2(tb_fixed_t x){    __tb_volatile__ tb_int_t    n = 10000000;    __tb_volatile__ tb_uint32_t     r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_fixed_ilog2(x);    }    t = tb_mclock() - t;    tb_printf("[fixed]: ilog2(%f) = %d, %lld ms/n", tb_fixed_to_float(x), r, t);}

static tb_void_t tb_fixed_test_div(tb_fixed_t a, tb_fixed_t b){    __tb_volatile__ tb_int_t    n = 10000000;    __tb_volatile__ tb_fixed_t  r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_fixed_div(a, b);    }    t = tb_mclock() - t;    tb_printf("[fixed]: div(%f, %f): %f, %lld ms/n", tb_fixed_to_float(a), tb_fixed_to_float(b), tb_fixed_to_float(r), t);}

static tb_void_t tb_fixed_test_ceil(tb_fixed_t x){    __tb_volatile__ tb_int_t    n = 10000000;    __tb_volatile__ tb_int_t    r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_fixed_ceil(x);    }    t = tb_mclock() - t;    tb_printf("[fixed]: ceil(%f): %d, %lld ms/n", tb_fixed_to_float(x), r, t);}

static tb_void_t tb_test_strcpy(tb_char_t const* s2){    __tb_volatile__ tb_int_t    n = 1000000;    tb_char_t s1[4096];    tb_hong_t t = tb_mclock();    while (n--)    {        tb_strcpy(s1, s2);    }    t = tb_mclock() - t;    tb_printf("%lld ms, tb_test_strcpy(%s) = %s/n", t, s2, s1);}

static tb_void_t tb_test_stricmp(tb_char_t const* s1, tb_char_t const* s2){    __tb_volatile__ tb_long_t   n = 1000000;    __tb_volatile__ tb_long_t   r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_stricmp(s1, s2);    }    t = tb_mclock() - t;    tb_printf("%lld ms, tb_test_stricmp(%s, %s) = %ld/n", t, s1, s2, r);}

static tb_void_t tb_test_wcslen(tb_wchar_t const* s){    __tb_volatile__ tb_long_t   n = 1000000;    __tb_volatile__ tb_long_t   r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_wcslen(s);    }    t = tb_mclock() - t;    tb_wprintf(L"%lld ms, tb_test_wcslen(%s) = %ld/n", t, s, r);}

static tb_void_t tb_float_test_exp(tb_float_t x){    __tb_volatile__ tb_long_t       n = 10000000;    __tb_volatile__ tb_float_t      r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_expf(x);    }    t = tb_mclock() - t;    tb_printf("[float]: exp(%f) = %f, %lld ms/n", (x), r, t);}

static tb_void_t tb_test_wcsncpy(tb_wchar_t const* s2, tb_size_t size){    __tb_volatile__ tb_int_t    n = 1000000;    tb_wchar_t s1[4096];    tb_hong_t t = tb_mclock();    while (n--)    {        tb_wcslcpy(s1, s2, size);    }    t = tb_mclock() - t;    tb_wprintf(L"%lld ms, tb_test_wcsncpy(%s, %lu) = %s/n", t, s2, size, s1);}

static tb_void_t tb_float_test_ceil(tb_float_t x){    __tb_volatile__ tb_long_t       n = 10000000;    __tb_volatile__ tb_long_t       r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = tb_ceil(x);    }    t = tb_mclock() - t;    tb_printf("[float]: ceil(%f): %ld, %lld ms/n", (x), r, t);}

static tb_void_t tb_float_test_div(tb_float_t a, tb_float_t b){    __tb_volatile__ tb_long_t       n = 10000000;    __tb_volatile__ tb_float_t      r = 0;    tb_hong_t t = tb_mclock();    while (n--)    {        r = a / b;    }    t = tb_mclock() - t;    tb_printf("[float]: div(%f, %f): %f, %lld ms/n", (a), (b), (r), t);}

static tb_bool_t tb_demo_sock_recv_func(tb_aice_t const* aice){    // check    tb_assert_and_check_return_val(aice && aice->code == TB_AICE_CODE_RECV, tb_false);    // the context    tb_demo_context_t* context = (tb_demo_context_t*)aice->priv;    tb_assert_and_check_return_val(context, tb_false);    // ok?    if (aice->state == TB_STATE_OK)    {        // trace        tb_trace_d("recv[%p]: real: %lu, size: %lu", aice->aico, aice->u.recv.real, aice->u.recv.size);        // post writ to file        if (!tb_aico_writ(context->file, context->size, aice->u.recv.data, aice->u.recv.real, tb_demo_file_writ_func, context)) return tb_false;        // save size        context->size += aice->u.recv.real;        // compute speed        context->peak += aice->u.recv.real;        if (!context->time)         {            context->time = tb_mclock();            context->base = tb_mclock();            context->sped = context->peak;        }        else if (tb_mclock() > context->time + 1000)        {            context->sped = context->peak;            context->peak = 0;            context->time = tb_mclock();            // trace            tb_trace_i("recv[%p]: size: %llu, sped: %lu KB/s", aice->aico, context->size, context->sped / 1000);        }    }    // closed or failed?    else    {        // trace        tb_trace_i("recv[%p]: state: %s", aice->aico, tb_state_cstr(aice->state));        // exit context        tb_demo_context_exit(context);    }    // ok    return tb_true;}

/* ////////////////////////////////////////////////////////////////////////////////////// * test */static tb_void_t tb_dns_test_done(tb_char_t const* name){    // time    tb_hong_t time = tb_mclock();    // done    tb_ipaddr_t addr;    if (tb_dns_looker_done(name, &addr))    {        time = tb_mclock() - time;        tb_trace_i("[demo]: %s => %{ipaddr}, %lld ms", name, &addr, time);    }    else tb_trace_i("[demo]: %s failed", name);}

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;}

static tb_void_t tb_demo_test_cstr_h(tb_size_t index){    // the count    tb_size_t count = 1000000;    // save func    g_func_indx = index;    g_func_prev = tb_item_func_str(tb_true);    // the func    tb_item_func_t func = g_func_prev;     func.hash = tb_demo_test_hash_func;    // init filter    tb_bloom_filter_ref_t filter = tb_bloom_filter_init(TB_BLOOM_FILTER_PROBABILITY_0_001, 1, count, func);    if (filter)    {        // clear random        tb_random_clear(tb_random_generator());        // done        tb_size_t i = 0;        tb_size_t r = 0;        tb_char_t s[256] = {0};        tb_hong_t t = tb_mclock();        for (i = 0; i < count; i++)        {            // the value            tb_long_t value = tb_random();            // format it            tb_snprintf(s, sizeof(s) - 1, "%ld", value);            // set value to filter            if (!tb_bloom_filter_set(filter, s))            {                // repeat++                r++;            }        }        t = tb_mclock() - t;        // trace        tb_trace_i("cstr: index: %lu, repeat: %lu, time: %lld ms", index, r, t);        // exit filter        tb_bloom_filter_exit(filter);    }}

/* ////////////////////////////////////////////////////////////////////////////////////// * test */ static tb_void_t tb_random_test(tb_long_t b, tb_long_t e){    // init     __tb_volatile__ tb_size_t   i = 0;    __tb_volatile__ tb_sint32_t n = 1000000;    __tb_volatile__ tb_long_t   rand = 0;    // done    tb_hong_t t = tb_mclock();    for (i = 0; i < n; i++) rand += tb_random_range(b, e);    t = tb_mclock() - t;    // trace    tb_trace_i("time: %lld, average: %d, range: %ld - %ld", t, (rand + (n >> 1)) / n, b, e);}

static tb_void_t tb_random_test_float(tb_float_t b, tb_float_t e){    // init     __tb_volatile__ tb_size_t   i = 0;    __tb_volatile__ tb_size_t   n = 1000000;    __tb_volatile__ tb_float_t  rand = 0;    // done    tb_hong_t t = tb_mclock();    for (i = 0; i < n; i++) rand += tb_random_rangef(b, e);    t = tb_mclock() - t;    // trace    tb_trace_i("time: %lld, average: %f, range: %f - %f", t, rand / n, b, e);}

/* ////////////////////////////////////////////////////////////////////////////////////// * main */tb_int_t tb_demo_asio_dns_main(tb_int_t argc, tb_char_t** argv){    // check    tb_assert_and_check_return_val(argv[1], 0);    // done    tb_aicp_ref_t       aicp = tb_null;    tb_aicp_dns_ref_t   dns = tb_null;    do    {        // init aicp        aicp = tb_aicp_init(2);        tb_assert_and_check_break(aicp);        // init dns        dns = tb_aicp_dns_init(aicp);        tb_assert_and_check_break(dns);        // sort server         tb_dns_server_sort();        // init time        tb_hong_t time = tb_mclock();        // trace        tb_trace_i("dns: %s: ..", argv[1]);        // done dns        tb_aicp_dns_done(dns, argv[1], -1, tb_demo_sock_dns_done_func, tb_null);        // loop aicp        tb_aicp_loop(aicp);        // exit time        time = tb_mclock() - time;        // trace        tb_trace_i("dns: %s: time: %lld ms", argv[1], time);    } while (0);    // trace    tb_trace_i("end");    // exit aicp    if (aicp) tb_aicp_exit(aicp);    return 0;}

static tb_int_t tb_demo_thread_local_test(tb_cpointer_t priv){    // self    tb_size_t self = tb_thread_self();        // trace    tb_trace_i("thread[%lx]: init", self);    // init the thread local, only once    static tb_thread_local_t s_local = TB_THREAD_LOCAL_INIT;    if (!tb_thread_local_init(&s_local, tb_demo_thread_local_free)) return -1;    // init start time    tb_hong_t time = tb_mclock();    // done    __tb_volatile__ tb_size_t count = 10000000;    while (count--)    {        // attempt to get local variable        tb_size_t local;        if (!(local = (tb_size_t)tb_thread_local_get(&s_local)))        {            // init local variable            if (tb_thread_local_set(&s_local, (tb_cpointer_t)self))                local = self;        }        // check        if (local != self)        {            // trace            tb_trace_i("thread[%lx]: invalid value: %lx", self, local);        }    }    // compile the interval time    time = tb_mclock() - time;    // trace    tb_trace_i("thread[%lx]: exit: %lld ms", self, time);    // ok    return 0;}

static tb_void_t tb_demo_test_uint32_h(tb_size_t index){    // the count    tb_size_t count = 1000000;    // save func    g_func_indx = index;    g_func_prev = tb_item_func_uint32();    // the func    tb_item_func_t func = g_func_prev;     func.hash = tb_demo_test_hash_func;    // init filter    tb_bloom_filter_ref_t filter = tb_bloom_filter_init(TB_BLOOM_FILTER_PROBABILITY_0_001, 1, count, func);    if (filter)    {        // clear random        tb_random_clear(tb_random_generator());        // done        tb_size_t i = 0;        tb_size_t r = 0;        tb_hong_t t = tb_mclock();        for (i = 0; i < count; i++)        {            // the value            tb_long_t value = tb_random_range(tb_random_generator(), 0, TB_MAXU32);            // set value to filter            if (!tb_bloom_filter_set(filter, (tb_cpointer_t)value))            {                // repeat++                r++;            }        }        t = tb_mclock() - t;        // trace        tb_trace_i("uint32: index: %lu, repeat: %lu, time: %lld ms", index, r, t);        // exit filter        tb_bloom_filter_exit(filter);    }}