C++ (Cpp) iclock64 Examples

Example #1

File: enet_client.cpp Project: libinzhangyuan/enet_bench_test

void EnetClient::HandleRecvedMsg(const msg_ptr_t& msg)
{
    if (msg->size() != test_msg_size_)
    {
        std::cout << "recv wrong msg size: " << msg->size() << std::endl << *msg << std::endl;
        loop_running_ = false;
        return;
    }

    // good test msg.
    //

    // log
    //
    uint64_t send_time = get_time_from_msg(*msg);
    uint64_t cur_time = iclock64();

    static uint64_t static_last_refresh_time = 0;
    static size_t static_recved_bytes = 0;
    static_recved_bytes += msg->size();

    {
        static size_t static_good_recv_count = 0;

        static_good_recv_count++;

        uint64_t interval = cur_time - send_time;
        recv_package_interval_.push_back(interval);
        recv_package_interval10_.push_back(interval);
        std::cout << interval << "\t";

        if (static_good_recv_count % 10 == 0)
        {
            int average10 = 0;
            for (int x : recv_package_interval10_)
                average10 += x;
            average10 = (average10 / 10);

            int average_total = 0;
            for (int x: recv_package_interval_)
                average_total += x;
            average_total = average_total / recv_package_interval_.size();

            std::cout << "max: " << *std::max_element( recv_package_interval10_.begin(), recv_package_interval10_.end() ) <<
                "  average 10: " << average10 <<
                "  average total: " << average_total;
            if (cur_time - static_last_refresh_time > 10 * 1000)
            {
                std::cout << " " << static_cast<double>(static_recved_bytes * 10 / (cur_time - static_last_refresh_time)) / 10 << "KB/s(in)";
                static_last_refresh_time = cur_time;
                static_recved_bytes = 0;
            }
            std::cout << std::endl;
            std::cout << get_cur_time_str() << " ";
            recv_package_interval10_.clear();
        }
        std::cout.flush();
    }
}

Example #2

File: enet_client.cpp Project: libinzhangyuan/enet_bench_test

msg_ptr_t make_test_str(size_t test_str_size)
{
    std::ostringstream ostr;
    ostr << iclock64();
    std::string msg_str = ostr.str();
    msg_str += test_str(CLOCK_INTERVAL_STR, test_str_size - msg_str.size());
    return msg_ptr_t(new std::string(msg_str));
}

Example #3

File: kcp_client.cpp Project: libinzhangyuan/asio_kcp

std::string make_test_str(size_t test_str_size)
{
    std::ostringstream ostr;
    ostr << CLOCK_START_STR << iclock64();
    std::string msg_str = ostr.str();
    msg_str += test_str(CLOCK_INTERVAL_STR, test_str_size - msg_str.size());
    return msg_str;
}

Example #4

File: enet_client.cpp Project: libinzhangyuan/enet_bench_test

void EnetClient::Run(void)
{
    Connect();

    loop_running_ = true;
    while (loop_running_)
    {
        // send test msg every 50 milliseconds
        {
            static uint64_t last_send_test_msg_time = 0;

            const uint64_t cur_time = iclock64();
            if ( (cur_time - last_send_test_msg_time) > SEND_TEST_MSG_INTERVAL )
            {
                last_send_test_msg_time = ( cur_time  - (cur_time % SEND_TEST_MSG_INTERVAL) );
                SendTestMsg();
            }
        }

        RunLoopOnce();
    }
}

Example #5

File: connection_manager.cpp Project: BlackHoleJet/asio_kcp

static inline uint32_t iclock()
{
    return (uint32_t)(iclock64() & 0xfffffffful);
}

Example #6

File: kcp_client.cpp Project: libinzhangyuan/asio_kcp

static inline IUINT32 iclock()
{
    return (IUINT32)(iclock64() & 0xfffffffful);
}

Example #7

File: kcp_client_util.cpp Project: BlackHoleJet/asio_kcp

uint32_t iclock()
{
    return (uint32_t)(iclock64() & 0xfffffffful);
}