使用powerapi进行开发 ​

下载源码（可选） ​

源码下载：https://gitee.com/openeuler/powerapi

源码中部分接口还处于实验阶段，并未发布，代码中使用 RELEASE_MODE 对接口是否正式发布进行了隔离。

当前已发布接口参考源码库中的 API 文档。

安装软件包 ​

使用以下命令安装 powerapi-devel 软件包，使用提供的接口进行开发。

yum install powerapi-devel

基本流程 ​

查询类接口调用只需要注册，设置类接口调用前除了注册还需要请求控制权。按业务场景分，业务流程如下：
离散型感知类业务场景：设置日志回调 -> 注册 -> 查询接口调用 -> 注销
配置类业务场景：设置日志回调 -> 注册 -> 请求控制权 -> 配置接口调用 -> 释放控制权 -> 注销

powerapi接口 ​

通用接口 ​

设置日志回调函数 ​

接口定义：PWR_API int PWR_SetLogCallback(void(LogCallback)(int level, const char *fmt, va_list vl))
接口描述：设置日志打印回调，设置后，powerapi库将回调LogCallBack函数打印日志。如不设置，默认打印到控制台。该接口可在注册前调用。

参数描述：

返回值：

设置服务端信息 ​

接口定义：PWR_API int PWR_SetServerInfo(const char* socketPath)
接口描述：该接口用于设置unix domain socket通信服务端地址信息。
参数描述：

返回值：

注：
服务端sock文件默认路径为/etc/sysconfig/pwrapis/pwrserver.sock，若在pwrapis配置文件中修改默认路径，则需要保证目录权限为755，而文件权限为722。 修改路径后需要在注册前通过该接口来告知so修改后的路径，否则连接将失败。

注册 ​

接口定义：PWR_API int PWR_Register(void)
接口描述：用于注册到powerapi service。
参数描述：无参数
返回值：

注销 ​

接口定义：PWR_API int PWR_UnRegister(void)
接口描述：用于从服务端注销。
参数描述：无参数
返回值：

请求接管能效控制权 ​

接口定义：PWR_API int PWR_RequestControlAuth(void)
接口描述：该接口用于请求对系统能效控制权进行接管。上层应用接管后，系统不会自动进行能效调控，否则会自动进行能效调控。
参数描述：无参数
返回值：

放弃能效控制权 ​

接口定义：PWR_API int PWR_ReleaseControlAuth(void)
接口描述：该接口用于释放对系统能效的控制权。
参数描述：无参数
返回值：

设置PowerAPI客户端的socket文件路径 ​

接口定义：int PWR_SetClientSockPath(const char* socketPath)

接口描述：该接口用于设置PowerAPI客户端的socket文件路径。 客户端sock文件默认路径为程序当前用户所在home目录(如/home/user/pwrclient.sock)。

参数描述：

返回值：

注意：

1. 该接口必须在注册前调用才能让新设置的socket文件路径生效。
2. 调用该接口设置的路径必须是存在并且当前用户有读写权限的路径。

设置数据采集任务的回调函数 ​

接口定义：int PWR_SetMetaDataCallback(void(MetaDataCallback)(const PWR_COM_CallbackData *callbackData))

接口描述：Powerapi目前支持部分功耗相关数据采集，此接口用户可设置回调函数，在回调函数中处理这些数据。

参数描述：

返回值：

注意：

1. 该接口必须在启动采集任务前进行设置，否则不处理数据。
2. 回调函数中应该尽量轻量化，不宜做过多逻辑处理，尤其是比较费时的逻辑处理。

创建数据采集任务 ​

接口定义：int PWR_CreateDcTask(const PWR_COM_BasicDcTaskInfo *basicDcTaskInfo)

接口描述：该接口用于创建周期性数据采集任务，目前暂时只支持两种类型的数据采集：CPU使用率和CPU性能数据。

参数描述：

返回值：

注意：

1. 创建的采集任务是以数据类型为单位，多次创建同一数据类型的采集任务，内部是只有一个这个数据类型的采集任务。

删除数据采集任务 ​

接口定义：int PWR_DeleteDcTask(PWR_COM_COL_DATATYPE dataType)

接口描述：该接口根据数据类型删除数据采集任务。

参数描述：

返回值：

设置事件回调函数 ​

接口定义：int PWR_SetEventCallback(void(EventCallback)(const PWR_COM_EventInfo* eventInfo))

