在iOS性能监控中，如何获取判断我们的App性能如何，哪方面性能发生变化，需要获取各维度数据进行版本间的对比。

获取CPU使用率

kern_return_t kr;
thread_array_t         thread_list;
mach_msg_type_number_t thread_count;

thread_info_data_t     thinfo;
mach_msg_type_number_t thread_info_count;

thread_basic_info_t basic_info_th;
uint32_t stat_thread = 0; // Mach threads

// get threads in the task
kr = task_threads(mach_task_self(), &thread_list, &thread_count);
if (kr != KERN_SUCCESS) {
    return -1;
}
if (thread_count > 0)
    stat_thread += thread_count;

long tot_sec = 0;
long tot_usec = 0;
float tot_cpu = 0;

for (int i = 0; i < (int)thread_count; i++)
{
    thread_info_count = THREAD_INFO_MAX;
    kr = thread_info(thread_list[i], THREAD_BASIC_INFO,
                     (thread_info_t)thinfo, &thread_info_count);
    if (kr != KERN_SUCCESS) {
        return -1;
    }
    
    basic_info_th = (thread_basic_info_t)thinfo;
    
    if (!(basic_info_th->flags & TH_FLAGS_IDLE)) {
        tot_sec = tot_sec + basic_info_th->user_time.seconds + basic_info_th->system_time.seconds;
        tot_usec = tot_usec + basic_info_th->user_time.microseconds + basic_info_th->system_time.microseconds;
        tot_cpu = tot_cpu + basic_info_th->cpu_usage / (float)TH_USAGE_SCALE * 100.0;
    }
    
} // for each thread

kr = vm_deallocate(mach_task_self(), (vm_offset_t)thread_list, thread_count * sizeof(thread_t));
assert(kr == KERN_SUCCESS);

return tot_cpu;

获取GPU使用时长

#define PROC_PIDCOALITIONINFO           20
#define PROC_PIDCOALITIONINFO_SIZE      (sizeof(struct proc_pidcoalitioninfo))

#define COALITION_TYPE_RESOURCE  (0)
#define COALITION_TYPE_MAX       (1)
#define COALITION_NUM_TYPES      (COALITION_TYPE_MAX + 1)
#define COALITION_NUM_THREAD_QOS_TYPES   7

struct proc_pidcoalitioninfo {
    uint64_t coalition_id[COALITION_NUM_TYPES];
    uint64_t reserved1;
    uint64_t reserved2;
    uint64_t reserved3;
};

struct coalition_resource_usage {
    uint64_t tasks_started;
    uint64_t tasks_exited;
    uint64_t time_nonempty;
    uint64_t cpu_time;
    uint64_t interrupt_wakeups;
    uint64_t platform_idle_wakeups;
    uint64_t bytesread;
    uint64_t byteswritten;
    uint64_t gpu_time;
    uint64_t cpu_time_billed_to_me;
    uint64_t cpu_time_billed_to_others;
    uint64_t energy;
    uint64_t logical_immediate_writes;
    uint64_t logical_deferred_writes;
    uint64_t logical_invalidated_writes;
    uint64_t logical_metadata_writes;
    uint64_t logical_immediate_writes_to_external;
    uint64_t logical_deferred_writes_to_external;
    uint64_t logical_invalidated_writes_to_external;
    uint64_t logical_metadata_writes_to_external;
    uint64_t energy_billed_to_me;
    uint64_t energy_billed_to_others;
    uint64_t cpu_ptime;
    uint64_t cpu_time_eqos_len;     /* Stores the number of thread QoS types */
    uint64_t cpu_time_eqos[COALITION_NUM_THREAD_QOS_TYPES];
    uint64_t cpu_instructions;
    uint64_t cpu_cycles;
    uint64_t fs_metadata_writes;
    uint64_t pm_writes;
};

extern int proc_pidinfo(int pid, int flavor, uint64_t arg, void *buffer, int buffersize);
extern int coalition_info_resource_usage(uint64_t cid, struct coalition_resource_usage *cru, size_t sz);

- (uint64_t)getGpuTime {
    int pid = NSProcessInfo.processInfo.processIdentifier;
    struct proc_pidcoalitioninfo idinfo = {0};
    int r = proc_pidinfo(pid, PROC_PIDCOALITIONINFO, 0, &idinfo, sizeof(idinfo));
    if (r > 0) {
        uint64_t resid = idinfo.coalition_id[COALITION_TYPE_RESOURCE];
        struct coalition_resource_usage coalusage = {0};
        r = coalition_info_resource_usage(resid, &coalusage,
            sizeof(coalusage));
        NSLog(@"gpu_time:%llu", coalusage.gpu_time); // GPU使用时长
        return coalusage.gpu_time;
    }
    return 0;
}

获取蜂窝网络和WiFi网络用量

这里获取的是整个手机网络用量，包括了其他App的用量，如果测试，请先杀死其他应用会更准一点。

struct ifaddrs *ifa_list = 0, *ifa;
if (getifaddrs(&ifa_list) == -1) {
    return 0;
}
uint32_t iBytes = 0;
uint32_t oBytes = 0;
uint32_t ipackets = 0;
uint32_t opackets = 0;
for (ifa = ifa_list; ifa; ifa = ifa->ifa_next) {
    if (AF_LINK != ifa->ifa_addr->sa_family) {
        continue;
    }
    if (!(ifa->ifa_flags & IFF_UP) && !(ifa->ifa_flags & IFF_RUNNING)) {
        continue;
    }
    if (ifa->ifa_data == 0) {
        continue;
    }
     //蜂窝网络
    if (!strcmp(ifa->ifa_name, "pdp_ip0"))
    {
        struct if_data *if_data = (struct if_data *)ifa->ifa_data;
        ipackets += if_data->ifi_ipackets; // 蜂窝网络下行数据包数量
        opackets += if_data->ifi_opackets; // 蜂窝网络上行数据包数量
        iBytes += if_data->ifi_ibytes; // 蜂窝网络下行流量
        oBytes += if_data->ifi_obytes; // 蜂窝网络上行流量
    }
    // WiFi
    else if (strncmp(ifa->ifa_name, "lo", 2)) {
        struct if_data *if_data = (struct if_data *)ifa->ifa_data;
        ipackets += if_data->ifi_ipackets; // WiFi网络下行数据包数量
        opackets += if_data->ifi_opackets; // WiFi网络上行数据包数量
        iBytes += if_data->ifi_ibytes; // WiFi网络下行流量
        oBytes += if_data->ifi_obytes; // WiFi网络上行流量
    }
}

freeifaddrs(ifa_list);

磁盘的读写用量

extern int proc_pid_rusage(int pid, int flavor, rusage_info_t *buffer);

int pid = NSProcessInfo.processInfo.processIdentifier;
rusage_info_current rusage;
if (proc_pid_rusage(pid, RUSAGE_INFO_CURRENT, (void **)&rusage) == 0)
{
    NSLog(@"磁盘读入:%llu，磁盘写入:%llu",
          rusage.ri_diskio_bytesread,
          rusage.ri_diskio_byteswritten);
}