static void uart_init(size_t baud_rate) { GPIO_REG(GPIO_IOF_SEL) &= ~IOF0_UART0_MASK; GPIO_REG(GPIO_IOF_EN) |= IOF0_UART0_MASK; UART0_REG(UART_REG_DIV) = get_cpu_freq() / baud_rate - 1; UART0_REG(UART_REG_TXCTRL) |= UART_TXEN; }
int main(int argc, char **argv) { pid_t pid[32], p; int i; uint64_t start, end, usec; printf("Create directories...\n"); start = read_tsc(); create_dir(PATH_PREFIX); for (i = 0; i < nr_threads; i++) { p = fork(); if (p == 0) { worker((void *) (long) i); exit(0); } pid[i] = p; } for (i = 0; i < nr_threads; i++) { waitpid(pid[i], NULL, 0); } end = read_tsc(); usec = (end - start) * 1000000 / get_cpu_freq(); printf("usec: %ld\t\n", usec); printf("Cleanup directories...\n"); /* system("rm -rf /tmp/_dirs"); */ return 0; }
void get_sys_info(sys_info_t *sys_info) { int freq = get_cpu_freq(); memset(sys_info, 0, sizeof(sys_info_t)); sys_info->freq_systembus = freq; sys_info->freq_ddrbus = freq; sys_info->freq_processor[0] = freq; }
/* 功能:获取系统运行状态 * 参数: pskb网络数据指针 * 返回值:无 * */ void get_machine_stat(char *pskb) { struct CheckMachineStat *pBoardStat = (struct CheckMachineStat*)pskb; /* 填充消息结构*/ pBoardStat->CheckMachineStatMsg.MsgId = ARM_PC_CHECK_MACHINE_STAT_RSP; pBoardStat->CheckMachineStatMsg.MsgLen = sizeof(*pBoardStat) - sizeof(pBoardStat->CheckMachineStatMsg); pBoardStat->MachineStat = 1; pBoardStat->TempData = get_ds18b20_temperature(); pBoardStat->Voltage = get_adc_voltage(); pBoardStat->CpuFreq = get_cpu_freq(); pBoardStat->FreeMemSpace = get_freemem_space(); pBoardStat->FreeDiskSpace = get_freedisk_space(); }
void _init() { #ifndef NO_INIT use_default_clocks(); use_pll(0, 0, 1, 31, 1); uart_init(115200); rt_kprintf("core freq at %ld Hz\n", get_cpu_freq()); write_csr(mtvec, &trap_entry); if (read_csr(misa) & (1 << ('F' - 'A'))) { // if F extension is present write_csr(mstatus, MSTATUS_FS); // allow FPU instructions without trapping write_csr(fcsr, 0); // initialize rounding mode, undefined at reset } #endif }
int main(int argc, const char *argv[]) { (void)argc; (void)argv; Display *dpy; char msg[100]; dpy = XOpenDisplay(NULL); struct net_bandwidth speed; struct tm tm; time_t t; do { speed = get_network_speed(); t = time(NULL); tm = *localtime(&t); sprintf(msg, "freq: %" PRIi32 "MHz " "temp: %" PRIi32 "C " "cpu: %" PRIi32 "%% " "ram: %" PRIi64 "MB " "U: %" PRIu32 "kB D: %" PRIu32 "kB " "V: %" PRIi64 "%% " "%02d.%02d. %02d:%02d\n", get_cpu_freq(), get_cpu_temp(), get_cpu_usage(), get_ram_usage(), speed.up, speed.down, get_alsa_volume(), tm.tm_mday, tm.tm_mon + 1, tm.tm_hour, tm.tm_min); XStoreName(dpy, DefaultRootWindow(dpy), msg); XSync(dpy, False); } while(!sleep(DELAY)); XCloseDisplay(dpy); printf("Something happened!"); return 0; }
int print_processor_info() { //puts("CPU info:"); printf("CPU ID: %d\n",get_cpuid()); int platform_cores = get_cpucnt(); printf("Number of cores: %d\n",platform_cores); //printf("Operating frequency: %d MHz\n",(get_cpu_freq()) >> 20); printf("Operating frequency: %d MHz\n",(get_cpu_freq())/1000000); int i = 0; int cores = 1; for(i = 1; i < get_cpucnt(); i++){ if(boot_info->slave[i].status != STATUS_NULL){ cores++; } } printf("Number of cores booted: %d\n",cores); int noc_cores = print_noc_info(); ABORT_IF_FAIL(platform_cores!=noc_cores,"An incorrect noc schedule is used"); ABORT_IF_FAIL(platform_cores!=cores,"Not all cores booted"); return cores; }
/* 功能:获取系统运行状态 * 参数: MCM请求消息 * 返回值:无 * */ void get_machine_info_req(s8 *pskb) { struct stru_machine_info_req *prMachineInfoReq = (struct stru_machine_info_req *)pskb; struct stru_machine_info_rsp rMachineInfoRsp; memset(&rMachineInfoRsp, 0, sizeof(rMachineInfoRsp)); /* 构造反馈消息*/ rMachineInfoRsp.struMsgHeader.u16MsgType = O_MAINMCM_MACHINE_INFO_QUERY_RSP; rMachineInfoRsp.struMsgHeader.u16MsgLength = sizeof(rMachineInfoRsp) - sizeof(rMachineInfoRsp.struMsgHeader); rMachineInfoRsp.struMsgHeader.u8TransType = prMachineInfoReq->struMsgHeader.u8TransType; get_ds18b20_temperature(&rMachineInfoRsp.f32Temp); get_adc_voltage(&rMachineInfoRsp.f32Vol); get_cpu_freq(&rMachineInfoRsp.f32CpuFreq); get_freemem_space(&rMachineInfoRsp.u32FreeMem); get_freedisk_space(&rMachineInfoRsp.u32FreeDisk); /* 反馈消息到MCM*/ send_rsp_message(&rMachineInfoRsp, sizeof(rMachineInfoRsp), prMachineInfoReq->struMsgHeader.u8TransType); }
// Sets the clock rate of the controller SDErr spi_set_clockrate(const uint32_t rate) { uint32_t patmos_rate = get_cpu_freq(); if (patmos_rate % rate != 0) { /* printf("Invalid clock rate (%ld)! Must be divisor of CPU rate (%ld)\n", rate, patmos_rate); */ return SD_CLK_DIVISOR; } if (rate > patmos_rate / 2) { /* printf("Invalid clock rate (%ld)! Must be smaller than or equal to" "half the CPU rate (%ld)\n", rate, patmos_rate); */ return SD_CLK_HIGH; } uint32_t clkdiv = (patmos_rate / rate) / 2; while(*sd_en_ptr != 0); *sd_clkdiv_ptr = clkdiv; return SD_SUCCESS; }
/* * Display the CPUs present on this board. */ void display_cpus(Board_node *board) { Prom_node *cpu; /* * display the CPUs' operating frequency, cache size, impl. field * and mask revision. */ for (cpu = dev_find_type(board->nodes, "cpu"); cpu != NULL; cpu = dev_next_type(cpu, "cpu")) { int freq; /* CPU clock frequency */ int ecache_size; /* External cache size */ int *mid; int *impl; int *mask, decoded_mask; mid = (int *)get_prop_val(find_prop(cpu, "upa-portid")); if (mid == NULL) { mid = (int *)get_prop_val(find_prop(cpu, "portid")); } freq = (get_cpu_freq(cpu) + 500000) / 1000000; ecache_size = get_ecache_size(cpu); impl = (int *)get_prop_val(find_prop(cpu, "implementation#")); mask = (int *)get_prop_val(find_prop(cpu, "mask#")); /* Do not display a failed CPU node */ if ((freq != 0) && (node_failed(cpu) == 0)) { /* Board number */ display_boardnum(board->board_num); /* CPU MID */ log_printf(" %2d ", *mid, 0); /* Module number */ display_mid(*mid); /* Running frequency */ log_printf(" %3d ", freq, 0); /* Ecache size */ if (ecache_size == 0) log_printf(" %3s ", "N/A", 0); else log_printf(" %4.1f ", (float)ecache_size / (float)(1<<20), 0); /* Implementation */ if (impl == NULL) { log_printf("%6s ", "N/A", 0); } else { switch (*impl) { case SPITFIRE_IMPL: log_printf("%-6s ", "US-I", 0); break; case BLACKBIRD_IMPL: log_printf("%-6s ", "US-II", 0); break; case CHEETAH_IMPL: log_printf("%-6s ", "US-III", 0); break; case CHEETAH_PLUS_IMPL: log_printf("%-7s ", "US-III+", 0); break; case JAGUAR_IMPL: log_printf("%-6s ", "US-IV", 0); break; default: log_printf("%-6x ", *impl, 0); break; } } /* CPU Mask */ if (mask == NULL) { log_printf(" %3s", "N/A", 0); } else { if ((impl) && IS_CHEETAH(*impl)) decoded_mask = REMAP_CHEETAH_MASK(*mask); else decoded_mask = *mask; log_printf(" %d.%d", (decoded_mask >> 4) & 0xf, decoded_mask & 0xf, 0); } log_printf("\n", 0); } }
void display_cpus(Board_node *board) { Prom_node *cpu; uint_t freq; int ecache_size; int *l3_shares; int *mid; int *impl; int *mask; int *coreid; char fru_prev = 'X'; /* Valid frus are 'A','B' */ int mid_prev; int ecache_size_prev = 0; char fru_name; /* * display the CPUs' operating frequency, cache size, impl. field * and mask revision. */ for (cpu = dev_find_type(board->nodes, "cpu"); cpu != NULL; cpu = dev_next_type(cpu, "cpu")) { mid = (int *)get_prop_val(find_prop(cpu, "portid")); if (mid == NULL) mid = (int *)get_prop_val(find_prop(cpu, "cpuid")); freq = HZ_TO_MHZ(get_cpu_freq(cpu)); ecache_size = get_ecache_size(cpu); impl = (int *)get_prop_val(find_prop(cpu, "implementation#")); mask = (int *)get_prop_val(find_prop(cpu, "mask#")); l3_shares = (int *)get_prop_val(find_prop(cpu, "l3-cache-sharing")); /* Do not display a failed CPU node */ if ((impl == NULL) || (freq == 0) || (node_failed(cpu))) continue; fru_name = CHERRYSTONE_GETSLOT_LABEL(*mid); if (CPU_IMPL_IS_CMP(*impl)) { coreid = (int *)get_prop_val(find_prop(cpu, "reg")); if (coreid == NULL) { continue; } if ((fru_prev == 'X') || ((fru_prev != 'X') && (fru_name != fru_prev))) { fru_prev = fru_name; mid_prev = *mid; ecache_size_prev = ecache_size; continue; } else { /* * Some CMP chips have a split E$, * so the size for both cores is added * together to get the total size for * the chip. * * Still, other CMP chips have E$ (L3) * which is logically shared, so the * total size is equal to the core size. */ if ((l3_shares == NULL) || ((l3_shares != NULL) && MULTIPLE_BITS_SET(*l3_shares))) { ecache_size += ecache_size_prev; } ecache_size_prev = 0; fru_prev = 'X'; } } log_printf(" %c", fru_name); /* CPU Module ID */ if (CPU_IMPL_IS_CMP(*impl)) { log_printf("%3d,%3d ", mid_prev, *mid, 0); } else log_printf(" %2d ", *mid); /* Running frequency */ log_printf("%4u", freq); if (ecache_size == 0) log_printf(" N/A "); else log_printf(" %4.1f ", (float)ecache_size / (float)(1<<20)); /* Implementation */ if (impl == NULL) { log_printf(dgettext(TEXT_DOMAIN, " N/A ")); } else { if (IS_CHEETAH(*impl)) log_printf(dgettext(TEXT_DOMAIN, "US-III ")); else if (IS_CHEETAH_PLUS(*impl)) log_printf(dgettext(TEXT_DOMAIN, "US-III+ ")); else if (IS_JAGUAR(*impl)) log_printf(dgettext(TEXT_DOMAIN, "US-IV ")); else if (IS_PANTHER(*impl)) log_printf(dgettext(TEXT_DOMAIN, "US-IV+ ")); else log_printf("%-6x ", *impl); } /* CPU Mask */ if (mask == NULL) { log_printf(dgettext(TEXT_DOMAIN, " N/A\n")); } else { log_printf(dgettext(TEXT_DOMAIN, " %d.%d\n"), (*mask >> 4) & 0xf, *mask & 0xf); } } }
static long px_tp_d_ioctl( struct file *fp, unsigned int cmd, unsigned long arg) #endif { switch (cmd) { case PX_TP_CMD_START_MODULE_TRACKING: return start_module_tracking(); case PX_TP_CMD_START_SAMPLING: return start_sampling((bool *)arg); case PX_TP_CMD_STOP_PROFILING: return stop_profiling(); case PX_TP_CMD_PAUSE_PROFILING: return pause_profiling(); case PX_TP_CMD_RESUME_PROFILING: return resume_profiling(); case PX_TP_CMD_ALLOC_EVENT_BUFFER: return allocate_event_buffer((unsigned int *)arg); case PX_TP_CMD_ALLOC_MODULE_BUFFER: return allocate_module_buffer((unsigned int *)arg); case PX_TP_CMD_FREE_EVENT_BUFFER: return free_event_buffer(); case PX_TP_CMD_FREE_MODULE_BUFFER: return free_module_buffer(); case PX_TP_CMD_SET_AUTO_LAUNCH_APP_PID: return set_auto_launch_app_pid((pid_t *)arg); case PX_TP_CMD_SET_WAIT_IMAGE_LOAD_NAME: return set_wait_image_load_name((char *)arg); case PX_TP_CMD_QUERY_REQUEST: return query_request((struct query_request_data *)arg); case PX_TP_CMD_GET_CPU_ID: return get_cpu_id((unsigned long *)arg); case PX_TP_CMD_GET_TARGET_RAW_DATA_LENGTH: return get_target_raw_data_length((unsigned long *)arg); case PX_TP_CMD_GET_TARGET_INFO: return get_target_info((unsigned long *)arg); case PX_TP_CMD_GET_CPU_FREQ: return get_cpu_freq((unsigned int *)arg); case PX_TP_CMD_GET_TIMESTAMP_FREQ: return get_timestamp_frequency((unsigned long *)arg); case PX_TP_CMD_GET_TIMESTAMP: return get_time_stamp((unsigned long long *)arg); case PX_TP_CMD_ADD_MODULE_RECORD: return add_module_record((struct add_module_data *)arg); #if 0 case PX_TP_CMD_RESET_EVENT_BUFFER_FULL: return reset_event_buffer_full((bool *)arg); case PX_TP_CMD_RESET_MODULE_BUFFER_FULL: return reset_module_buffer_full((bool *)arg); #endif // case PX_TP_CMD_SET_KERNEL_FUNC_ADDR: // return set_kernel_func_addr((struct tp_kernel_func_addr *)arg); // case PX_TP_CMD_HOOK_ADDRESS: // return hook_address((struct tp_hook_address *)arg); case PX_TP_CMD_READ_EVENT_BUFFER: return read_event_buffer((struct read_buffer_data *)arg); case PX_TP_CMD_READ_MODULE_BUFFER: return read_module_buffer((struct read_buffer_data *)arg); case PX_TP_CMD_GET_POSSIBLE_CPU_NUM: return get_possible_cpu_number((unsigned int *)arg); case PX_TP_CMD_GET_ONLINE_CPU_NUM: return get_online_cpu_number((unsigned int *)arg); default: return -EINVAL; } }
void *ref1(void*){ int target_fps = 0; int target_Ug = 0; int target_Uc = 0; start_sampling = 1; int fps; int Ug; static unsigned long long Ug_bp,Ug_tp; get_gpu_time(&Ug_bp,&Ug_tp); int Uc; static unsigned long long Uc_bp,Uc_tp; get_cpu_time(4,&Uc_bp,&Uc_tp); int Fc,Fg; while(true){ if(game == -1){sleep(1);start_sampling=1;continue;} Fc=get_cpu_freq(0); Fg=get_gpu_freq(); //printf("Sample%d Fc=%d,Fg=%d,Uc=%d,Ug=%d\n",start_sampling,get_cpu_freq(0),get_gpu_freq(),Uc,Ug); if(start_sampling == 1){ fps = get_fps(binder); Uc = get_cpu_util(4,&Uc_bp,&Uc_tp); Ug = get_gpu_util(&Ug_bp,&Ug_tp); printf("Sample%d Fc=%d,Fg=%d,Uc=%d,Ug=%d\n",start_sampling,Fc,Fg,Uc,Ug); if(target_fps < fps)target_fps = fps; if(target_Uc < Uc)target_Uc = Uc; if(target_Ug < Ug)target_Ug = Ug; set_cpu_freq(0,FL[3]); set_gpu_freq(GFL[4]); start_sampling=2; sleep(1);continue; }else if(start_sampling == 2){ fps = get_fps(binder); Uc = get_cpu_util(4,&Uc_bp,&Uc_tp); Ug = get_gpu_util(&Ug_bp,&Ug_tp); printf("Sample%d Fc=%d,Fg=%d,Uc=%d,Ug=%d\n",start_sampling,Fc,Fg,Uc,Ug); if(target_fps < fps)target_fps = fps; if(target_Uc < Uc)target_Uc = Uc; if(target_Ug < Ug)target_Ug = Ug; set_cpu_freq(0,FL[10]); set_gpu_freq(GFL[0]); start_sampling=3; sleep(1);continue; }else if(start_sampling == 3){ fps = get_fps(binder); Uc = get_cpu_util(4,&Uc_bp,&Uc_tp); Ug = get_gpu_util(&Ug_bp,&Ug_tp); printf("Sample%d Fc=%d,Fg=%d,Uc=%d,Ug=%d\n",start_sampling,Fc,Fg,Uc,Ug); if(target_fps < fps)target_fps = fps; if(target_Uc < Uc)target_Uc = Uc; if(target_Ug < Ug)target_Ug = Ug; set_cpu_freq(0,FL[10]); set_gpu_freq(GFL[4]); start_sampling=4; sleep(1);continue; }else if(start_sampling == 4){ printf("Sample%d Fc=%d,Fg=%d\n",start_sampling,get_cpu_freq(0),get_gpu_freq()); printf("Q : %d , Ug : %d , Uc : %d\n",target_fps,target_Ug,target_Uc); start_sampling=5; } fps = get_fps(binder); int fps_dev = (target_fps - fps)*100/target_fps; static int FL_point = freq_level-2; static int pre_FL = FL_point; static int GFL_point = gpu_freq_level-1; static int pre_GFL = GFL_point; int CPU_Sensitive = 1; int Fc_adj = 0; int Fg_adj = 0; int Ug_adj = 0; if(fps_dev > 10){ //printf("UP! %d %d %d\n",fps,target_fps,fps_dev); Uc = get_cpu_util(4,&Uc_bp,&Uc_tp); Ug = get_gpu_util(&Ug_bp,&Ug_tp); int fps_dif = (target_fps - fps); int Uc_dev = (target_Uc - Uc)*100/target_Uc; int Ug_dev = (target_Ug - Ug)*100/target_Ug; if(CPU_Sensitive){ //CPU Sensitive Fc_adj = (double)fps_dif * reciprocal(Coef_Fc2Q[game]) + FL[FL_point]; Ug_adj = Ug + (double)fps_dif * reciprocal(Coef_Ug2Q[game]); if(Ug_adj > target_Ug){ Fg_adj = (double)(Ug_adj - target_Ug) * -reciprocal(Coef_Fg2Ug[game]) + GFL[GFL_point]; } }else{ //GPU Sensitive Fg_adj = (double)fps_dif * reciprocal(Coef_Fg2Q[game]) + GFL[GFL_point]; Ug_adj = Ug + (double)fps_dif * reciprocal(Coef_Uc2Q[game]); if(Ug_adj > target_Ug){ Fc_adj = (double)(Ug_adj - target_Ug) * -reciprocal(Coef_Fc2Uc[game]) + FL[FL_point]; } } while(FL_point < freq_level && FL[FL_point] < Fc_adj)FL_point++; while(GFL_point < gpu_freq_level && GFL[GFL_point] < Fg_adj)GFL_point++; if(FL_point != pre_FL){ if(FL_point > freq_level-2){ FL_point = freq_level-2; }else if(FL_point < 2){ FL_point = 2; } pre_FL = FL_point; set_cpu_freq(0,FL[FL_point]); } if(GFL_point != pre_GFL){ if(GFL_point > gpu_freq_level-1){ GFL_point = gpu_freq_level-1; }else if(GFL_point < 0){ GFL_point = 0; } pre_GFL = GFL_point; set_gpu_freq(GFL[GFL_point]); } }else if(fps_dev <= 10){ //printf("DOWN! POWER SAVE %d %d %d\n",fps,target_fps,fps_dev); Uc = get_cpu_util(4,&Uc_bp,&Uc_tp); Ug = get_gpu_util(&Ug_bp,&Ug_tp); int Uc_dev = target_Uc - Uc; int Ug_dev = target_Ug - Ug; if(Uc_dev*100/Uc > 10) Fc_adj = (double)(Uc_dev) * reciprocal(Coef_Fc2Uc[game]) + FL[FL_point]; if(Ug_dev*100/Ug > 10) Fg_adj = (double)(Ug_dev) * reciprocal(Coef_Fg2Ug[game]) + GFL[GFL_point]; while(FL_point > 0 && FL[FL_point] > Fc_adj)FL_point--; while(GFL_point > 0 && GFL[GFL_point] > Fg_adj)GFL_point--; if(FL_point != pre_FL){ if(FL_point > freq_level-2){ FL_point = freq_level-2; }else if(FL_point < 2){ FL_point = 2; } pre_FL = FL_point; set_cpu_freq(0,FL[FL_point]); } if(GFL_point != pre_GFL){ if(GFL_point > gpu_freq_level-1){ GFL_point = gpu_freq_level-1; }else if(GFL_point < 0){ GFL_point = 0; } pre_GFL = GFL_point; set_gpu_freq(GFL[GFL_point]); } } sleep(1); } return 0; }
static long px_hotspot_d_ioctl(struct file *fp, unsigned int cmd, unsigned long arg) #endif { int ret; if ((ret = check_ioctl(fp, cmd, arg)) != 0) return ret; switch (cmd) { case PX_HS_CMD_START_MODULE_TRACKING: return start_module_tracking_hs(); case PX_HS_CMD_START_SAMPLING: return start_sampling((bool *)arg); case PX_HS_CMD_STOP_PROFILING: return stop_profiling(); case PX_HS_CMD_PAUSE_PROFILING: return pause_profiling(); case PX_HS_CMD_RESUME_PROFILING: return resume_profiling(); case PX_HS_CMD_ALLOC_SAMPLE_BUFFER: return allocate_all_sample_buffers((unsigned int *)arg); case PX_HS_CMD_ALLOC_MODULE_BUFFER: return allocate_module_buffer((unsigned int *)arg); case PX_HS_CMD_FREE_SAMPLE_BUFFER: return free_all_sample_buffers(); case PX_HS_CMD_FREE_MODULE_BUFFER: return free_module_buffer(); case PX_HS_CMD_SET_AUTO_LAUNCH_APP_PID: return set_auto_launch_app_pid((pid_t *)arg); case PX_HS_CMD_SET_WAIT_IMAGE_LOAD_NAME: return set_wait_image_load_name((char *)arg); case PX_HS_CMD_SET_TBS_SETTINGS: return set_tbs_settings((struct HSTimerSettings *)arg); case PX_HS_CMD_SET_EBS_SETTINGS: return set_ebs_settings((struct HSEventSettings *)arg); case PX_HS_CMD_SET_CALIBRATION_MODE: return set_calibration_mode((bool *)arg); case PX_HS_CMD_QUERY_REQUEST: return query_request((struct query_request_data *)arg); case PX_HS_CMD_GET_CALIBRATION_RESULT: return get_calibration_result((struct calibration_result *)arg); case PX_HS_CMD_GET_CPU_ID: return get_cpu_id((unsigned long *)arg); case PX_HS_CMD_GET_TARGET_RAW_DATA_LENGTH: return get_target_raw_data_length((unsigned long *)arg); case PX_HS_CMD_GET_TARGET_INFO: return get_target_info((unsigned long *)arg); case PX_HS_CMD_GET_CPU_FREQ: return get_cpu_freq((unsigned int *)arg); case PX_HS_CMD_GET_TIMESTAMP_FREQ: return get_timestamp_frequency((unsigned long *)arg); case PX_HS_CMD_GET_TIMESTAMP: return get_time_stamp((unsigned long long *)arg); case PX_HS_CMD_ADD_MODULE_RECORD: return add_module_record_hs((struct add_module_data *)arg); case PX_HS_CMD_READ_SAMPLE_BUFFER: return read_sample_buffer((struct read_buffer_data *)arg); case PX_HS_CMD_READ_MODULE_BUFFER: return read_module_buffer((struct read_buffer_data *)arg); case PX_HS_CMD_READ_TOTAL_SAMPLE_COUNT: return read_total_sample_count((unsigned long long *)arg); case PX_HS_CMD_GET_POSSIBLE_CPU_NUM: return get_possible_cpu_number((unsigned int *)arg); case PX_HS_CMD_GET_ONLINE_CPU_NUM: return get_online_cpu_number((unsigned int *)arg); default: return -EINVAL; } }
int main(int argc, char **argv) { int i, fd=-1; pthread_t tid[32]; uint64_t start, end, usec; #ifdef PVM struct nvmap_arg_struct a; /*PVM needs a chunk and procid*/ int chunk_id = 120; int proc_id = 20; unsigned long offset = 0; #endif for (i = 0; i < ncores; i++) { flag[i] = 0; } if (argc > 1) { nbufs = atoi(argv[1]); } #ifdef USEFILE create_file(filename, (1 + nbufs) * PAGESIZE); /*easy to change the flags if we are testing page read performance*/ fd = open(filename, O_RDWR); #endif #ifdef PVM a.fd = fd; a.offset = offset; a.chunk_id =chunk_id; a.proc_id = proc_id; /*FIXME: What is pflags and persist?*/ a.pflags = 1; a.nopersist=DISABLE_PERSIST; //pvm's nvmmap function shared_area = (char *) syscall(__NR_nv_mmap_pgoff, 0,(1 + nbufs) * PAGESIZE, PROT_READ | PROT_WRITE,MAP_FLAGS, &a); //shared_area = mmap(0, (1 + nbufs) * PAGESIZE, PROT_READ | PROT_WRITE, MAP_FLAGS, fd, 0); #else shared_area = mmap(0, (1 + nbufs) * PAGESIZE, PROT_READ | PROT_WRITE, MAP_FLAGS, fd, 0); #endif if (shared_area == MAP_FAILED) { perror("Error mmapping the file"); exit(EXIT_FAILURE); } start = read_tsc(); for (i = 0; i < ncores; i++) { pthread_create(&tid[i], NULL, worker, (void *) (long) i); } for (i = 0; i < ncores; i++) { pthread_join(tid[i], NULL); } end = read_tsc(); usec = (end - start) * 1000000 / get_cpu_freq(); printf("usec: %ld\t\n", usec); close(fd); return 0; }