接口描述：PowerAPI内部定义了一些事件，用户可以设置回调函数，在回调函数中处理这些事件。目前支持认证失败和控制权被抢占两个事件。

参数描述：

返回值：

注意：

1. 回调函数的实现应轻量化，不宜做过多逻辑处理，尤其是比较费时的逻辑处理，否则可能导致由于数据拥塞而丢失数据。

CPU ​

获取CPU信息 ​

接口定义：PWR_API int PWR_CPU_GetInfo(PWR_CPU_Info *cpuInfo)
接口描述：获取CPU信息，包含CPU基础信息，NUMA信息。
参数描述：

返回值：

获取CPU使用率 ​

接口定义：int PWR_CPU_GetUsage(PWR_CPU_Usage *usage, uint32_t bufferSize)

接口描述：获取CPU全部核心的平均使用率，以及每个核心分别的使用率。

参数描述：

返回值：

注意：

1. 该接口会阻塞当前线程500ms，如果是比较频繁的获取CPU使用率，建议采用任务方式，参见创建数据采集任务

获取CPU性能数据 ​

接口定义：int PWR_CPU_GetPerfData(PWR_CPU_PerfData *perfData)

接口描述：获取CPU性能数据，实时获取CPU单指令平均LLC miss数和IPC(统计时长100ms)

参数描述：

返回值：

注意：

1. 该接口会阻塞当前线程100ms，如果是比较频繁的获取CPU性能数据，建议采用任务方式，参见创建数据采集任务

获取CPU Frequency能力 ​

接口定义：PWR_API int PWR_CPU_GetFreqAbility(PWR_CPU_FreqAbility *freqAbi, uint32_t bufferSize)
参数描述：查询可用的CPUFreq调频域信息，可用governor和当前使用的CPUFreq驱动。

返回值：

获取CPU Frequency governor ​

接口定义：PWR_API int PWR_CPU_GetFreqGovernor(char gov[], uint32_t size)
接口描述：获取系统当前使用的CPUFreq调频器（默认获取第一个调频域的governor）。
参数描述：

返回值：

设置CPU Frequency governor ​

接口定义：PWR_API int PWR_CPU_SetFreqGovernor(const char gov[])
接口描述：设置系统当前使用的CPUFreq调频器（设置时将所有调频域设置为输入的governor）。
参数描述：

返回值：

获取CPU Frequency governor所有属性值 ​

接口定义：PWR_API int PWR_CPU_GetFreqGovAttrs(PWR_CPU_FreqGovAttrs *govAttrs)
接口描述：获取当前所使用的CPUFreq调频器的所有属性信息。
参数描述：

返回值：

获取CPU Frequency governor属性 ​

接口定义：PWR_API int PWR_CPU_GetFreqGovAttr(PWR_CPU_FreqGovAttr *govAttr)
接口描述：获取当前使用的CPUFreq属性（系统将获取第一个调频域（policy0）当前使用的governor对应的属性）。
参数描述：

返回值：

设置CPU Frequency governor属性 ​

接口定义：PWR_API int PWR_CPU_SetFreqGovAttr(const PWR_CPU_FreqGovAttr *govAttr)
接口描述：设置当前使用的CPUFreq属性（系统将设置第一个调频域（policy0）当前使用的governor对应的属性）。
参数描述：

返回值：

注：
不同的governor所支持的属性有所差异，governor所支持的属性一般在以下路径：/sys/devices/system/cpu/cpufreq/{gov}/，其中{gov}为当前使用的调频器名称。

获取CPU工作频率范围 ​

接口定义：PWR_API int PWR_CPU_GetFreqRange(PWR_CPU_FreqRange *freqRange)
接口描述：获取CPU工作频率范围（默认获取第一个调频域的工作频率范围）。
参数描述：

返回值：

设置CPU工作频率范围 ​

接口定义：PWR_API int PWR_CPU_SetFreqRange(const PWR_CPU_FreqRange *freqRange)
接口描述：设置CPU工作频率范围（把所有调频域设置成指定的频率范围）。
参数描述：

返回值：

获取CPU当前频率 ​

接口定义：PWR_API int PWR_CPU_GetFreq(PWR_CPU_CurFreq curFreq[], uint32_t *num, int spec)
接口描述：获取调频域的当前频率。
参数描述：

返回值：

设置CPU当前频率 ​

接口定义：PWR_API int PWR_CPU_SetFreq(const PWR_CPU_CurFreq curFreq[], uint32_t num)
接口描述：设置调频域的工作频率（CPUFreq governor为userspace时才可设置）。
参数描述：

