int run_sequential( char *dataset_file, pltb_config_t *config, model_space_t *model_space )
{
FILE *out = DEBUG_PROCESS_STATISTICS_OPEN_OUTPUT;
pltb_model_stat_t stats[model_space->matrix_count];
TIME_STRUCT_INIT(timer);
fprint_eval_header(out);
pllAlignmentData *data = read_alignment_data(dataset_file);
pltb_result_t result;
for(unsigned i = 0; i < IC_MAX; i++) {
result.ic[i] = FLT_MAX;
}
while (next_model(model_space)) {
partitionList *parts = init_partitions(data, config->base_freq_kind);
pllInstance *inst = setup_instance(model_space->matrix_repr, &config->attr_model_eval, data, parts);
pltb_model_stat_t *stat = &stats[model_space->matrix_index];
stat->matrix_index = model_space->matrix_index;
TIME_START(timer);
optimize_model_parameters(inst, parts);
TIME_END(timer);
stat->time_cpu = TIME_CPU(timer);
stat->time_real = TIME_REAL(timer);
stat->likelihood = inst->likelihood;
calculate_model_ICs(stat, data, inst, model_space->free_parameter_count, config);
merge_into_result(&result, stat, model_space->matrix_index);
fprint_eval_row(out, model_space, stat);
pllPartitionsDestroy(inst, &parts);
pllDestroyInstance(inst);
}
fprint_eval_summary(out, model_space, &stats, &result);
DEBUG_PROCESS_STATISTICS_CLOSE_OUTPUT(out);
evaluate_result(model_space, &result, data, config);
pllAlignmentDataDestroy(data);
return 0;
}
void evaluate_result(model_space_t *relative_model_space, pltb_result_t *result, pllAlignmentData *data, pltb_config_t *config)
{
pllInstance *tree;
/* TODO: inplace modifications. ugly! */
make_indices_absolute(relative_model_space, &result->matrix_index);
unsigned *models = malloc(sizeof(unsigned) * (IC_MAX + config->n_extra_models));
unsigned n_models = prepare_unique_model_tasks(models, &result->matrix_index, config->extra_models, config->n_extra_models);
model_space_t model_space;
init_selection_model_space(&model_space, models, n_models);
PRINT_TREE_SEARCH_HEADER();
while (next_model(&model_space)) {
PRINT_TREE_SEARCH_PRETEXT_BEGIN(model_space.matrix_repr_short);
bool first = true;
for (unsigned i = 0; i < IC_MAX; i++) {
if (result->matrix_index[i] == models[model_space.matrix_index]) {
if (first) {
PRINT_TREE_SEARCH_PRETEXT_IC(get_IC_name_short(i));
first = false;
} else {
PRINT_TREE_SEARCH_PRETEXT_IC_SEP(get_IC_name_short(i));
}
}
}
if (first) {
PRINT_TREE_SEARCH_PRETEXT_IC("extra");
}
PRINT_TREE_SEARCH_PRETEXT_END();
partitionList *parts = init_partitions(data, config->base_freq_kind);
/* do the actual work */
tree = setup_instance(model_space.matrix_repr, &config->attr_tree_search, data, parts);
tree_search(tree, parts);
prepare_tree_string(tree, parts);
PRINT_TREE(tree->tree_string);
pllPartitionsDestroy(tree, &parts);
pllDestroyInstance(tree);
}
destroy_model_space(&model_space);
}
SOS()
{
readyq = new_dllist();
mt_init();
writeok = mt_sem_create(0);
writers = mt_sem_create(1);
readers = mt_sem_create(1);
nelem = mt_sem_create(0);
consoleWait = mt_sem_create(0);
wr_iobuf = make_io_buffer(1);
cr_iobuf = make_io_buffer(256);
crb_no_chars = 0;
crb_end = 0;
crb_begin = 0;
curpid = -1;
// pids = make_rb();
init_partitions();
DEBUG('e', "pagesize: %d\n", PageSize);
jrbTree = make_jrb(); // Step 20
init = new_pcb(); // Step 22
init->pid = get_new_pid(); // Step 22
cread_vnode = new_vnode();
cread_vnode->iobuf =cr_iobuf;
cr_iobuf->nwriters = 1;
cwrite_vnode = new_vnode();
cwrite_vnode->iobuf = wr_iobuf;
wr_iobuf->nreaders = 1;
start_timer(10);
bzero(main_memory, MemorySize);
mt_create(read_console_io, (void *)cr_iobuf);
mt_create(write_console_io, (void *)wr_iobuf);
//mt_create(read_console, NULL);
mt_create(initialize_user_process, (void *)Argv);
schedule();
}
int main( int argc, char **argv ) {
num_particles = read_int( argc, argv, "-n", 1000 );
char *savename = read_string( argc, argv, "-o", NULL );
MPI_Init( &argc, &argv );
MPI_Comm_size( MPI_COMM_WORLD, &num_procs );
MPI_Comm_rank( MPI_COMM_WORLD, &rank );
fsave = savename && rank == 0 ? fopen( savename, "w" ) : NULL;
particles = (particle_t*) malloc( num_particles * sizeof(particle_t) );
MPI_Type_contiguous( 7, MPI_DOUBLE, &PARTICLE );
MPI_Type_commit( &PARTICLE );
set_size( num_particles );
init_vars();
init_partitions();
if( rank == 0 ) {
init_particles( num_particles, particles );
}
MPI_Bcast(particles, num_particles, PARTICLE, 0, MPI_COMM_WORLD);
partition_particles();
init_grid();
double simulation_time = read_timer();
for( int step = 0; step < NSTEPS; step++ ) {
if (rank == 0) {
right_fringe();
MPI_Isend(right_sending_buffer, num_sending_right, PARTICLE, rank+1, 0, MPI_COMM_WORLD, &send_right_req);
MPI_Irecv(right_receiving_buffer, num_my_particles, PARTICLE, rank+1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_right_req);
MPI_Wait(&send_right_req, &send_right_stat);
MPI_Wait(&recv_right_req, &recv_right_stat);
MPI_Get_count(&recv_right_stat, PARTICLE, &recvd_right_count);
num_augmented_particles = num_my_particles + recvd_right_count;
memcpy(my_particles + num_my_particles, right_receiving_buffer, recvd_right_count * sizeof(particle_t));
} else if (rank == (num_procs-1)) {
left_fringe();
MPI_Isend(left_sending_buffer, num_sending_left, PARTICLE, rank-1, 0, MPI_COMM_WORLD, &send_left_req);
MPI_Irecv(left_receiving_buffer, num_my_particles, PARTICLE, rank-1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_left_req);
MPI_Wait(&send_left_req, &send_left_stat);
MPI_Wait(&recv_left_req, &recv_left_stat);
MPI_Get_count(&recv_left_stat, PARTICLE, &recvd_left_count);
num_augmented_particles = num_my_particles + recvd_left_count;
memcpy(my_particles + num_my_particles, left_receiving_buffer, recvd_left_count * sizeof(particle_t));
} else {
left_fringe();
right_fringe();
MPI_Isend(left_sending_buffer, num_sending_left, PARTICLE, rank-1, 0, MPI_COMM_WORLD, &send_left_req);
MPI_Irecv(left_receiving_buffer, num_my_particles, PARTICLE, rank-1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_left_req);
MPI_Isend(right_sending_buffer, num_sending_right, PARTICLE, rank+1, 0, MPI_COMM_WORLD, &send_right_req);
MPI_Irecv(right_receiving_buffer, num_my_particles, PARTICLE, rank+1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_right_req);
MPI_Wait(&send_left_req, &send_left_stat);
MPI_Wait(&send_right_req, &send_right_stat);
MPI_Wait(&recv_left_req, &recv_left_stat);
MPI_Wait(&recv_right_req, &recv_right_stat);
MPI_Get_count(&recv_left_stat, PARTICLE, &recvd_left_count);
MPI_Get_count(&recv_right_stat, PARTICLE, &recvd_right_count);
num_augmented_particles = num_my_particles + recvd_left_count + recvd_right_count;
memcpy(my_particles + num_my_particles, left_receiving_buffer, recvd_left_count * sizeof(particle_t));
memcpy(my_particles + num_my_particles + recvd_left_count, right_receiving_buffer, recvd_right_count * sizeof(particle_t));
}
populate_grid();
time_step();
num_sending_left = 0;
num_sending_right = 0;
int num_remaining_particles = 0;
for ( int i = 0; i < num_my_particles; i++ ) {
if (rank != 0 && my_particles[i].x <= partition_offsets[rank]) {
left_sending_buffer[num_sending_left++] = my_particles[i];
} else if (rank != (num_procs-1) && my_particles[i].x > partition_offsets[rank+1]) {
right_sending_buffer[num_sending_right++] = my_particles[i];
} else {
remaining_particles[num_remaining_particles++] = my_particles[i];
}
}
if (rank == 0) {
MPI_Isend(right_sending_buffer, num_sending_right, PARTICLE, rank+1, 0, MPI_COMM_WORLD, &send_right_req);
MPI_Irecv(right_receiving_buffer, num_my_particles, PARTICLE, rank+1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_right_req);
MPI_Wait(&send_right_req, &send_right_stat);
MPI_Wait(&recv_right_req, &recv_right_stat);
MPI_Get_count(&recv_right_stat, PARTICLE, &recvd_right_count);
num_augmented_particles = num_remaining_particles + recvd_right_count;
memcpy(my_particles, remaining_particles, num_remaining_particles * sizeof(particle_t));
memcpy(my_particles + num_remaining_particles, right_receiving_buffer, recvd_right_count * sizeof(particle_t));
num_my_particles = num_augmented_particles;
} else if (rank == (num_procs-1)) {
MPI_Isend(left_sending_buffer, num_sending_left, PARTICLE, rank-1, 0, MPI_COMM_WORLD, &send_left_req);
MPI_Irecv(left_receiving_buffer, num_my_particles, PARTICLE, rank-1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_left_req);
MPI_Wait(&send_left_req, &send_left_stat);
MPI_Wait(&recv_left_req, &recv_left_stat);
MPI_Get_count(&recv_left_stat, PARTICLE, &recvd_left_count);
num_augmented_particles = num_remaining_particles + recvd_left_count;
memcpy(my_particles, remaining_particles, num_remaining_particles * sizeof(particle_t));
memcpy(my_particles + num_remaining_particles, left_receiving_buffer, recvd_left_count * sizeof(particle_t));
num_my_particles = num_augmented_particles;
} else {
MPI_Isend(right_sending_buffer, num_sending_right, PARTICLE, rank+1, 0, MPI_COMM_WORLD, &send_right_req);
MPI_Irecv(right_receiving_buffer, num_my_particles, PARTICLE, rank+1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_right_req);
MPI_Isend(left_sending_buffer, num_sending_left, PARTICLE, rank-1, 0, MPI_COMM_WORLD, &send_left_req);
MPI_Irecv(left_receiving_buffer, num_my_particles, PARTICLE, rank-1, MPI_ANY_TAG, MPI_COMM_WORLD, &recv_left_req);
MPI_Wait(&send_right_req, &send_right_stat);
MPI_Wait(&recv_right_req, &recv_right_stat);
MPI_Wait(&send_left_req, &send_left_stat);
MPI_Wait(&recv_left_req, &recv_left_stat);
MPI_Get_count(&recv_left_stat, PARTICLE, &recvd_left_count);
MPI_Get_count(&recv_right_stat, PARTICLE, &recvd_right_count);
num_augmented_particles = num_remaining_particles + recvd_left_count + recvd_right_count;
memcpy(my_particles, remaining_particles, num_remaining_particles * sizeof(particle_t));
memcpy(my_particles + num_remaining_particles, left_receiving_buffer, recvd_left_count * sizeof(particle_t));
memcpy(my_particles + num_remaining_particles + recvd_left_count, right_receiving_buffer, recvd_right_count * sizeof(particle_t));
num_my_particles = num_augmented_particles;
}
}
simulation_time = read_timer() - simulation_time;
if( rank == 0 ) {
printf( "num_particles = %d, num_procs = %d, simulation time = %g s\n", num_particles, num_procs, simulation_time );
}
if (savename) {
if (rank == 0) {
final_partition_sizes = (int*) malloc( num_procs * sizeof(int) );
}
MPI_Gather(&num_my_particles, 1, MPI_INT, final_partition_sizes, 1, MPI_INT, 0, MPI_COMM_WORLD);
if (rank == 0) {
final_partition_offsets = (int*) malloc( num_procs * sizeof(int) );
final_partition_offsets[0] = 0;
for (int i = 1; i < num_procs; i++) {
final_partition_offsets[i] = final_partition_offsets[i-1] + final_partition_sizes[i-1];
}
}
MPI_Gatherv(my_particles, num_my_particles, PARTICLE, particles, final_partition_sizes, final_partition_offsets, PARTICLE, 0, MPI_COMM_WORLD);
if (rank == 0) {
save( fsave, num_particles, particles );
free(final_partition_sizes);
free(final_partition_offsets);
}
}
free( partition_offsets );
free( partition_sizes );
free( my_particles ); // same as my_particles
free(remaining_particles);
free( left_sending_buffer );
free( right_sending_buffer );
free( left_receiving_buffer );
free( right_receiving_buffer );
if( fsave ) fclose( fsave );
MPI_Finalize();
return 0;
}
