int start_system_broadcast_without_solutions ( int myid, int n, int *nbsols )
{
int fail,dim;
if(myid == 0) /* manager reads start system */
{
fail = read_start_system_without_solutions();
fail = copy_start_system_to_container();
/* fail = solcon_open_solution_input_file(); */
fail = solcon_scan_solution_banner();
fail = solcon_read_solution_dimensions(nbsols,&dim);
printf("read the solution dimensions : %d\n",*nbsols);
}
else
/* initialize system container */
fail = syscon_initialize_number_of_standard_polynomials(n);
monomials_broadcast(myid,n); /* broadcast container */
if(myid != 0) /* copy result of broadcast */
{
fail = copy_container_to_start_system();
fail = syscon_clear_standard_system(); /* clear system container */
}
return fail;
}
int target_in_container_broadcast ( int myid, int n )
{
int fail;
if(myid == 0)
{
if(v>0) printf("Manager copies target system to container.\n");
fail = copy_target_system_to_container();
}
else
{
if(v>0) printf("Node %d initializes container with n = %d.\n",myid,n);
fail = syscon_initialize_number_of_standard_polynomials(n);
}
monomials_broadcast(myid,n);
if(myid != 0)
{
if(v>0) printf("Node %d copies container to target.\n",myid);
fail = copy_container_to_target_system();
fail = syscon_clear_standard_system();
}
return fail;
}
int main ( int argc, char *argv[] )
{
int myid,numprocs,n,nbsols,mysolnum;
MPI_Status status;
adainit();
MPI_Init(&argc,&argv);
MPI_Comm_size(MPI_COMM_WORLD,&numprocs);
MPI_Comm_rank(MPI_COMM_WORLD,&myid);
dimension_broadcast(myid,&n);
monomials_broadcast(myid,n);
copy_broadcast(myid);
start_system_broadcast(myid,n,&nbsols);
MPI_Bcast(&nbsols,1,MPI_INT,0,MPI_COMM_WORLD);
solutions_distribute(myid,nbsols,n,numprocs,&mysolnum);
// if(myid == 1) print_homotopy();
MPI_Finalize();
adafinal();
return 0;
}
int start_system_broadcast ( int myid, int n, int *nbsols )
{
int fail;
if(myid == 0) /* manager reads start system */
{
fail = read_standard_start_system();
fail = copy_start_system_to_container();
fail = copy_start_solutions_to_container();
}
else
/* initialize system container */
fail = syscon_initialize_number_of_standard_polynomials(n);
monomials_broadcast(myid,n); /* broadcast container */
if(myid != 0) /* copy result of broadcast */
{
fail = copy_container_to_start_system();
fail = syscon_clear_standard_system(); /* clear system container */
}
else
fail = solcon_number_of_standard_solutions(nbsols);
return fail;
}
void start_system_broadcast ( int myid, int n, int *nbsols )
{
int *a,*b,fail;
double *c;
if(myid == 0)
{
fail = _ada_use_c2phc(13,a,b,c); /* read start system */
/* fail = _ada_use_c2phc(14,a,b,c); */ /* write start system */
fail = _ada_use_c2phc(3,a,b,c); /* copy start to container */
/* fail = _ada_use_c2phc(21,a,b,c); */ /* write system in container */
fail = _ada_use_c2phc(7,a,b,c); /* copy start sols to container */
/* fail = _ada_use_c2phc(15,a,b,c); */ /* write start solutions */
}
if(myid != 0)
fail = _ada_use_c2phc(23,&n,b,c); /* initialize container */
monomials_broadcast(myid,n); /* broadcast container */
if(myid != 0) /* copy result of broadcast */
{
fail = _ada_use_c2phc(4,a,b,c); /* copy container to target */
fail = _ada_use_c2phc(27,a,b,c); /* clear systems container */
/* fail = _ada_use_c2phc(14,a,b,c); */ /* write start system */
}
if(myid == 0)
{
fail = _ada_use_c2phc(32,a,nbsols,c); /* get #solutions */
/* printf("There are %d start solutions.\n", *nbsols); */
}
}
void system_broadcast ( int myid, int n )
{
int fail;
if(myid == 0)
{
fail = celcon_create_random_coefficient_system();
/* if(v>1) fail = celcon_write_random_coefficient_system(); */
fail = celcon_copy_into_systems_container();
}
dimension_broadcast(myid,&n);
monomials_broadcast(myid,n);
if(myid != 0)
{
fail = celcon_copy_from_systems_container();
/* if(v>1) if(myid==1) fail = celcon_write_random_coefficient_system(); */
}
}
int named_start_system_broadcast
( int myid, int n, int *nbsols, int kind, int nc, char name[nc] )
{
int fail,dim;
if(myid == 0) /* manager reads start system */
{
if(kind == 2)
fail = read_named_linear_product_start_system(nc,name);
else
fail = read_named_start_without_solutions(nc,name);
fail = copy_start_system_to_container();
if(kind >= 3) /* cheater's homotopy */
{
fail = solcon_scan_solution_banner();
fail = solcon_read_solution_dimensions(nbsols,&dim);
}
else
fail = syscon_total_degree(nbsols);
if(v>0) printf("the number of solution paths : %d\n",*nbsols);
}
else
/* initialize system container */
fail = syscon_initialize_number_of_standard_polynomials(n);
monomials_broadcast(myid,n); /* broadcast container */
if(myid != 0) /* copy result of broadcast */
{
fail = copy_container_to_start_system();
fail = syscon_clear_standard_system(); /* clear system container */
}
return fail;
}
int monodromy_breakup ( int myid, int n, int dim, int deg, int nbloops,
int numprocs, double *trackwtime )
{
int mysolnum,i,done,fail;
if(v>0) printf("Node %d knows n = %d, #loops = %d.\n",myid,n,nbloops);
monomials_broadcast(myid,n);
MPI_Bcast(°,1,MPI_INT,0,MPI_COMM_WORLD);
if(v>0) printf("Node %d went through bcast of degree %d.\n",myid,deg);
solutions_distribute(myid,deg,n,numprocs,&mysolnum);
MPI_Bcast(&dim,1,MPI_INT,0,MPI_COMM_WORLD);
fail = initialize_standard_sampler(dim);
if(myid == 0)
{
fail = validate_solutions(); /* sanity check */
fail = initialize_standard_monodromy(nbloops,deg,dim);
/* initialize traces */
if(v>1) print_solutions(myid);
fail = store_standard_solutions();
}
for(i=1; i<=2; i++)
{
if((v>0)&&(myid == 0)) printf("slice %d for linear trace...\n",i);
trace_slice_broadcast(myid,i);
gamma_broadcast(myid,n);
f_track_paths(myid,deg,n,numprocs,mysolnum,trackwtime);
if(myid == 0)
{
fail = store_standard_solutions();
fail = restore_standard_solutions();
}
solutions_distribute(myid,deg,n,numprocs,&mysolnum);
if(myid == 0) f_swap_slices(myid);
}
slices_broadcast(myid,dim,n);
for(i=0; i<nbloops; i++)
{
if((v>0)&&(myid == 0)) printf("Starting loop #\%d...\n",i);
gamma_broadcast(myid,n);
f_track_paths(myid,deg,n,numprocs,mysolnum,trackwtime);
if(myid != 0) f_swap_slices(myid);
if(myid == 0)
{
if(v>1) print_solutions(myid);
solcon_clear_standard_solutions();
}
gamma_broadcast(myid,n);
f_track_paths(myid,deg,n,numprocs,mysolnum,trackwtime);
if(myid == 0)
{
if(v>1) print_solutions(myid);
fail = store_standard_solutions();
fail = standard_monodromy_permutation(deg,&done);
solcon_clear_standard_solutions();
}
MPI_Bcast(&done,1,MPI_INT,0,MPI_COMM_WORLD);
MPI_Barrier(MPI_COMM_WORLD); /* every node must know if done */
if(done == 1)
{
if (v>0) printf("Node %d leaves the loop at step %d.\n", myid,i+1);
if(myid == 0) printf("Executed %d monodromy loops.\n", i+1);
return 0;
}
else
{
if(myid != 0) f_swap_slices(myid);
slices_broadcast(myid,dim,n); /* new slices */
if(myid == 0) fail = restore_standard_solutions();
MPI_Bcast(°,1,MPI_INT,0,MPI_COMM_WORLD);
solutions_distribute(myid,deg,n,numprocs,&mysolnum);
}
}
if(myid == 0) printf("Executed %d monodromy loops.\n", i+1);
return 1;
}
void cascade_one_level_down(int myid, int numbprocs, char *infile,
char *outfile, WSET *ws, int num_group,
int stages, int cnt_stage, int cnt_step, IDLE_ELEMENT **ie,
LISTELEMENT **listpointer, int *TaskCount,
int NUM_GROUP, int *dimension, int *cnt_index,
int update_flag)
{
int n,/* dimension */
nbsols, dim, deg, fail, i,
n1, n2, cd;
double vcp[34];
if(myid == 0)
{
printf("manager is in inside of cascade_one_level_down\n");
read_dimension_of_system((int)strlen(infile),infile,&n);
}
dimension_broadcast(myid,&n);
if(myid == 0)
{
fail = syscon_clear_symbol_table();
fail = read_named_start_without_solutions((int)strlen(infile),infile);
/*fail = copy_start_system_to_container();*/
fail = copy_start_system_to_container();
fail = syscon_sort_embed_symbols(&dim);
printf("the top dimension is %d\n",dim);
fail = copy_container_to_start_system();
fail = solcon_scan_solution_banner();
fail = solcon_read_solution_dimensions(&nbsols,dimension);
}
else
/* initialize system container */
fail = syscon_initialize_number_of_standard_polynomials(n);
monomials_broadcast(myid,n); /* broadcast container */
if(myid != 0) /* copy result of broadcast */
{
fail = copy_container_to_start_system();
fail = syscon_clear_standard_system(); /* clear system container */
}
fail = create_cascade_homotopy();
MPI_Barrier(MPI_COMM_WORLD);
if(myid == 0)
{
if(v>3) printf("# paths to track : %d\n",nbsols);
fail = define_output_file_with_string ((int)strlen(outfile), outfile);
fail = write_standard_target_system();
fail = write_standard_start_system();
/*fail = tune_continuation_parameters(); printf("\n");*/
fail = retrieve_continuation_parameters(vcp);
write_solution_banner_to_defined_output_file(nbsols,n);
printf("\nSee the output file for results...\n\n");
}
MPI_Bcast(&nbsols,1,MPI_INT,0,MPI_COMM_WORLD);
MPI_Bcast(vcp,34,MPI_DOUBLE,0,MPI_COMM_WORLD);
if(myid != 0)
{
fail = set_continuation_parameters(vcp);
}
if(myid == 0)
{
n1=0; n2=0; cd=n;
send_collect(ws, num_group, stages, cnt_stage, numbprocs, cnt_step,
ie, listpointer, TaskCount, NUM_GROUP,
cnt_index, update_flag,
n1, n2, cd);
if(update_flag) *cnt_index=*cnt_index+1;
if(v>3)
{
printf("after send_collect \n");
printf("%d JOBs in listpointer. \n", length(*listpointer));
printf("%d idles\n", num_idle(*ie));
printf("indexing........ with cnt_index=%d\n", *cnt_index);
}
}
else
{
if(v>3) printf("node %d will run run_slave \n", myid); fflush;
run_slave(myid);
}
MPI_Barrier(MPI_COMM_WORLD);
if(myid == 0)
{
if(v>3) printf("manager clear data \n");
fail = clear_data();
if(fail>0) printf("manager fail to clear data.\n"); fflush;
fail = solcon_close_solution_input_file(0);
if(fail>0) printf("fail to close solution input file.\n");
fail = solcon_clear_standard_solutions( );
if(fail>0) printf("fail to clear solution container.\n");
fail = close_output_file();
if(fail>0) printf("fail to close output file. \n");
fflush;
}
else
{
if(v>3) printf("node %d clear data \n", myid);
fail = clear_data();
if(fail>0) printf("node %d fail to clear data.\n", myid);
fflush;
}
}
int standard_run ( int myid, int nbrp, int nbc, char* outfile, int verbose )
{
int fail,dim,nbsols,mysolnum,len,*nbpaths;
double startwtime,endwtime,wtime,*time;
startwtime = MPI_Wtime();
if(myid == 0)
{
time = (double*)calloc(nbrp,sizeof(double));
nbpaths = (int*)calloc(nbrp,sizeof(int));
fail = read_target_system_without_solutions();
fail = copy_target_system_to_container();
fail = syscon_number_of_standard_polynomials(&dim);
fail = write_standard_target_system(); // writes to file
}
standard_dimensions_broadcast(myid,&dim,&dim);
if(verbose > 0) printf("Process %d has dimension %d.\n",myid,dim);
monomials_broadcast(myid,dim); // broadcast target system
if(myid != 0) fail = copy_container_to_target_system();
if(verbose > 0)
if(myid == 1) fail = write_standard_target_system();
if(myid == 0)
{
fail = read_standard_start_system();
fail = copy_start_system_to_container();
fail = write_standard_start_system(); // writes to file
fail = write_start_solutions(); // writes solutions to file
fail = copy_start_solutions_to_container();
fail = solcon_number_of_standard_solutions(&nbsols);
if(verbose>0) printf("Read %d start solutions.\n",nbsols);
}
else
fail = syscon_initialize_number_of_standard_polynomials(dim);
monomials_broadcast(myid,dim); // broadcast start system
if(myid != 0) fail = copy_container_to_start_system();
if(verbose > 0)
if(myid == 1) fail = write_standard_start_system();
parameters_broadcast(myid,nbrp,verbose);
if(myid == 0) verbose = prompt_for_verbose();
MPI_Barrier(MPI_COMM_WORLD);
MPI_Bcast(&verbose,1,MPI_INT,0,MPI_COMM_WORLD);
MPI_Bcast(&nbsols,1,MPI_INT,0,MPI_COMM_WORLD);
solutions_distribute(myid,nbsols,dim,nbrp,&mysolnum);
fail = solcon_number_of_standard_solutions(&len);
if(verbose > 0) printf("Node %d has %d solutions.\n",myid,len);
if(myid > 0)
{
fail = copy_container_to_start_solutions();
fail = standard_track_paths(myid,nbrp,nbc,outfile,verbose);
}
MPI_Barrier(MPI_COMM_WORLD);
solutions_collect(myid,nbsols,dim,nbrp,mysolnum);
if(myid == 0)
{
fail = copy_container_to_target_solutions();
fail = write_target_solutions();
}
endwtime = MPI_Wtime();
wtime = endwtime-startwtime;
MPI_Gather(&wtime,1,MPI_DOUBLE,time,1,MPI_DOUBLE,0,MPI_COMM_WORLD);
MPI_Gather(&mysolnum,1,MPI_INT,nbpaths,1,MPI_INT,0,MPI_COMM_WORLD);
if(myid == 0)
{
nbpaths[0] = nbsols;
write_time_and_paths_to_defined_output_file(nbrp,time,nbpaths);
free(time); free(nbpaths);
}
return 0;
}
