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;
}
