uv_err_t uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { unsigned int numcpus; uv_cpu_info_t* ci; *cpu_infos = NULL; *count = 0; numcpus = sysconf(_SC_NPROCESSORS_ONLN); assert(numcpus != (unsigned int) -1); assert(numcpus != 0); ci = calloc(numcpus, sizeof(*ci)); if (ci == NULL) return uv__new_sys_error(ENOMEM); read_models(numcpus, ci); read_times(numcpus, ci); /* read_models() on x86 also reads the CPU speed from /proc/cpuinfo */ if (ci[0].speed == 0) read_speeds(numcpus, ci); *cpu_infos = ci; *count = numcpus; return uv_ok_; }
uv_err_t uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { unsigned int numcpus; uv_cpu_info_t* ci; *cpu_infos = NULL; *count = 0; numcpus = sysconf(_SC_NPROCESSORS_ONLN); assert(numcpus != (unsigned int)-1); assert(numcpus != 0); ci = calloc(numcpus, sizeof(*ci)); if (ci == NULL) return uv__new_sys_error(ENOMEM); if (read_models(numcpus, ci)) { SAVE_ERRNO(uv_free_cpu_info(ci, numcpus)); return uv__new_sys_error(errno); } if (read_times(numcpus, ci)) { SAVE_ERRNO(uv_free_cpu_info(ci, numcpus)); return uv__new_sys_error(errno); } /* read_models() on x86 also reads the CPU speed from /proc/cpuinfo. * We don't check for errors here. Worst case, the field is left zero. */ if (ci[0].speed == 0) read_speeds(numcpus, ci); *cpu_infos = ci; *count = numcpus; return uv_ok_; }
int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { unsigned int numcpus; uv_cpu_info_t* ci; int err; FILE* statfile_fp; *cpu_infos = NULL; *count = 0; statfile_fp = uv__open_file("/proc/stat"); if (statfile_fp == NULL) return UV__ERR(errno); err = uv__cpu_num(statfile_fp, &numcpus); if (err < 0) goto out; err = UV_ENOMEM; ci = uv__calloc(numcpus, sizeof(*ci)); if (ci == NULL) goto out; err = read_models(numcpus, ci); if (err == 0) err = read_times(statfile_fp, numcpus, ci); if (err) { uv_free_cpu_info(ci, numcpus); goto out; } /* read_models() on x86 also reads the CPU speed from /proc/cpuinfo. * We don't check for errors here. Worst case, the field is left zero. */ if (ci[0].speed == 0) read_speeds(numcpus, ci); *cpu_infos = ci; *count = numcpus; err = 0; out: if (fclose(statfile_fp)) if (errno != EINTR && errno != EINPROGRESS) abort(); return err; }
file_load_status quake3_bsp_map::load(istream& stream) { if (!stream.good()) { m_last_error = "The stream was invalid"; return FILE_NOT_FOUND; } if (!load_and_check_header(stream)) { m_last_error = "Map contains an invalid header string"; return FILE_LOAD_FAILED; } read_lumps(stream); read_entities(stream); read_vertices(stream); read_faces(stream); read_face_indices(stream); read_textures(stream); read_lightmaps(stream); read_bsp_nodes(stream); read_bsp_leaves(stream); read_bsp_leaf_faces(stream); read_bsp_leaf_brushes(stream); read_models(stream); read_planes(stream); read_brushes(stream); read_brushsides(stream); read_effects(stream); read_lightvols(stream); read_visibility_data(stream); do_post_load(); print_statistics(); return FILE_LOAD_SUCCESS; }
int uv_cpu_info(uv_cpu_info_t** cpu_infos, int* count) { unsigned int numcpus; uv_cpu_info_t* ci; int err; *cpu_infos = NULL; *count = 0; numcpus = sysconf(_SC_NPROCESSORS_ONLN); assert(numcpus != (unsigned int) -1); assert(numcpus != 0); ci = uv__calloc(numcpus, sizeof(*ci)); if (ci == NULL) return -ENOMEM; err = read_models(numcpus, ci); if (err == 0) err = read_times(numcpus, ci); if (err) { uv_free_cpu_info(ci, numcpus); return err; } /* read_models() on x86 also reads the CPU speed from /proc/cpuinfo. * We don't check for errors here. Worst case, the field is left zero. */ if (ci[0].speed == 0) read_speeds(numcpus, ci); *cpu_infos = ci; *count = numcpus; return 0; }
int main(int argc, char **argv) { char *topo_file = NULL; char *model_list_file = NULL; char *feat_file = NULL; char *sil_word = "sil_2"; char *align_file = NULL; int feat_dim = 0; int arg_idx = 1; while (arg_idx < argc) { if (!strcmp(argv[arg_idx], "--topo")) { if (arg_idx + 1 >= argc) { print_usage("Missing argument."); return 2; } topo_file = argv[arg_idx + 1]; arg_idx += 2; } else if (!strcmp(argv[arg_idx], "--model-list")) { if (arg_idx + 1 >= argc) { print_usage("Missing argument."); return 2; } model_list_file = argv[arg_idx + 1]; arg_idx += 2; } else if (!strcmp(argv[arg_idx], "--feat")) { if (arg_idx + 1 >= argc) { print_usage("Missing argument."); return 2; } feat_file = argv[arg_idx + 1]; arg_idx += 2; } else if (!strcmp(argv[arg_idx], "--dim")) { if (arg_idx + 1 >= argc) { print_usage("Missing argument."); return 2; } feat_dim = atoi(argv[arg_idx + 1]); arg_idx += 2; } else if (!strcmp(argv[arg_idx], "--sil-word")) { if (arg_idx + 1 >= argc) { print_usage("Missing argument."); return 2; } sil_word = argv[arg_idx + 1]; arg_idx += 2; } else if (!strcmp(argv[arg_idx], "--align-file")) { if (arg_idx + 1 > argc) { print_usage("Missing argument."); return 2; } align_file = argv[arg_idx + 1]; arg_idx += 2; } else { print_usage("Invalid argument."); return 3; } } if (!topo_file || !model_list_file || !feat_file || !feat_dim) { print_usage("Missing argument."); return 4; } fprintf(stderr, "Using silent word %s ... \n", sil_word); // reads in models HMM **hmm_set = NULL; FILE *fmodel_list = fopen(model_list_file, "r"); int hmm_size = read_models(fmodel_list, &hmm_set); fclose(fmodel_list); fprintf(stderr, "Loaded %d models ... \n", hmm_size); // generate transition matrix float **trans_matrix = NULL; HMMStateMap *state_mapping = NULL; int total_states = 0; int nodes_num = 0; total_states = topo_gen_transmat((void **)hmm_set, hmm_size, topo_file, &trans_matrix, &state_mapping, &nodes_num, 0.0); fprintf(stderr, "Loaded topology for HMM.\n"); // prepare for decoding TransMatrix trans_mat; FeatureStruct feat_struct; FeatureSet *decode_fs = featset_init(feat_dim, 16); trans_mat.trans_matrix = trans_matrix; trans_mat.state_hmm_map = state_mapping; trans_mat.total_states = total_states; trans_mat.dummy_states = nodes_num; // read features for decoding featset_read_file(feat_file, decode_fs); feat_struct.feat = decode_fs->feat[0]; feat_struct.feat_size = decode_fs->feat_sizes[0]; feat_struct.feat_dim = decode_fs->feat_dim; int *align = (int *) malloc(sizeof(int) * decode_fs->feat_sizes[0]); hmm_decode_viterbi(hmm_set, hmm_size, &trans_mat, &feat_struct, align); int curr_hmm_id = 0; int prev_hmm_id = -1; for (int t = 0; t < feat_struct.feat_size; t++) { // fprintf(stderr, "%d ", align[t]); curr_hmm_id = state_mapping[align[t]].hmm_id; // fprintf(stderr, "%d ", curr_hmm_id); if (curr_hmm_id != prev_hmm_id) { if (curr_hmm_id >= 0 && strcmp(hmm_set[curr_hmm_id]->lex, sil_word)) { printf("%s ", hmm_set[curr_hmm_id]->lex); } } prev_hmm_id = curr_hmm_id; } printf("\n"); if (align_file != NULL) { fprintf(stderr, "Writing alignment ... "); FILE *fp = fopen(align_file, "wb"); align_write(align, decode_fs->feat_sizes[0], total_states, state_mapping, fp); fclose(fp); fprintf(stderr, "done\n"); } return 0; }
int main(int argc, char **argv) { char *model_list = NULL; // "all_models.list"; char *database_file = NULL; // "train.db"; // char *database_file = "train_10.db"; // char *database_file = "train_1.db"; HMM **hmm_set = NULL; int max_iter = 20; float tolerance = 0.00001; char *result_dir = NULL; // "train_result"; char filename_buf[512]; int feat_dim = 13; int i = 1; int init_feat_capacity = 64; while (i < argc) { if (!strcmp(argv[i], "--model-list")) { if (i + 1 >= argc) { print_usage("Missing argument."); return 2; } model_list = argv[i + 1]; i += 2; } else if (!strcmp(argv[i], "--db")) { if (i + 1 >= argc) { print_usage("Missing argument."); return 2; } database_file = argv[i + 1]; i += 2; } else if (!strcmp(argv[i], "--result-dir")) { if (i + 1 >= argc) { print_usage("Missing argument."); return 2; } result_dir = argv[i + 1]; i += 2; } else if (!strcmp(argv[i], "--max-iter")) { if (i + 1 >= argc) { print_usage("Missing argument."); return 2; } max_iter = atoi(argv[i + 1]); i += 2; } else if (!strcmp(argv[i], "--feat-dim")) { if (i + 1 >= argc) { print_usage("Missing argument."); return 2; } feat_dim = atoi(argv[i + 1]); i += 2; } else if (!strcmp(argv[i], "--init-capacity")) { if (i + 1 >= argc) { print_usage("Missing argument."); return 2; } init_feat_capacity = atoi(argv[i + 1]); i += 2; } else { fprintf(stderr, "Invalid argument: %s\n", argv[i]); print_usage(NULL); return 3; } } if (database_file == NULL || max_iter < 1 || result_dir == NULL || feat_dim < 1 || model_list == NULL) { print_usage("Missing argument."); return 4; } FILE *fmodel_list = fopen(model_list, "r"); int hmm_size = read_models(fmodel_list, &hmm_set); fclose(fmodel_list); Database *train_db = read_database(database_file); // void hmm_train_continuous(HMM **hmm_set, int hmm_size, Database *db, int feat_dim, int max_iter, float tolerance) hmm_train_continuous(hmm_set, hmm_size, train_db, feat_dim, max_iter, tolerance, init_feat_capacity); for (int h = 0; h < hmm_size; h++) { sprintf(filename_buf, "%s/%s.hmm", result_dir, hmm_set[h]->lex); fprintf(stderr, "Writing model for %s\n", filename_buf); hmm_write(hmm_set[h], filename_buf); } return 0; }