返回值：

获取CPU休眠能力和状态信息 ​

接口定义：PWR_API int PWR_CPU_GetIdleInfo(PWR_CPU_IdleInfo *idleInfo)
接口描述：获取CPUIdele能力和状态信息。
参数描述：

返回值：

获取CPU休眠governor ​

接口定义：PWR_API int PWR_CPU_GetIdleGovernor(char idleGov[], uint32_t size)
接口描述：获取CPU休眠模式。
参数描述：

返回值：

设置CPU休眠governor ​

接口定义：PWR_API int PWR_CPU_SetIdleGovernor(const char idleGov[])
接口描述：设置CPU休眠模式。
参数描述：

返回值：

获取CPU&DMA时延 ​

接口定义：PWR_API int PWR_CPU_DmaGetLatency(int *latency)
接口描述：获取CPU&DMA可忍受时延。
参数描述：

返回值：

设置CPU&DMA时延 ​

接口定义：PWR_API int PWR_CPU_DmaSetLatency(int latency)
接口描述：设置CPU&DMA可忍受时延。
参数描述：

返回值：

注：
不同的C-state，被唤醒所需时间不同，睡得越深，唤醒时延越大，因而系统在进入C-state前会判断CPU&DMA latency，如果对应C-state的时延大于CPU&DMA latency，则不会进入C-state。
各个C-state唤醒时延参考（单位：us）

系统类接口 ​

设置整系统电源状态 ​

接口定义：int PWR_SYS_SetPowerState(int powerState)

接口描述：

1. 该接口用于进行系统级休眠

参数描述：

返回值：

注意：

1. 系统进入休眠后，如果重新激活系统，需要通过其他方式(如通过BMC物理端口的IPMI接口)远程激活系统。

获取系统当前功耗信息 ​

接口定义：int PWR_SYS_GetRtPowerInfo(PWR_SYS_PowerInfo * powerInfo)

接口描述：

1. 查询系统实时能耗信息，包括整机当前功率、CPU当前功率、内存当前功率

参数描述：

返回值：

注意：

1. ARM平台暂时无法获取到CPU功耗信息和内存功耗信息

HBM类接口 ​

查询HBM能力和运行模式 ​

接口定义：int PWR_HBM_GetSysState(PWR_HBM_SYS_STATE *state) 接口描述：

1. 查询当前设备是否支持HBM，并查询HBM当前运行模式为flat模式、还是cache模式或混合模式。
2. HBM一般支持flat和cache两种运行模式，前者OS会将HBM作为cpuless的numa节点使用，而后者当做LLC使用。两种方式都支持进行上下电操作。

参数描述：

返回值：

关闭/启动所有HBM ​

接口定义：int PWR_HBM_SetAllPwrState(int state)

接口描述：

1. 关闭/启动所有HBM，包括cache模式和flat模式。

参数描述：

返回值：

proc进程相关接口 ​

根据关键字查找任务 ​

接口定义: int PWR_PROC_QueryProcs(const char *keywords, pid_t procs[], uint32_t *num)

接口描述：

1. 根据关键字查找进程，并返回进程列表。

参数描述：

返回值：

查询瓦特调度开关状态 ​

瓦特调度说明：

1. 瓦特调度是一种为节省功耗，在内核采取的调度机制。在负载比较低时，系统会将任务集中在部分numa节点，为其他节点创造进入低功耗的条件。随着负载变化，系统会动态地扩缩用于完成任务的numa节点。
2. 约束：当前瓦特调度在x86内核中是默认是不开启，如果需要开启需要QOS_SCHED_DYNAMIC_AFFINITY和QOS_SCHED_SMART_GRID这两个配置，重新编译内核并替换内核。

接口定义: int PWR_PROC_GetWattState(int *state)

接口描述：

1. 查询瓦特调度开关状态。

参数描述：

返回值：

设置瓦特调度开关 ​

接口定义: int PWR_PROC_SetWattState(int state)

接口描述：

1. 设置瓦特调度开关状态。

参数描述：

返回值：

设置瓦特调度第一调度域 ​

接口定义: int PWR_PROC_SetWattFirstDomain(int cpuId)

接口描述：

