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