Cpu.cpp

Go to the documentation of this file.

// ======================================================================
// \title Os/Darwin/Cpu.cpp
// \brief Darwin implementation for Os::Cpu
// ======================================================================
#include <mach/mach_error.h>
#include <mach/mach_host.h>
#include <mach/mach_init.h>
#include <mach/mach_types.h>
#include <mach/message.h>
#include <mach/vm_map.h>
#include <Fw/Types/Assert.hpp>
#include <Os/Darwin/Cpu.hpp>

namespace Os {
namespace Darwin {
namespace Cpu {

kern_return_t cpu_data_helper(processor_cpu_load_info_t& cpu_load_info,
                              FwSizeType& cpu_count,
                              mach_msg_type_number_t& processor_msg_count) {
    static_assert(std::numeric_limits<FwSizeType>::max() >= std::numeric_limits<natural_t>::max(),
                  "FwSizeType cannot hold natural_t values");
    natural_t cpu_count_natural = 0;
    kern_return_t stat =
        host_processor_info(mach_host_self(), PROCESSOR_CPU_LOAD_INFO, &cpu_count_natural,
                            reinterpret_cast<processor_info_array_t*>(&cpu_load_info), &processor_msg_count);
    cpu_count = cpu_count_natural;
    return stat;
}

void cpu_data_release(processor_cpu_load_info_t cpu_load_info, mach_msg_type_number_t processor_msg_count) {
    (void)vm_deallocate(mach_task_self(), reinterpret_cast<vm_address_t>(cpu_load_info),
                        processor_msg_count * sizeof(integer_t));
}

kern_return_t cpu_by_index(FwSizeType cpu_index, FwSizeType& used, FwSizeType& total) {
    processor_cpu_load_info_t cpu_load_info;
    FwSizeType cpu_count = 0;
    mach_msg_type_number_t processor_msg_count = 0;
    kern_return_t status = cpu_data_helper(cpu_load_info, cpu_count, processor_msg_count);

    // Failure for CPU index
    if (cpu_count <= cpu_index) {
        if (KERN_SUCCESS == status) {
            cpu_data_release(cpu_load_info, processor_msg_count);
        }
        status = KERN_FAILURE;
    } else if (KERN_SUCCESS == status) {
        processor_cpu_load_info per_cpu_info = cpu_load_info[cpu_index];

        // Total the ticks across the different states: idle, system, user, etc...
        total = 0;
        for (FwSizeType i = 0; i < CPU_STATE_MAX; i++) {
            total += per_cpu_info.cpu_ticks[i];
        }
        used = total - per_cpu_info.cpu_ticks[CPU_STATE_IDLE];
        cpu_data_release(cpu_load_info, processor_msg_count);
    }
    return status;
}

CpuInterface::Status DarwinCpu::_getCount(FwSizeType& cpu_count) {
    processor_cpu_load_info_t cpu_load_info;
    mach_msg_type_number_t processor_msg_count = 0;
    if (KERN_SUCCESS == cpu_data_helper(cpu_load_info, cpu_count, processor_msg_count)) {
        cpu_data_release(cpu_load_info, processor_msg_count);
        return Status::OP_OK;
    }
    cpu_count = 0;
    return Status::ERROR;
}

CpuInterface::Status DarwinCpu::_getTicks(Os::Cpu::Ticks& ticks, FwSizeType cpu_index) {
    kern_return_t status = cpu_by_index(cpu_index, ticks.used, ticks.total);
    if (KERN_SUCCESS == status) {
        return Status::OP_OK;
    }
    ticks.total = 1;
    ticks.used = 1;
    return Status::ERROR;
}

CpuHandle* DarwinCpu::getHandle() {
    return &this->m_handle;
}

}  // namespace Cpu
}  // namespace Darwin
}  // namespace Os