1. 该接口用于指定瓦特调度使用的第一个调度域。
2. 默认情况下，在启动瓦特调度时，系统选择最空闲的NUMA node作为第一个调度域(level0)，后续在扩缩算力时，根据NUMA node的亲和性进行扩缩(例如：对于2颗CPU芯片，4个NUMA node的设备，node2为第一个调度域时，优先会扩展同一个socket下的node3, 然后是另一个socket下的node1和node0)。
3. 有些情况下，由于IRQ亲和性等原因，为了保证性能，需要指定第一个调度域为IRQ所在的NUMA node。

参数描述：

返回值：

注意：

1. 设置的CPU是在线和可调度状态。
2. 瓦特调度需要是关闭状态。

获取瓦特调度属性 ​

瓦特调度属性说明：

接口定义: int PWR_PROC_GetWattAttrs(PWR_PROC_WattAttrs *wattAttrs)

接口描述：

1. 获取瓦特调度属性。

参数描述：

返回值：

设置瓦特调度属性 ​

接口定义: int PWR_PROC_SetWattAttrs(PWR_PROC_WattAttrs *wattAttrs)

接口描述：

1. 设置瓦特调度属性。

参数描述：

返回值：

查询当前瓦特调度任务列表 ​

接口定义：int PWR_PROC_GetWattProcs(pid_t wattProcs[], uint32_t *num)

接口描述：

1. 查询有哪些任务已经加入到瓦特调度中

参数描述：

返回值：

添加瓦特调度任务 ​

接口定义：int PWR_PROC_AddWattProcs(const pid_t wattProcs[], uint32_t num)

接口描述：

1. 添加任务到瓦特调度中

参数描述：

返回值：

注意：

1. 子进程会继承父进程/线程的瓦特调度属性。即如果父进程/线程已经在瓦特调度组，则生成的子进程/线程也会在该调度组

删除瓦特调度任务 ​

接口定义：int PWR_PROC_DelWattProcs(const pid_t wattProcs[], uint32_t num)

接口描述：

1. 删除任务从瓦特调度中

参数描述：

返回值：

查询smart_grid开关状态 ​

smart_grid说明：

1. smart_grid智能网格是一种为节省功耗，在瓦特调度的基础上内核的一种CPU资源划分和标识方法。smart_grid可以将算力资源和任务划分不同等级，高等级任务用高算力来运行，低等级任务用低算力运行。
2. 为使smart_grid生效，需要先开启smart_grid，并批量设置任务的smart_grid_level。
3. openEuler 22.03 SP2及以上版本才支持smart_grid功能。
4. 开启smart_grid前，开启瓦特调度才能让smart_grid功能生效。

接口定义：int PWR_PROC_GetSmartGridState(int *state)

接口描述：

1. 查询smart_grid开关状态

参数描述：

返回值：

设置smart_grid开关状态 ​

接口定义：int PWR_PROC_SetSmartGridState(int state)

接口描述：

1. 设置smart_grid开关状态

参数描述：

返回值：

根据smart_grid_level查询任务列表 ​

smart_grid等级说明：

1. 当前只支持两个等级：0-高等级， 1-低等级。
2. 处于高等级的任务将会被调度到性能域，而处于低等级的任务将会被调度到能效域。
3. 子进程/线程会继承父进程/线程的smart_grid等级属性。即如果父进程/线程的等级是0，则生成的子进程/线程等级也是0。
4. 已经存在的子进程/线程不会随父进程/线程改变smart_grid等级属性。

接口定义：int PWR_PROC_GetSmartGridProcs(PWR_PROC_SMART_GRID_LEVEL level, PWR_PROC_SmartGridProcs *sgProcs)

接口描述：

1. 根据smart_grid_level查询任务列表

参数描述：

返回值：

批量设置任务的smart_grid_level ​

接口定义：int PWR_PROC_SetSmartGridLevel(const PWR_PROC_SmartGridProcs *sgProcs)

接口描述：

1. 批量设置任务的smart_grid等级

参数描述：

返回值：

获取smart_grid的调频器 ​

smart_gird调频器可设置参数：

接口定义：int PWR_PROC_GetSmartGridGov(PWR_PROC_SmartGridGov *sgGov)

接口描述：

1. 获取smart_grid的调频器

参数描述：

返回值：

设置smart_grid的调频器 ​

接口定义：int PWR_PROC_SetSmartGridGov(const PWR_PROC_SmartGridGov *sgGov)

接口描述：

1. 设置smart_grid的调频器

参数描述：

返回值：

获取服务的状态 ​

接口定义：int PWR_PROC_GetServiceState(PWR_PROC_ServiceStatus *sStatus)

