main()

int main	(	int	argc,
		char **	argv
	)

AcouSTO Entry point.

int main(int argv, char **argv) AcouSTO Entry point.

• MPI initialization
• configuration parsing
• modules calling geometry, BEM coefficients, solution
• finalization many things could be improved among which:
  • avoid (where possible) global variables to improve readability
  • introduce a dynamic linking architecture to load modules at runtime

                                {
  int c ;
  int option_index = 0; // for getopt

  /* used for time recording */
  double rawtime0;
  double rawtime1;
  double rawtime2;
  double rawtime3;
  double rawtime4;
  double timebco, timemco, timesol;

  // log level as read by command line */
  int log_level = LOG_INFO;

  /* convenience array chars to store dates */
  char starttime[80];
  char endtime[80];

  int mpierr; // mpi error code
  int iam, nprocs;


  int onlymemoryout;
  DOUBLE mem2 = 0.0;
  int check_dir = 0; // Defaults to overwrite directory

  /*   Start of code */
  setLogLevel(log_level); // setting level to info for starters

  // MPI Initialization. We didn't declare a different error handler, thus the
  // default behaviour on error is aborting the code. We are fine with it for now.
  mpierr = MPI_Init(&argc, &argv);

  MPI_Comm_rank(MPI_COMM_WORLD, &rank); /* getting my rank */
  MPI_Comm_size(MPI_COMM_WORLD, &size); /* getting group size */

  MPI_AcouSTO_structs(); // Initialization of AcouSTO custom structures

//  allocating GLOBAL structures for data (defined in common.h)
  runinfo       = calloc(1,sizeof(struct run_info));
  rundetails    = calloc(1,sizeof(struct run_details));
  modgeominfo   = calloc(1,sizeof(struct modgeom_info));
  modcoefacinfo = calloc(1,sizeof(struct modcoefac_info));
  modcoemicinfo = calloc(1,sizeof(struct modcoemic_info));
  modsolinfo    = calloc(1,sizeof(struct modsol_info));
#ifdef _MYSQL_
  mysqlinfo     = calloc(1,sizeof(struct mysql_info));
#endif

  // recording start time
  time(&rundetails->starttime);

  // Allocating solution struct
  solution = calloc(1,sizeof(struct solution_struct));

  /*
   * Read main options with getopt only on master process.
   */
  if (0 == rank) { /* MASTER PROCESS */
    fileinfo = malloc(sizeof(struct file_info));

    /* Defining long options struct */
    static struct option long_options[] = { 
       { "dat-file", required_argument, 0, 'f' }, 
       { "version", no_argument, 0, 'V' }, 
       { "help", no_argument, 0, 'h' },
       { "log-level", required_argument, 0, 'l' }, 
       { "estimate-memory", required_argument, 0, 'm' } ,
       { "check-dir", no_argument, 0, 'c' } 
    };

    opterr = 0; // reset error

    //back up main parameters
    main_argc = argc;
    main_argv = argv;
    onlymemoryout= 0;

    /*  Options Parsing loop */
    while ((c = getopt_long(argc, argv, "f:l:Vhmc", long_options, &option_index)) != -1)
    switch (c)
    {
      case 'f': // file name
        datfile = malloc(strlen(optarg)+1);
        strcpy(datfile,optarg);
        break;
      case 'V': // version
        printf("%s %s\n", ac_name,ac_version);
        break;
      case 'c': // Checkdir flag
        check_dir = 1;
        break;
      case 'h': // help
        printhelp();
        exit(1);
        break;
      case 'l': // log level
        log_level = atoi(optarg);
        setLogLevel(log_level);
        break;
      case '?': // what ?!
        if (optopt == 'f')
          fprintf(stderr, "Option -%c requires an argument.\n", optopt);
      case 'm': // Only memory out
        onlymemoryout = 1;

      default: // default prints nothing
        printf(" ");
    }
    logger(LOG_INFO, "****************    Job started     ***************\n");
    logger(LOG_INFO, "Program started\n");

    /* READING CONFIG FILE */
    if(-1 == readconfig(datfile,check_dir)){
      cleanup();
      return -1;
    }


  } // END OF MASTER PROCESS SECTION

  // Sending &configuration to all nodes
  MPI_Bcast(&log_level, 1, MPI_INT, 0, MPI_COMM_WORLD);
  setLogLevel(log_level);

  logger(LOG_DEBUG, "Broadcasting &config...\n");
  MPI_Bcast(runinfo               , 1, mpi_runinfo_type , 0, MPI_COMM_WORLD);
  MPI_Bcast(modgeominfo           , 1, mpi_geominfo_type, 0, MPI_COMM_WORLD);
  MPI_Bcast(modsolinfo            , 1, mpi_solinfo_type , 0, MPI_COMM_WORLD);
  MPI_Bcast(&modcoemicinfo->active, 1, MPI_INT          , 0, MPI_COMM_WORLD);
  MPI_Bcast(&modcoefacinfo->active, 1, MPI_INT          , 0, MPI_COMM_WORLD);

#ifdef _MYSQL_
  // broadcasting only info on mysql active
  MPI_Bcast(&mysqlinfo->active,1,MPI_INT,0,MPI_COMM_WORLD);
#endif
  logger(LOG_DEBUG, "Broadcasting &config done\n");

  // consistency checks
  if (modsolinfo->nradian > modgeominfo->ncntr && 0 == modsolinfo->custombc) {
    logger(LOG_ERROR, "Number of radiant panels (%d) cannot be higher then number of unsymmetrized elements(%d): \n", modsolinfo->nradian, modgeominfo->ncntr);
    cleanup();
    return 1;
  }

  // consistency checks
  if (modsolinfo->nimped > modgeominfo->ncntr && 0 == modsolinfo->custombc) {
    logger(LOG_ERROR, "Number of impedent panels (%d) cannot be higher then number of unsymmetrized elements(%d): \n", modsolinfo->nimped, modgeominfo->ncntr);
    cleanup();
    return 1;
  }

  // initializing BLACS grid
  if (size < runinfo->nprows * runinfo->npcols) { // check on grid size
    logger(LOG_ERROR, "Number of processes (%d) not enough for grid size (%d x %d )\n", size, runinfo->nprows, runinfo->npcols);
    cleanup();
    return 1;
  }

  logger(LOG_INFO, " Initializing process grid [%d x %d]\n", runinfo->nprows, runinfo->npcols);
  Cblacs_pinfo(&iam, &nprocs);
  Cblacs_get(0, 0, &runinfo->ctxt);
  Cblacs_gridinit(&runinfo->ctxt, "R", runinfo->nprows, runinfo->npcols); // grid init
  Cblacs_gridinfo(runinfo->ctxt, &runinfo->nprows, &runinfo->npcols, &(runinfo->myrow), &(runinfo->mycol)); // grid info
  logger(LOG_INFO, " Successfully initialized process grid [%d x %d]\n", runinfo->nprows, runinfo->npcols);

  rawtime0 = MPI_Wtime(); // checkpoint

  MPI_Bcast(&onlymemoryout,1,MPI_INT,0,MPI_COMM_WORLD);
  if (rank == 0) {
    logger(LOG_INFO, "****************    Memory Estimate    ***************\n");
    logger(LOG_INFO,"Consider this as a rough estimate. \n");
    logger(LOG_INFO,"Memory actually allocated heavily depends on \n");
    logger(LOG_INFO," the particular combination of parameters used  \n");
    mem2 = estimate_memory2();
    PRINT_MEM("Estimated Memory for Each Process:", mem2);
    logger(LOG_INFO, "****************    Memory Estimate-end    ***********\n");
  }
  if (onlymemoryout) {
    goto cleanup;
  }
  /*******************************************
   * STARTING ELABORATION
   *******************************************/
  /* GEOMETRY */
  if (1 == modgeominfo->active) {
    logger(LOG_INFO, MSG_GEOMETRY_START);
    if (1 != georeader()) {
      logger(LOG_ERROR, MSG_GEOM_ERROR);
      cleanup();
      return 1;
    }
  }
  rawtime1 = MPI_Wtime(); // checkpoint

  /* Prints VRML and VTK files */
  if(modsolinfo->printwrl){
    vrmlout();
  }
  if(modsolinfo->printvtk){
    vtkout_unc();
  }

  if (modsolinfo->pre_calculate_coefs) {
    /* BODY COEFFICIENTS */
    logger(LOG_DEBUG, "Body Coefficient active: %d\n", modcoefacinfo->active);
    logger(LOG_INFO, MSG_COEF_START);
     if (1 != acoustic_body_coefs()) {
       logger(LOG_ERROR, MSG_BODYCOEF_ERROR);
       cleanup();
       return 1;
    }

    //MPI_Barrier(MPI_COMM_WORLD);
    rawtime2 = MPI_Wtime(); // checkpoint

    /* MICS COEFFICIENTS */
    logger(LOG_DEBUG, "Mics Coefficient active: %d\n", modcoemicinfo->active);
    if (1 != acoustic_mics_coefs()) {
        logger(LOG_ERROR, MSG_MICSCOEF_ERROR);
        cleanup();
        return 1;
    }
    rawtime3 = MPI_Wtime(); // checkpoint
  }

  /* SOLUTION */
  logger(LOG_DEBUG, "Solution active: %d\n", modsolinfo->active);
  if (1 == modsolinfo->active) {
    logger(LOG_INFO, MSG_SOLUTION_START);
    acoustic_solution();
    /* Prints VRML files for solution*/
    if(modsolinfo->printwrl){
      vrmlout_sol();
    }
  }

  rawtime4 = MPI_Wtime(); // recording end time

  time(&rundetails->endtime); // recording end time
  rundetails->elapsed = rawtime4 - rawtime0; // setting elapsed
  timebco = 0.0; // setting elapsed
  timemco = 0.0; // setting elapsed
  timesol = rawtime4 - rawtime1; // setting elapsed
  if (modsolinfo->pre_calculate_coefs) {
    timebco = rawtime2 - rawtime1; // setting elapsed
    timemco = rawtime3 - rawtime2; // setting elapsed
    timesol = rawtime4 - rawtime3; // setting elapsed
  }
  logger(LOG_INFO, "total run time=%f seconds\n", rundetails->elapsed);
  // dumping rundetails
  if (rank == 0) {
    strftime(starttime, sizeof(starttime), "%a %Y-%m-%d %H:%M:%S %Z", localtime(&rundetails->starttime));
    strftime(endtime, sizeof(endtime), "%a %Y-%m-%d %H:%M:%S %Z", localtime(&rundetails->endtime));
    logger(LOG_INFO, "---------------------------------\n");
    logger(LOG_INFO, " Run details\n");
    logger(LOG_INFO, "---------------------------------\n");
#ifdef _MYSQL_
    logger(LOG_INFO," mysql id = %d\n",mysqlinfo->runid);
#endif
    logger(LOG_INFO, " title    = %s\n", rundetails->title);
    logger(LOG_INFO, " owner    = %s\n", rundetails->owner);
    logger(LOG_INFO, " cfg path = %s\n", rundetails->cfg_filepath);
    logger(LOG_INFO, " cfg      = %s\n", rundetails->cfg_filename);
    logger(LOG_INFO, " start    = %s\n", starttime);
    logger(LOG_INFO, " end      = %s\n", endtime);
    logger(LOG_INFO, " elapsed  = %f s\n", rundetails->elapsed);
    logger(LOG_INFO, "  for body coefs = %f s\n", timebco);
    logger(LOG_INFO, "  for mics coefs = %f s\n", timemco);
    logger(LOG_INFO, "  for solution   = %f s\n", timesol);
    logger(LOG_INFO, " no. of procs.   = %d\n", rundetails->nnodes);
#ifdef _MYSQL_
    // Storing run on MySQL if enabled.
    if(mysqlinfo->active) {
      mysql_update();
    }
#endif
    logger(LOG_INFO,
        "****************    Job finished    ***************\n");
  }

  cleanup:
  if (onlymemoryout) {
    if (0 == rank) {
      PRINT_MEM("Total Allocated Memory:", TOTAL_MEMORY);
    }
  } else {
    PRINT_MEM("Total Allocated Memory:", TOTAL_MEMORY);
  }
  Cblacs_gridexit(runinfo->ctxt);
  logger(LOG_INFO, "cleanup...\n");
  cleanup(); // cleaning up
  logger(LOG_INFO, MSG_PROGRAM_END);
  MPI_Finalize();
  return 0;
}