void execute_pwaln(CtgDB *db, uint32_t min_overlap, float het, uint32_t max_nctg) { PWDB *pwaln; CtgDB *tdb = init_ctgdb(); uint32_t i; int last_oldcid = -1; int line_num = 0; Ctg *ctg; int id = 0; for (i = 0; i < count_ctglist(db->ctgs); i++) { ctg = ref_ctglist(db->ctgs, i); if (last_oldcid != (int)ctg->old_clsid) { if (line_num > 0) { tdb->ctgnum = count_ctglist(tdb->ctgs); if (tdb->ctgnum > 1 && tdb->ctgnum <= max_nctg) { //magic number 50 //print_ctgdb(tdb); pwaln = pw_aln_contigs(tdb); pwaln = clustering_ctg(pwaln, min_overlap, het); print_clusters(pwaln); free_pwdb(pwaln); free_ctgdb(tdb); } else { free_ctgdb(tdb); } id = 0; tdb = init_ctgdb(); } last_oldcid = (int)ctg->old_clsid; line_num++; ctg->cls_id = id; push_ctglist(tdb->ctgs, *ctg); id++; } else { line_num++; ctg->cls_id = id; push_ctglist(tdb->ctgs, *ctg); id++; } } tdb->ctgnum = count_ctglist(tdb->ctgs); if (tdb->ctgnum > 1 && tdb->ctgnum <= max_nctg) { //magic number 50 //print_ctgdb(tdb); pwaln = pw_aln_contigs(tdb); pwaln = clustering_ctg(pwaln, min_overlap, het); print_clusters(pwaln); free_pwdb(pwaln); free_ctgdb(tdb); } else { free_ctgdb(tdb); } }
//kernel code identification int kdi(unsigned startVirtualAddr, Mem * mem, int pageSize, unsigned cr3Pages[], int *kdi_time, int *allPages) { struct timeval earlier; struct timeval later; if (gettimeofday(&earlier, NULL)) { perror("gettimeofday() error"); exit(1); } //generate step 1 clusters unsigned cluster_index = getClusters(startVirtualAddr, mem, pageSize, allPages); print_clusters(cluster_index); findKernelCodePageByCr3(startVirtualAddr, mem, pageSize, cr3Pages); if (gettimeofday(&later, NULL)) { perror("gettimeofday() error"); exit(1); } (*kdi_time) = timeval_diff(NULL, &later, &earlier) / 1000; printf ("step1,all pages: %d, cluster: %d,kdi time cost is %d milliseconds\n", *allPages, cluster_index, (*kdi_time)); return cluster_index; }
int main(int argc, char **argv) { sparse_matrix_arr* adj_matrix; double precision; n_division *final_division; int i,max_group_index = 0; if (argc < 3) { fprintf(stderr, "Invalid Arguments, Aborting.\n"); fprintf(stderr, "Usage: %s <adjacency-mat-file> <group-file> <precision>\n", argv[0]); return EXIT_FAILURE; } if (sscanf(argv[2], "%lf", &precision) < 1) { fprintf(stderr, "Invalid precision, Aborting.\n"); fprintf(stderr, "Usage: %s <adjacency-mat-file> <group-file> <precision>\n", argv[0]); return EXIT_FAILURE; } if ((adj_matrix = read_adjacency_matrix_file(argv[1])) == NULL) { /*Problem reading adjacency matrix data */ return EXIT_FAILURE; } if ((final_division = algorithm3(adj_matrix, precision, 1)) == NULL) { free_sparse_matrix_arr(adj_matrix); return EXIT_FAILURE; } for(i=0; i<final_division->p_groups->n;i++) if (max_group_index<final_division->p_groups->values[i]) max_group_index = final_division->p_groups->values[i]; printf("%f %d\n", final_division->quality, max_group_index+1); print_clusters(final_division); free_sparse_matrix_arr(adj_matrix); free_n_division(final_division); return EXIT_SUCCESS; }
void output_blif (t_block *clb, int num_clusters, boolean global_clocks, boolean * is_clock, const char *out_fname, boolean skip_clustering) { /* * This routine dumps out the output netlist in a format suitable for * * input to vpr. This routine also dumps out the internal structure of * * the cluster, in essentially a graph based format. */ FILE *fpout; int bnum, column; struct s_linked_vptr *p_io_removed; int i; fpout = my_fopen(out_fname, "w", 0); column = 0; fprintf(fpout, ".model %s\n", blif_circuit_name); /* Print out all input and output pads. */ fprintf(fpout, "\n.inputs "); for (bnum = 0; bnum < num_logical_blocks; bnum++) { if (logical_block[bnum].type == VPACK_INPAD) { print_string(logical_block[bnum].name, &column, fpout); } } p_io_removed = circuit_p_io_removed; while (p_io_removed) { print_string((char*) p_io_removed->data_vptr, &column, fpout); p_io_removed = p_io_removed->next; } column = 0; fprintf(fpout, "\n.outputs "); for (bnum = 0; bnum < num_logical_blocks; bnum++) { if (logical_block[bnum].type == VPACK_OUTPAD) { /* remove output prefix "out:" */ print_string(logical_block[bnum].name + 4, &column, fpout); } } column = 0; fprintf(fpout, "\n\n"); /* print logic of clusters */ print_clusters(clb, num_clusters, fpout); /* handle special case: input goes straight to output without going through any logic */ for (bnum = 0; bnum < num_logical_blocks; bnum++) { if (logical_block[bnum].type == VPACK_INPAD) { for (i = 1; i <= vpack_net[logical_block[bnum].output_nets[0][0]].num_sinks; i++) { if (logical_block[vpack_net[logical_block[bnum].output_nets[0][0]].node_block[i]].type == VPACK_OUTPAD) { fprintf(fpout, ".names "); print_string(logical_block[bnum].name, &column, fpout); print_string( logical_block[vpack_net[logical_block[bnum].output_nets[0][0]].node_block[i]].name + 4, &column, fpout); fprintf(fpout, "\n1 1\n"); } } } } fprintf(fpout, "\n.end\n"); fclose(fpout); }
void output_clustering(t_block *clb, int num_clusters, boolean global_clocks, boolean * is_clock, char *out_fname, boolean skip_clustering) { /* * This routine dumps out the output netlist in a format suitable for * * input to vpr. This routine also dumps out the internal structure of * * the cluster, in essentially a graph based format. */ FILE *fpout; int bnum, netnum, column; fpout = fopen(out_fname, "w"); fprintf(fpout, "<block name=\"%s\" instance=\"FPGA_packed_netlist[0]\">\n", out_fname); fprintf(fpout, "\t<inputs>\n\t\t"); column = 2 * TAB_LENGTH; /* Organize whitespace to ident data inside block */ for (bnum = 0; bnum < num_logical_blocks; bnum++) { if (logical_block[bnum].type == VPACK_INPAD) { print_string(logical_block[bnum].name, &column, 2, fpout); } } fprintf(fpout, "\n\t</inputs>\n"); fprintf(fpout, "\n\t<outputs>\n\t\t"); column = 2 * TAB_LENGTH; for (bnum = 0; bnum < num_logical_blocks; bnum++) { if (logical_block[bnum].type == VPACK_OUTPAD) { print_string(logical_block[bnum].name, &column, 2, fpout); } } fprintf(fpout, "\n\t</outputs>\n"); column = 2 * TAB_LENGTH; if (global_clocks) { fprintf(fpout, "\n\t<clocks>\n\t\t"); for (netnum = 0; netnum < num_logical_nets; netnum++) { if (is_clock[netnum]) { print_string(vpack_net[netnum].name, &column, 2, fpout); } } fprintf(fpout, "\n\t</clocks>\n\n"); } /* Print out all input and output pads. */ for (bnum = 0; bnum < num_logical_blocks; bnum++) { switch (logical_block[bnum].type) { case VPACK_INPAD: case VPACK_OUTPAD: case VPACK_COMB: case VPACK_LATCH: if (skip_clustering) { assert(0); } break; case VPACK_EMPTY: vpr_printf(TIO_MESSAGE_ERROR, "in output_netlist: logical_block %d is VPACK_EMPTY.\n", bnum); exit(1); break; default: vpr_printf(TIO_MESSAGE_ERROR, "in output_netlist: Unexpected type %d for logical_block %d.\n", logical_block[bnum].type, bnum); } } if (skip_clustering == FALSE) print_clusters(clb, num_clusters, fpout); fprintf(fpout, "</block>\n\n"); fclose(fpout); print_stats(clb, num_clusters); }
int main(int argc, char **argv) { long int prev_cluster = 0, prev_total_cluster=-1, exit_count = 0; printf("Yet to cluster = %ld\n", yet_to_cluster); while(yet_to_cluster > 0) { if(prev_cluster-yet_to_cluster==total_clusters-prev_total_cluster) { exit_count++; if(exit_count >= 3*log(NO_READS)) { printf("No more clustering ... exiting ...\n\n"); store_clusters(); return 0; } } else exit_count = 0; hash_comparisions = 0; false_collisions = 0; prev_cluster = yet_to_cluster; prev_total_cluster = total_clusters; // copy reads from reads_rem.txt to reads_err.txt char sequence[READ_LENGTH] = {0}; long int read_number; FILE *f1, *f2; f1 = fopen("reads_rem.txt","r"); f2 = fopen("reads_err.txt","w"); while(fscanf(f1,"%ld",&read_number) != EOF) { fscanf(f1, "%s", sequence); fprintf(f2, "%ld\n", read_number); fprintf(f2, "%s\n", sequence); } fclose(f1); fclose(f2); // pickup random reads and setup the cluster centers pick_cluster_centers(); if(total_clusters > prev_total_cluster) { // cluster_reads cluster_reads(); base_comparisions = hash_comparisions + (false_collisions * 30) + ((prev_cluster-yet_to_cluster) * 30); // print clusters print_clusters(); } } store_clusters(); return 0; }