/*
* Compare two matrices. Print an error message if they differ by
* more than EPSILON.
*/
int compare_matrix(int n, REAL *A, int an, REAL *B, int bn)
{
int i, j;
REAL c;
int num_zero = 0;
for (i = 0; i < n; ++i)
for (j = 0; j < n; ++j) {
/* compute the relative error c */
if(ELEM(A, an, i, j) == 0 && ELEM(B, bn, i, j) == 0)
num_zero++;
c = ELEM(A, an, i, j) - ELEM(B, bn, i, j);
if (c < 0.0)
c = -c;
c = c / ELEM(A, an, i, j);
if (c > EPSILON) {
bots_message("Strassen: Wrong answer!\n");
return BOTS_RESULT_UNSUCCESSFUL;
}
}
if(num_zero == n * n) {
bots_message("Strassen: All zero!\n");
return BOTS_RESULT_UNSUCCESSFUL;
}
return BOTS_RESULT_SUCCESSFUL;
}
void uts_read_file ( char *filename )
{
FILE *fin;
if ((fin = fopen(filename, "r")) == NULL) {
bots_message("Could not open input file (%s)\n", filename);
exit (-1);
}
fscanf(fin,"%lf %lf %d %d %d %llu %d %llu",
&b_0,
&nonLeafProb,
&nonLeafBF,
&rootId,
&computeGranularity,
&exp_tree_size,
&exp_tree_depth,
&exp_num_leaves
);
fclose(fin);
computeGranularity = max(1,computeGranularity);
// Printing input data
bots_message("\n");
bots_message("Root branching factor = %f\n", b_0);
bots_message("Root seed (0 <= 2^31) = %d\n", rootId);
bots_message("Probability of non-leaf node = %f\n", nonLeafProb);
bots_message("Number of children for non-leaf node = %d\n", nonLeafBF);
bots_message("E(n) = %f\n", (double) ( nonLeafProb * nonLeafBF ) );
bots_message("E(s) = %f\n", (double) ( 1.0 / (1.0 - nonLeafProb * nonLeafBF) ) );
bots_message("Compute granularity = %d\n", computeGranularity);
bots_message("Random number generator = "); rng_showtype();
}
int readseqs(char *filename)
{
int i, l1, no_seqs;
FILE *fin = fopen(filename, "r");
char *seq1, chartab[128];
if (!fin) {
bots_message("Could not open sequence file (%s)\n", filename);
exit (-1);
}
if ( fscanf(fin,"Number of sequences is %d", &no_seqs) == EOF ) {
bots_message("Sequence file is bogus (%s)\n", filename);
exit(-1);
};
fill_chartab(chartab);
bots_message("Sequence format is Pearson\n");
alloc_aln(no_seqs);
for (i = 1; i <= no_seqs; i++) {
seq1 = get_seq(names[i], &l1, chartab, fin);
seqlen_array[i] = l1;
seq_array[i] = (char *) malloc((l1 + 2) * sizeof (char));
encode(seq1, seq_array[i], l1);
free(seq1);
}
return no_seqs;
}
counter_t serial_uts ( Node *root )
{
counter_t num_nodes;
bots_message("Computing Unbalance Tree Search algorithm ");
num_nodes = serTreeSearch( 0, root, uts_numChildren(root) );
bots_message(" completed!\n");
return num_nodes;
}
void strassen_main_par(REAL *A, REAL *B, REAL *C, int n)
{
bots_message("Computing parallel Strassen algorithm (n=%d) ", n);
#pragma omp parallel
#pragma omp single
#pragma omp task untied
OptimizedStrassenMultiply_par(C, A, B, n, n, n, n, 1);
bots_message(" completed!\n");
}
void find_queens (int size)
{
char *a;
total_count=0;
a = alloca(size * sizeof(char));
bots_message("Computing N-Queens algorithm (n=%d) ", size);
nqueens(size, 0, a, &total_count);
bots_message(" completed!\n");
}
counter_t parallel_uts ( Node *root )
{
counter_t num_nodes;
bots_message("Computing Unbalance Tree Search algorithm ");
#pragma omp parallel
#pragma omp single nowait
#pragma omp task untied
num_nodes = parTreeSearch( 0, root, getNumRootChildren(root) );
bots_message(" completed!");
return num_nodes;
}
static void write_outputs() {
int i, j;
bots_message("Minimum area = %d\n\n", MIN_AREA);
for (i = 0; i < MIN_FOOTPRINT[0]; i++) {
for (j = 0; j < MIN_FOOTPRINT[1]; j++) {
if (BEST_BOARD[i][j] == 0) {bots_message(" ");}
else bots_message("%c", (((int)BEST_BOARD[i][j]) - 1 + ((int)'A')));
}
bots_message("\n");
}
}
static void write_outputs() {
int i, j;
bots_message("Minimum area = %d\n\n", MIN_AREA);
for (i = 0; i < MIN_FOOTPRINT[0]; i++) {
for (j = 0; j < MIN_FOOTPRINT[1]; j++) {
if (BEST_BOARD[i * COLS + j] == 0) {bots_message(" ");}
else bots_message("%c", 'A' + BEST_BOARD[i * COLS + j] - 1);
}
bots_message("\n");
}
}
/***********************************************************************
* print_structure:
**********************************************************************/
void print_structure(char *name, float *M[])
{
int ii, jj;
bots_message("Structure for matrix %s @ 0x%p\n",name, M);
for (ii = 0; ii < bots_arg_size; ii++) {
for (jj = 0; jj < bots_arg_size; jj++) {
if (M[ii*bots_arg_size+jj]!=NULL) {bots_message("x");}
else bots_message(" ");
}
bots_message("\n");
}
bots_message("\n");
}
static void main_entrypoint(void *____arg) {
main_entrypoint_ctx *ctx = (main_entrypoint_ctx *)____arg;
int size; size = ctx->size;
{
total_count=0;
bots_message("Computing N-Queens algorithm (n=%d) ", size);
hclib_start_finish(); {
char *a;
a = (char *)malloc(size * sizeof(char));
nqueens(size, 0, a, &total_count,0);
} ; hclib_end_finish();
bots_message(" completed!\n");
} ; free(____arg);
}
unsigned long long parallel_uts ( Node *root )
{
unsigned long long num_nodes = 0 ;
root->numChildren = uts_numChildren(root);
bots_message("Computing Unbalance Tree Search algorithm ");
#pragma omp parallel
#pragma omp single nowait
#pragma omp task untied
num_nodes = parTreeSearch( 0, root, root->numChildren );
bots_message(" completed!");
return num_nodes;
}
void pairalign_init (char *filename)
{
int i;
if (!filename || !filename[0]) {
bots_error(0, "Please specify an input file with the -f option\n");
}
init_matrix();
nseqs = readseqs(1,filename);
bots_message("Multiple Pairwise Alignment (%d sequences)\n",nseqs);
for (i = 1; i <= nseqs; i++)
bots_debug("Sequence %d: %s %6.d aa\n", i, names[i], seqlen_array[i]);
ktup = 1;
window = 5;
signif = 5;
gap_open = 10.0;
gap_extend = 0.2;
pw_go_penalty = 10.0;
pw_ge_penalty = 0.1;
}
void uts_initRoot(Node * root)
{
root->height = 0;
root->numChildren = -1; // means not yet determined
rng_init(root->state.state, rootId);
bots_message("Root node at %p\n", root);
}
void find_queens (int size)
{
{
total_count=0;
bots_message("Computing N-Queens algorithm (n=%d) ", size);
{
{
char *a;
a = (char *)malloc(size * sizeof(char));
nqueens(size, 0, a, &total_count,0);
}
}
bots_message(" completed!\n");
}
}
void compute_floorplan (void)
{
#pragma omp_to_hclib
{
coor footprint;
/* footprint of initial board is zero */
footprint[0] = 0;
footprint[1] = 0;
bots_message("Computing floorplan ");
#pragma omp parallel
{
#pragma omp single
bots_number_of_tasks = add_cell(1, footprint, board, gcells, 0);
}
bots_message(" completed!\n");
}
}
void fib0 (int n)
{
#if defined(MANUAL_CUTOFF) || defined(IF_CUTOFF) || defined(FINAL_CUTOFF)
par_res = fib(n,0);
#else
par_res = fib(n);
#endif
bots_message("Fibonacci result for %d is %lld\n",n,par_res);
}
void fib0 (int n)
{
main_entrypoint_ctx *new_ctx = (main_entrypoint_ctx *)malloc(sizeof(main_entrypoint_ctx));
new_ctx->n = n;
const char *deps[] = { "system" };
hclib_launch(main_entrypoint, new_ctx, deps, 1);
bots_message("Fibonacci result for %d is %lld\n",n,par_res);
}
void uts_show_stats( void )
{
int nPes = atoi(bots_resources);
int chunkSize = 0;
bots_message("\n");
bots_message("Tree size = %llu\n", (unsigned long long) bots_number_of_tasks );
bots_message("Maximum tree depth = %d\n", maxTreeDepth );
bots_message("Chunk size = %d\n", chunkSize );
bots_message("Number of leaves = %llu (%.2f%%)\n", nLeaves, nLeaves/(float)bots_number_of_tasks*100.0 );
bots_message("Number of PE's = %.4d threads\n", nPes );
bots_message("Wallclock time = %.3f sec\n", bots_time_program );
bots_message("Overall performance = %.0f nodes/sec\n", (bots_number_of_tasks / bots_time_program) );
bots_message("Performance per PE = %.0f nodes/sec\n", (bots_number_of_tasks / bots_time_program / nPes) );
}
void sparselu_par_call(float **BENCH)
{
int ii, jj, kk;
bots_message("Computing SparseLU Factorization (%dx%d matrix with %dx%d blocks) ",
bots_arg_size,bots_arg_size,bots_arg_size_1,bots_arg_size_1);
#pragma omp parallel private(kk)
{
for (kk=0; kk<bots_arg_size; kk++)
{
#pragma omp single
lu0(BENCH[kk*bots_arg_size+kk]);
#pragma omp for nowait
for (jj=kk+1; jj<bots_arg_size; jj++)
if (BENCH[kk*bots_arg_size+jj] != NULL)
#pragma omp task untied firstprivate(kk, jj) shared(BENCH)
{
fwd(BENCH[kk*bots_arg_size+kk], BENCH[kk*bots_arg_size+jj]);
}
#pragma omp for
for (ii=kk+1; ii<bots_arg_size; ii++)
if (BENCH[ii*bots_arg_size+kk] != NULL)
#pragma omp task untied firstprivate(kk, ii) shared(BENCH)
{
bdiv (BENCH[kk*bots_arg_size+kk], BENCH[ii*bots_arg_size+kk]);
}
#pragma omp for private(jj)
for (ii=kk+1; ii<bots_arg_size; ii++)
if (BENCH[ii*bots_arg_size+kk] != NULL)
for (jj=kk+1; jj<bots_arg_size; jj++)
if (BENCH[kk*bots_arg_size+jj] != NULL)
#pragma omp task untied firstprivate(kk, jj, ii) shared(BENCH)
{
if (BENCH[ii*bots_arg_size+jj]==NULL) BENCH[ii*bots_arg_size+jj] = allocate_clean_block();
bmod(BENCH[ii*bots_arg_size+kk], BENCH[kk*bots_arg_size+jj], BENCH[ii*bots_arg_size+jj]);
}
}
}
bots_message(" completed!\n");
}
void compute_floorplan (void)
{
coor footprint;
/* footprint of initial board is zero */
footprint[0] = 0;
footprint[1] = 0;
bots_message("Computing floorplan ");
#pragma omp parallel
{
#pragma omp single
#if defined(MANUAL_CUTOFF) || defined(IF_CUTOFF) || defined(FINAL_CUTOFF)
bots_number_of_tasks = add_cell(1, footprint, board, gcells,0);
#else
bots_number_of_tasks = add_cell(1, footprint, board, gcells);
#endif
}
bots_message(" completed!\n");
}
void find_queens (int size)
{
#pragma omp_to_hclib
{
total_count=0;
bots_message("Computing N-Queens algorithm (n=%d) ", size);
#pragma omp parallel
{
#pragma omp single
{
char *a;
a = (char *)malloc(size * sizeof(char));
nqueens(size, 0, a, &total_count,0);
}
}
bots_message(" completed!\n");
}
}
int uts_check_result ( void )
{
int answer = BOTS_RESULT_SUCCESSFUL;
if ( bots_number_of_tasks != exp_tree_size ) {
answer = BOTS_RESULT_UNSUCCESSFUL;
bots_message("Tree size value is non valid.\n");
}
return answer;
}
int uts_check_result ( void )
{
int answer = BOTS_RESULT_SUCCESSFUL;
if ( bots_number_of_tasks != exp_tree_size ) {
answer = BOTS_RESULT_UNSUCCESSFUL;
bots_message("Incorrect tree size result (%llu instead of %llu).\n", bots_number_of_tasks, exp_tree_size);
}
return answer;
}
/***********************************************************************
* genmat:
**********************************************************************/
void genmat (float *M[])
{
int null_entry, init_val, i, j, ii, jj;
float *p;
int a=0,b=0;
init_val = 1325;
/* generating the structure */
for (ii=0; ii < bots_arg_size; ii++)
{
for (jj=0; jj < bots_arg_size; jj++)
{
/* computing null entries */
null_entry=FALSE;
if ((ii<jj) && (ii%3 !=0)) null_entry = TRUE;
if ((ii>jj) && (jj%3 !=0)) null_entry = TRUE;
if (ii%2==1) null_entry = TRUE;
if (jj%2==1) null_entry = TRUE;
if (ii==jj) null_entry = FALSE;
if (ii==jj-1) null_entry = FALSE;
if (ii-1 == jj) null_entry = FALSE;
/* allocating matrix */
if (null_entry == FALSE){
a++;
M[ii*bots_arg_size+jj] = (float *) malloc(bots_arg_size_1*bots_arg_size_1*sizeof(float));
if ((M[ii*bots_arg_size+jj] == NULL))
{
bots_message("Error: Out of memory\n");
exit(101);
}
/* initializing matrix */
p = M[ii*bots_arg_size+jj];
for (i = 0; i < bots_arg_size_1; i++)
{
for (j = 0; j < bots_arg_size_1; j++)
{
init_val = (3125 * init_val) % 65536;
(*p) = (float)((init_val - 32768.0) / 16384.0);
p++;
}
}
}
else
{
b++;
M[ii*bots_arg_size+jj] = NULL;
}
}
}
bots_debug("allo = %d, no = %d, total = %d, factor = %f\n",a,b,a+b,(float)((float)a/(float)(a+b)));
}
void fib0 (int n)
{
hclib_pragma_marker("omp_to_hclib", "", "pragma61_omp_to_hclib");
{
hclib_pragma_marker("omp", "parallel", "pragma63_omp_parallel");
{
hclib_pragma_marker("omp", "single", "pragma65_omp_single");
{
par_res = fib(n);
}
}
}
bots_message("Fibonacci result for %d is %lld\n",n,par_res);
}
unsigned long long parallel_uts ( Node *root )
{
unsigned long long num_nodes = 0 ;
root->numChildren = uts_numChildren(root);
bots_message("Computing Unbalance Tree Search algorithm ");
hclib_pragma_marker("omp_to_hclib", "", "pragma183_omp_to_hclib");
{
hclib_pragma_marker("omp", "parallel", "pragma185_omp_parallel");
{
hclib_pragma_marker("omp", "single nowait", "pragma187_omp_single");
{
hclib_pragma_marker("omp", "task untied", "pragma189_omp_task");
num_nodes = parTreeSearch( 0, root, root->numChildren );
}
}
}
bots_message(" completed!");
return num_nodes;
}
/***********************************************************************
* allocate_clean_block:
**********************************************************************/
float * allocate_clean_block()
{
int i,j;
float *p, *q;
p = (float *) malloc(bots_arg_size_1*bots_arg_size_1*sizeof(float));
q=p;
if (p!=NULL){
for (i = 0; i < bots_arg_size_1; i++)
for (j = 0; j < bots_arg_size_1; j++){(*p)=0.0; p++;}
}
else
{
bots_message("Error: Out of memory\n");
exit (101);
}
return (q);
}
void floorplan_init (char *filename)
{
int i,j;
inputFile = fopen(filename, "r");
if(NULL == inputFile) {
bots_message("Couldn't open %s file for reading\n", filename);
exit(1);
}
/* read input file and initialize global minimum area */
read_inputs();
MIN_AREA = ROWS * COLS;
/* initialize board is empty */
for (i = 0; i < ROWS; i++)
for (j = 0; j < COLS; j++) board[i][j] = 0;
}
int align_verify ()
{
int i,j;
int result = BOTS_RESULT_SUCCESSFUL;
for(i = 0; i<nseqs; i++)
{
for(j = 0; j<nseqs; j++)
{
if (bench_output[i*nseqs+j] != seq_output[i*nseqs+j])
{
bots_message("Error: Optimized prot. (%3d:%3d)=%5d Sequential prot. (%3d:%3d)=%5d\n",
i+1, j+1, (int) bench_output[i*nseqs+j],
i+1, j+1, (int) seq_output[i*nseqs+j]);
result = BOTS_RESULT_UNSUCCESSFUL;
}
}
}
return result;
}
