void app_init (App * app) { GError *err = NULL; app->definitions = gtk_builder_new (); gtk_builder_add_from_file (app->definitions, UI_DEFINITIONS_FILE, &err); if (err != NULL) { g_printerr ("Error while loading app definitions file: %s\n", err->message); g_error_free (err); gtk_main_quit (); } gtk_builder_connect_signals (app->definitions, app); app_init_colors (app); app->filename = NULL; app->display_level = FALSE; app->display_weight = FALSE; GtkCellRenderer *renderer=gtk_cell_renderer_text_new(); GET_UI_ELEMENT(GtkComboBox, combobox_from); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_from),renderer,FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_from),renderer, "text",0, NULL); gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_from),0); GET_UI_ELEMENT(GtkComboBox, combobox_to); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_to),renderer,FALSE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_to),renderer, "text",0, NULL); gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_to),0); //init non graphical units app->p_graph = malloc(sizeof(graph)); app->p_matrix = malloc(sizeof(matrix)); app->p_matrix->i_size = 3; matrix_malloc(app->p_matrix); matrix_zero(app->p_matrix); //construct the graph from the matrix init_all(app->p_graph, app->p_matrix); }
char set_level(matrix *p_matrix, summit *v_summit) { int i; int i_level = 0; matrix MatriceTemp; MatriceTemp.i_size = p_matrix->i_size; matrix_malloc(&MatriceTemp); if(has_loop(p_matrix)){ printf("Error : set_level. A matrix which have loop cannot be used to calculate levels"); return 0; } else{ //Initialisation matrix_copy(p_matrix, &MatriceTemp); for(i=0;i<MatriceTemp.i_size;i++){ v_summit[i].i_level = -1; } for(i=0;i<MatriceTemp.i_size;i++){ //Les sommets sans precedents sont de NV 0 if(has_prev(&MatriceTemp, i)){ v_summit[i].i_level = i_level; } } for(i=0;i<MatriceTemp.i_size;i++){ if(v_summit[i].i_level == i_level){ matrix_zero_at_line(&MatriceTemp, i); } } //Fin init while(!all_level_checked(p_matrix, v_summit)){ i_level++; for(i=0;i<MatriceTemp.i_size;i++){ if(has_prev(&MatriceTemp, i)&&(v_summit[i].i_level==-1)){ v_summit[i].i_level = i_level; } } for(i=0;i<MatriceTemp.i_size;i++){ if(v_summit[i].i_level == i_level){ matrix_zero_at_line(&MatriceTemp, i); } } //Fin for } //Fin while } //Fin si has_loop matrix_free(&MatriceTemp); return 1; }
void master(char *a_fname, char *b_fname, char *out_fname) { Matrix a = matrix_read(a_fname); Matrix b = matrix_read(b_fname); if (a.width != a.height || b.width != b.height || a.width != b.width) { printf("Invalid inputs. Both matricies must be nxn. A was %dx%d. B was" " %dx%d", a.height, a.width, b.height, b.width); MPI_Abort(MPI_COMM_WORLD, -1); } MPI_Bcast(&(a.width), 1, MPI_INT, 0, MPI_COMM_WORLD); Matrix result = matrix_malloc(a.width, b.width); matrix_init(&result); MPI_matrix_multiply(&result, &a, &b, a.width, 0, MPI_COMM_WORLD); matrix_write(out_fname, result); if (result.width <= 20) matrix_print(result); free(result.data); free(a.data); free(b.data); }
void MPI_matrix_multiply(Matrix *result, Matrix *a, Matrix *b, int n, int root, MPI_Comm comm) { int rank, total_procs; MPI_Comm_rank(comm, &rank); MPI_Comm_size(comm, &total_procs); int rows_per_proc = n / total_procs; int total_procs_used = total_procs; MPI_Comm gather_comm = comm; int gather_root = root; if (rows_per_proc == 0) { if (rank == root) printf("Warning: multilpying two %dx%d matricies takes %d or fewer" " processes. %d were given.\n", n, n, n, total_procs); int color = rank + root - 1; int key = color % total_procs + 1; color /= total_procs; MPI_Comm_split(comm, color, key, &gather_comm); if (rank == root) MPI_Comm_rank(gather_comm, &gather_root); MPI_Bcast(&gather_root, 1, MPI_INT, root, comm); if (color > 0) return; rows_per_proc = 1; total_procs_used = n; } if (n > total_procs && n % total_procs != 0) { if (rank == root) printf("Number of rows is not evenly divisible by number of processes.\n"); return; } int size = rows_per_proc * n; // ################################################## // Step 0: Distribute A and invert b // ################################################## Matrix A = matrix_malloc(rows_per_proc, n); MPI_Scatter(rank == root ? a->data : NULL, size, MPI_FLOAT, A.data, size, MPI_FLOAT, root, comm); if (rank == root && b->is_inverted != 1) matrix_invert(b); int i; int sender = (rank - 1) % total_procs; if (sender < 0) sender += total_procs; int reciever = (rank + 1) % total_procs; int last_proc_rank = (root + total_procs_used - 1) % total_procs; Matrix B = matrix_malloc(n, rows_per_proc); B.is_inverted = 1; Matrix C = matrix_malloc(rows_per_proc, n); C.is_inverted = 1; float *c_data = C.data; MPI_Status status; double start_time = MPI_Wtime(); for (i = 0; i < total_procs_used; i++) { // ################################################## // Step 1: Recieve Data // ################################################## if (rank == root) matrix_get_submatrix(&B, *b, 0, i * rows_per_proc); else MPI_Recv(B.data, rows_per_proc * n, MPI_FLOAT, sender, MPI_ANY_TAG, comm, &status); // ################################################## // Step 2: Calculate Dot Product // ################################################## matrix_multiply(&C, A, B); C.data += rows_per_proc; // ################################################## // Step 3: Send Data // ################################################## if (rank != last_proc_rank) MPI_Send(B.data, rows_per_proc * n, MPI_FLOAT, reciever, 0, comm); } C.data = c_data; // ################################################## // Step 4: Get time and Gather on root // ################################################## double end_time = MPI_Wtime(); if (rank == last_proc_rank) MPI_Send(&end_time, 1, MPI_DOUBLE, 0, 0, comm); if (rank == root) { MPI_Recv(&end_time, 1, MPI_DOUBLE, last_proc_rank, MPI_ANY_TAG, comm, &status); printf("Multiplication took %f seconds.\n", end_time - start_time); } int send_count = C.width * C.height; MPI_Gather(C.data, send_count, MPI_FLOAT, rank == root ? result->data : NULL, send_count, MPI_FLOAT, gather_root, gather_comm); free(C.data); free(B.data); free(A.data); }