接口描述：

1. 获取服务的状态

参数描述：

返回值：

设置服务的状态 ​

接口定义：int PWR_PROC_SetServiceState(const PWR_PROC_ServiceState *sState)

接口描述：

1. 设置服务的状态

参数描述：

返回值：

注意：

1. 目前暂时只支持设置mpctool和eagle两个服务的状态。
2. 设置服务状态前，需要安装mpctool或者eagle两个软件，分别对应python3-eagle-mpctool和eagle软件包。
3. mpctool目前只支持以下arm服务器机型，x86下无法使用
   1. Taishan200 2280(VD)
   2. Taishan200 Pro 2280
   3. Taishan200 2280v2

使用用例 ​

将以下代码保存为powerapi_test.c。

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include <pwrapic/powerapi.h>

#define MAIN_LOOP_INTERVAL 5
#define TEST_FREQ 2400
#define TEST_CORE_NUM 128
#define AVG_LEN_PER_CORE 5
#define TEST_CPU_DMA_LATENCY 2000
#define TASK_INTERVAL 1000
#define TASK_RUN_TIME 10
#define TEST_FREQ_RANGE_MIN 500
#define TEST_FREQ_RANGE_MAX 2500

static int g_run = 1;

static void PrintResult(char *function, int ret)
{
    int length = 24;
    printf("[TEST ]    ");
    printf("%-*s", length, function);
    printf(":");
    if (ret == PWR_SUCCESS) {
        printf("SUCCESS ret: %d\n", ret);
    } else {
        printf("ERROR   ret: %d\n", ret);
    }
}

enum {
    DEBUG = 0,
    INFO,
    WARNING,
    ERROR
};

static const char *GetLevelName(int level)
{
    static char debug[] = "DEBUG";
    static char info[] = "INFO";
    static char warning[] = "WARNING";
    static char error[] = "ERROR";
    switch (level) {
        case DEBUG:
            return debug;
        case INFO:
            return info;
        case WARNING:
            return warning;
        case ERROR:
            return error;
        default:
            return info;
    }
}

void LogCallback(int level, const char *fmt, va_list vl)
{
    char logLine[4096] = {0};
    char message[4000] = {0};
    int length = 5;

    if (vsnprintf(message, sizeof(message) - 1, fmt, vl) < 0) {
        return;
    }

    printf("[");
    printf("%-*s", length, GetLevelName(level));
    printf("]    %s\n", message);
}

static void SignalHandler(int none)
{
    g_run = 0;
}

static void SetupSignal(void)
{
    // regist signal handler
    (void)signal(SIGINT, SignalHandler);
    (void)signal(SIGUSR1, SignalHandler);
    (void)signal(SIGUSR2, SignalHandler);
    (void)signal(SIGTERM, SignalHandler);
    (void)signal(SIGKILL, SignalHandler);
}
/************************** COMMON ************************/
static void TEST_PWR_SetLogCallback(void)
{
    int ret = -1;
    ret = PWR_SetLogCallback(LogCallback);
    PrintResult("PWR_SetLogCallback", ret);
}

static void TEST_PWR_SetServerInfo(void)
{
    int ret = -1;
    char str[] = "/etc/sysconfig/pwrapis/pwrserver.sock";
    ret = PWR_SetServerInfo(str);
    PrintResult("PWR_SetServerInfo", ret);
}

static void TEST_PWR_Register(void)
{
    while (PWR_Register() != PWR_SUCCESS) {
        sleep(MAIN_LOOP_INTERVAL);
        PrintResult("PWR_Register", PWR_ERR_COMMON);
        continue;
    }
    PrintResult("PWR_Register", PWR_SUCCESS);
}

static void TEST_PWR_RequestControlAuth(void)
{
    int ret = -1;
    ret = PWR_RequestControlAuth();
    PrintResult("PWR_RequestControlAuth", ret);
}
/************************** COMMON END************************/

/***************************** CPU ***************************/
static void TEST_PWR_CPU_GetInfo(void)
{
    int ret = -1;
    PWR_CPU_Info *info = (PWR_CPU_Info *)malloc(sizeof(PWR_CPU_Info));
    if (!info) {
        return;
    }
    bzero(info, sizeof(PWR_CPU_Info));
    ret = PWR_CPU_GetInfo(info);
    PrintResult("PWR_CPU_GetInfo", ret);
    printf("    arch: %s\n    coreNum: %d\n    maxFreq: %f\n    minFreq: %f\n    "
        "modelName: %s\n    numaNum: %d\n    threadsPerCore: %d\n", info->arch,
        info->coreNum, info->maxFreq, info->minFreq, info->modelName, info->numaNum,
        info->threadsPerCore);
    for (int i = 0; i < info->numaNum; i++) {
        printf("    numa node[%d]  cpuList: %s\n", info->numa[i].nodeNo, info->numa[i].cpuList);
    }
    free(info);
}

