void uvm_phase_controller::wait_for_run_phases()
{
// wait for all spawned runtime schedules to complete their run phases
if (m_join_run.process_count() > 0) {
m_join_run.wait();
}
// all stop tasks have returned => end run phase
stop_run(UVM_STOP_REASON_PHASE_COMPLETE);
}
void uvm_phase_controller::wait_for_global_timeout() {
// Since this thread may be spawned slightly later, get accurate timeout based on spawn time
sc_time tdur = m_global_timeout - sc_time_stamp();
wait(tdur);
// global timeout has expired => run phase has ended
SC_REPORT_WARNING(UVM_PHASE_CTRL_GLOBAL_TIMEOUT,"");
stop_run(UVM_STOP_REASON_GLOBAL_TIMEOUT);
}
int my_stop(int value, char *message)
{
int size;
char buff[1024];
size = 0;
if (write(1, "car_forward:0\n", 14) == -1)
return (my_putstr("Error with write.\n", 2, -1));
if ((size = read(0, buff, 1023)) < 0)
return (my_putstr("Error with read.\n", 2, -1));
buff[size - 1] = '\0';
if (my_strncmp(buff, "1:OK:", 5) != 0)
return (my_putstr("Error with car_forward:0.\n", 2, -1));
return (stop_run(value, message));
}
int main ( int argc, char *argv[] )
{
/***********************************************************************
* Local variables
***********************************************************************/
int ierr = 0; // Flag errors
char *error = NULL; // Error message string
double t1, t2, t3, t4, t5; // Variables to track runtime
/* File in/out handling variables */
char *inputFile = NULL, *outputFile = NULL;
FILE *fp_in = NULL, *fp_out = NULL;
input_data input_vars; // Struct to store input variables
input_data_init ( &input_vars ); // Set variables to initial values
para_data para_vars; // Struct to store parallel variables
para_data_init ( ¶_vars ); // Set variables to initial values
time_data time_vars; // Struct to store time variables
time_data_init ( &time_vars ); // Set variables to initial values
geom_data geom_vars; // Struct to store geometry variables
geom_data_init ( &geom_vars ); // Set variables to initial values
sn_data sn_vars; // Struct to store sn variables
sn_data_init ( &sn_vars ); // Set variables to initial values
data_data data_vars; // Struct to store data variables
data_data_init ( &data_vars ); // Set variables to initial values
control_data control_vars; // Struct to store control variables
control_data_init ( &control_vars ); // Set variables to initial values
mms_data mms_vars; // Struct to store mms variables
mms_data_init ( &mms_vars ); // Set variables to initial values
solvar_data solvar_vars; // Struct to store solvar variables
solvar_data_init ( &solvar_vars ); // Set variables to initial values
sweep_data sweep_vars; // Struct to store sweep variables
sweep_data_init ( &sweep_vars ); // Set variables to initial values
dim_sweep_data dim_sweep_vars;
/***********************************************************************
* Perform calls that set up the parallel environment in MPI and
* OpenMP. Also starts the timer. Update parallel setup time.
***********************************************************************/
/* Initialize the parallel environment */
pinit ( argc, argv, ¶_vars, &t1, &ierr );
t2 = wtime(); // Get the MPI walltime
/* Calc parallel setup time */
time_vars.tparset = time_vars.tparset + t2 - t1;
/***********************************************************************
* Read the command line arguments to get i/o file names.
* Open the two files.
***********************************************************************/
ierr = cmdarg ( argc, argv, &inputFile, &outputFile, &error,
para_vars.iproc, para_vars.root );
bcast_i_scalar ( &ierr, para_vars.comm_snap, para_vars.root, para_vars.nproc );
/* Ensure arguments are valid */
if ( ierr != 0 )
{
print_error ( NULL, error, para_vars.iproc, para_vars.root );
FREE ( inputFile );
FREE ( outputFile );
FREE ( error );
stop_run ( 0, 0, 0, ¶_vars, &sn_vars, &data_vars, &mms_vars,
&geom_vars, &solvar_vars, &control_vars );
}
/* Open the input file to read in initial values */
ierr = open_file ( &fp_in, inputFile, "r", &error, para_vars.iproc, para_vars.root );
bcast_i_scalar ( &ierr, para_vars.comm_snap, para_vars.root, para_vars.nproc);
/* Ensure input file is found */
if ( ierr != 0 )
{
print_error ( NULL, error, para_vars.iproc, para_vars.root );
FREE ( inputFile );
FREE ( outputFile );
FREE ( error );
stop_run ( 0, 0, 0, ¶_vars, &sn_vars, &data_vars, &mms_vars,
&geom_vars, &solvar_vars, &control_vars );
}
/* Open the output file to write results and error messages */
ierr = open_file ( &fp_out, outputFile, "w", &error, para_vars.iproc, para_vars.root );
bcast_i_scalar ( &ierr, para_vars.comm_snap, para_vars.root, para_vars.nproc );
/* Ensure output file can be created */
if ( ierr != 0 )
{
print_error ( NULL, error, para_vars.iproc, para_vars.root );
FREE ( inputFile );
FREE ( outputFile );
FREE ( error );
stop_run ( 0, 0, 0, ¶_vars, &sn_vars, &data_vars, &mms_vars,
&geom_vars, &solvar_vars, &control_vars );
}
/***********************************************************************
* Write code version and execution time to output.
***********************************************************************/
if ( para_vars.iproc == para_vars.root ) version_print ( fp_out );
/***********************************************************************
* Read input
***********************************************************************/
ierr = read_input ( fp_in, fp_out, &input_vars, ¶_vars, &time_vars );
ierr = close_file ( fp_in, inputFile, &error, para_vars.iproc,
para_vars.root );
FREE ( inputFile );
bcast_i_scalar ( &ierr, para_vars.comm_snap, para_vars.root, para_vars.nproc );
if ( ierr != 0 )
{
print_error ( fp_out, error, para_vars.iproc, para_vars.root );
FREE ( outputFile );
FREE ( error );
stop_run ( 0, 0, 0, ¶_vars, &sn_vars, &data_vars, &mms_vars,
&geom_vars, &solvar_vars, &control_vars );
}
/***********************************************************************
* Get nthreads for each proc. Print the warning about resetting
* nthreads if necessary. Don't stop run. Set up the SDD MPI topology.
***********************************************************************/
t3 = wtime();
pinit_omp ( para_vars.comm_snap, &input_vars.nthreads, input_vars.nnested,
¶_vars.do_nested, &ierr, &error );
if ( ierr != 0 ) print_error ( NULL, error, para_vars.iproc,
para_vars.root );
pcomm_set ( input_vars.npey, input_vars.npez, ¶_vars, &ierr );
t4 = wtime();
time_vars.tparset = time_vars.tparset + t4 - t3;
/***********************************************************************
* Setup problem
***********************************************************************/
setup ( &input_vars, ¶_vars, &time_vars, &geom_vars, &sn_vars,
&data_vars, &solvar_vars, &control_vars, &mms_vars, fp_out,
&ierr, &error );
/***********************************************************************
* Call for the problem solution
***********************************************************************/
translv ( &input_vars, ¶_vars, &time_vars, &geom_vars, &sn_vars,
&data_vars, &control_vars, &solvar_vars, &mms_vars,
&sweep_vars, &dim_sweep_vars, fp_out, &ierr, &error );
/***********************************************************************
* Output the results. Print the timing summary
***********************************************************************/
output ( &input_vars, ¶_vars, &time_vars, &geom_vars, &data_vars,
&sn_vars, &control_vars, &mms_vars, &solvar_vars, &sweep_vars,
fp_out, &ierr, &error );
if ( para_vars.iproc == para_vars.root ) time_summ ( fp_out, &time_vars );
/***********************************************************************
* Final cleanup: deallocate, close output file, end the program
***********************************************************************/
dealloc_input ( 3, &sn_vars, &data_vars, &mms_vars );
dealloc_solve ( 3, &geom_vars, &solvar_vars, &control_vars );
t5 = wtime();
time_vars.tsnap = t5 - t1;
if ( para_vars.iproc == para_vars.root )
{
fprintf ( fp_out, " Total Execution time"
" %.4E\n\n", time_vars.tsnap );
fprintf ( fp_out, " Grind Time (nanoseconds)"
" %.4E\n\n", time_vars.tgrind );
fprintf ( fp_out,
"****************************************"
"****************************************\n" );
}
ierr = close_file ( fp_out, outputFile, &error, para_vars.iproc, para_vars.root );
FREE ( outputFile );
bcast_i_scalar ( &ierr, para_vars.comm_snap, para_vars.root, para_vars.nproc );
if ( ierr != 0 )
{
print_error ( 0, error, para_vars.iproc, para_vars.root );
FREE ( error );
stop_run ( 0, 0, 0, ¶_vars, &sn_vars, &data_vars, &mms_vars,
&geom_vars, &solvar_vars, &control_vars );
}
if ( control_vars.otrdone )
{
FREE ( error );
stop_run ( 0, 0, 1, ¶_vars, &sn_vars, &data_vars, &mms_vars,
&geom_vars, &solvar_vars, &control_vars );
}
else
{
FREE ( error );
stop_run ( 0, 0, 2, ¶_vars, &sn_vars, &data_vars, &mms_vars,
&geom_vars, &solvar_vars, &control_vars );
}
return 0;
}
/*******************************************************************************
* Control the setup process
*******************************************************************************/
void setup ( input_data *input_vars, para_data *para_vars, time_data *time_vars,
geom_data *geom_vars, sn_data *sn_vars, data_data *data_vars,
solvar_data *solvar_vars, control_data *control_vars,
mms_data *mms_vars, FILE *fp_out, int *ierr, char **error )
{
/*******************************************************************************
* Local variables
*******************************************************************************/
int flg, mis, mie, mjs, mje, mks, mke, qis, qie, qjs, qje, qks, qke;
double t1, t2;
/*******************************************************************************
* First put input ny and nz into ny_gl and nz_gl respectively. Use ny
* and nz for local sizes. Determine global indices of local bounds.
* Establish min of nthreads and ng for threaded MPI calls in sweep.
*******************************************************************************/
t1 = wtime();
NY_GL = NY;
NZ_GL = NZ;
NY = NY_GL / NPEY;
NZ = NZ_GL / NPEZ;
JLB = YPROC * NY + 1;
JUB = (YPROC + 1) * NY;
KLB = ZPROC * NZ + 1;
KUB = (ZPROC + 1) * NZ;
NUM_GRTH = MIN( NTHREADS, NG );
/*******************************************************************************
* Allocate needed arrays
*******************************************************************************/
setup_alloc( input_vars, para_vars, sn_vars, data_vars, &flg, ierr, error );
if ( *ierr != 0 )
{
print_error ( fp_out, *error, IPROC, ROOT );
stop_run( flg, 0, 0, para_vars, sn_vars, data_vars, mms_vars,
geom_vars, solvar_vars, control_vars );
}
/*******************************************************************************
* Progress through setups. _delta sets cell and step sizes, _vel sets
* velocity array, _angle sets the ordinates/weights, _mat sets the
* material identifiers, _src sets fixed source, _data sets the
* mock cross section arrays, and expcoeff sets up the scattering
* expansion basis function array.
*******************************************************************************/
setup_delta( input_vars, geom_vars, control_vars );
setup_vel( input_vars, data_vars );
setup_angle( input_vars, sn_vars );
setup_mat( input_vars, geom_vars, data_vars,
&mis, &mie, &mjs, &mje, &mks, &mke );
setup_data( input_vars, data_vars );
expcoeff( input_vars, sn_vars, &NDIMEN );
setup_src( input_vars, para_vars, geom_vars, sn_vars, data_vars, control_vars,
mms_vars, &qis, &qie, &qjs, &qje, &qks, &qke, ierr, error );
if ( *ierr != 0 )
{
print_error ( fp_out, *error, IPROC, ROOT );
stop_run( 2, 0, 0, para_vars, sn_vars, data_vars, mms_vars,
geom_vars, solvar_vars, control_vars );
}
/*******************************************************************************
* Echo the data from this module to the output file. If requested via
* scatp, print the full scattering matrix to file.
*******************************************************************************/
if ( IPROC == ROOT )
{
setup_echo ( fp_out, input_vars, para_vars, geom_vars, data_vars, sn_vars,
control_vars, mis, mie, mjs, mje, mks, mke,
qis, qie, qjs, qje, qks, qke );
if ( SCATP == 1 ) setup_scatp( input_vars, para_vars, data_vars, ierr, error );
}
glmax_i ( ierr, COMM_SNAP );
if ( *ierr != 0 )
{
print_error ( fp_out, *error, IPROC, ROOT );
FREE ( error );
stop_run ( 3, 0, 0, para_vars, sn_vars, data_vars, mms_vars,
geom_vars, solvar_vars, control_vars );
}
t2 = wtime();
TSET = t2 - t1;
}
