cputime.hpp

Go to the documentation of this file.

//    OpenVPN -- An application to securely tunnel IP networks
//               over a single port, with support for SSL/TLS-based
//               session authentication and key exchange,
//               packet encryption, packet authentication, and
//               packet compression.
//
//    Copyright (C) 2012- OpenVPN Inc.
//
//    SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
 
#pragma once
 
#include <errno.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/resource.h>
#include <unistd.h>
 
#include <string>
 
#include <openvpn/common/file.hpp>
#include <openvpn/common/string.hpp>
#include <openvpn/common/number.hpp>
#include <openvpn/common/exception.hpp>
 
#if defined(__APPLE__)
#include <mach/mach.h>
 
static int getrusage_thread(struct rusage &rusage)
{
    int ret = -1;
    thread_basic_info_data_t info{};
    mach_msg_type_number_t info_count = THREAD_BASIC_INFO_COUNT;
    kern_return_t kern_err;
 
    kern_err = thread_info(mach_thread_self(),
                           THREAD_BASIC_INFO,
                           (thread_info_t)&info,
                           &info_count);
    if (kern_err == KERN_SUCCESS)
    {
        rusage.ru_utime.tv_sec = info.user_time.seconds;
        rusage.ru_utime.tv_usec = info.user_time.microseconds;
        rusage.ru_stime.tv_sec = info.system_time.seconds;
        rusage.ru_stime.tv_usec = info.system_time.microseconds;
        ret = 0;
    }
    else
    {
        errno = EINVAL;
    }
    return ret;
}
 
#endif
 
namespace openvpn {
inline double cpu_time(const bool thread = false)
{
    try
    {
        struct rusage usage{};
 
        int ret = 0;
#if defined(__APPLE__)
        if (thread)
            ret = getrusage_thread(usage);
        else
            ret = getrusage(RUSAGE_SELF, &usage);
#else
        ret = getrusage((thread ? RUSAGE_THREAD : RUSAGE_SELF), &usage);
#endif
        if (ret != 0)
        {
            throw Exception("getrusage() call failed: " + std::string(strerror(errno)));
        }
        double utime = static_cast<double>(usage.ru_utime.tv_sec) + (static_cast<double>(usage.ru_utime.tv_usec / 1000000));
        double stime = static_cast<double>(usage.ru_stime.tv_sec) + (static_cast<double>(usage.ru_stime.tv_usec / 1000000));
 
        return utime + stime;
    }
    catch (const std::exception &e)
    {
        // OPENVPN_LOG("cpu_time exception: " << e.what());
        return -1.0;
    }
}
 
 
} // namespace openvpn