static void TEST_PWR_CPU_GetFreq(void)
{
    int ret = -1;
    int num = 0;
    int spec = 0;
    int i = 0;

    /**
     * Test 1: spec = 0, get all policy freq.
     * Set the num to the number of CPU cores
     * (it is possible that one kernel corresponds to one policy)
     */
    num = TEST_CORE_NUM;
    spec = 0;
    PWR_CPU_CurFreq cpuCurFreq1[num];
    bzero(cpuCurFreq1, num * sizeof(PWR_CPU_CurFreq));
    ret = PWR_CPU_GetFreq(cpuCurFreq1, &num, spec);
    PrintResult("1  PWR_CPU_GetFreq", ret);
    for (i = 0; i < num; i++) {
        printf("    policy[%d]: %lf\n", cpuCurFreq1[i].policyId, cpuCurFreq1[i].curFreq);
    }

    /**
     * Test 2: spec = 0 num = 2. get the previous 2 policies freq
     */
    ret = -1;
    // 2: previous 2 policies
    num = 2;
    spec = 0;
    PWR_CPU_CurFreq cpuCurFreq2[num];
    bzero(cpuCurFreq2, num * sizeof(PWR_CPU_CurFreq));
    ret = PWR_CPU_GetFreq(cpuCurFreq2, &num, spec);
    PrintResult("2  PWR_CPU_GetFreq", ret);
    for (i = 0; i < num; i++) {
        printf("    policy[%d]: %lf\n", cpuCurFreq2[i].policyId, cpuCurFreq2[i].curFreq);
    }

    /**
     * Test 3: spec = 1, get the two target policy freq
     */
    ret = -1;
    // 2: previous 2 policies
    num = 2;
    spec = 1;
    PWR_CPU_CurFreq cpuCurFreq3[num];
    bzero(cpuCurFreq3, num * sizeof(PWR_CPU_CurFreq));
    cpuCurFreq3[0].policyId = 0;
    // 32 : the Id of the second policy.
    cpuCurFreq3[1].policyId = 32;
    ret = PWR_CPU_GetFreq(cpuCurFreq3, &num, spec);
    PrintResult("3  PWR_CPU_GetFreq", ret);
    for (i = 0; i < num; i++) {
        printf("    policy[%d]: %lf\n", cpuCurFreq3[i].policyId, cpuCurFreq3[i].curFreq);
    }
}

static void TEST_PWR_CPU_SetFreq(void)
{
    int ret = -1;
    int num = 1;
    PWR_CPU_CurFreq cpuCurFreq[num];
    bzero(cpuCurFreq, num * sizeof(PWR_CPU_CurFreq));
    cpuCurFreq[0].policyId = 0;
    cpuCurFreq[0].curFreq = TEST_FREQ;
    ret = PWR_CPU_SetFreq(cpuCurFreq, num);
    PrintResult("PWR_CPU_SetFreq", ret);

    int spec = 1;
    bzero(cpuCurFreq, num * sizeof(PWR_CPU_CurFreq));
    cpuCurFreq[0].policyId = 0;
    ret = PWR_CPU_GetFreq(cpuCurFreq, &num, spec);
    printf("    current policy[%d]: %lf\n", cpuCurFreq[0].policyId, cpuCurFreq[0].curFreq);
}
/*************************** CPU END *************************/

int main(int argc, const char *args[])
{
    /********** Common **********/
    TEST_PWR_SetServerInfo();
    TEST_PWR_SetLogCallback();
    TEST_PWR_Register();
    TEST_PWR_RequestControlAuth();

    /************ CPU ***********/
    TEST_PWR_CPU_GetInfo();
    TEST_PWR_CPU_GetFreq();
    TEST_PWR_CPU_SetFreq();

    PWR_ReleaseControlAuth();
    PWR_UnRegister();
    return 0;
}

使用gcc编译：

gcc powerapi_test.c -o powerapi_test -lpwrapi

运行查看结果：

./powerapi_test