cuik.c

Go to the documentation of this file.

#include "cuiksystem.h"
#include "parameters.h"

#include "defines.h"
#include "error.h"
#include "box_list.h"
#include "filename.h"
#include "random.h"

#include <string.h>
#include <stdlib.h>
#include <time.h>

#if (_USE_MPI)
  #include <mpi.h>
  #include <unistd.h>
#endif

int main(int argc, char **arg)
{
  signed int np=1,p=0;     /* The default mode is to run on one processor */

  FILE *f_out;             /* File where the solutions are printed as they 
                              are found */

  FILE *f_state;           /* File from where we try to recover the execution
                              state of cuik (this is used to continue execution
                              after a crash) */

  #if (!_QUIET)
    FILE *f_in;            /* Used to read-and-print the equation input 
                              file in the output file */
  #endif

  Tfilename fcuik;
  Tfilename fparam;
  Tfilename fsols;
  Tfilename fstate;

  TCuikSystem cuiksystem;  /* The set of variables and equations */
  Tparameters parameters;  /* Parameters used in the Cuik process */

  boolean restart;         /* Restart from a state file */

  #if (_USE_MPI)
    unsigned int i;
    unsigned int fileflag_in;
    MPI_Status status;
    char name[MPI_MAX_PROCESSOR_NAME+1];
    signed int len;

    MPI_Init(&argc,&arg);

    /* Set up a new Error handler */
    MPI_Errhandler_set(MPI_COMM_WORLD,MPI_ERRORS_RETURN);

    MPI_Comm_rank(MPI_COMM_WORLD,&p);  /*number of this process*/
    MPI_Comm_size(MPI_COMM_WORLD,&np); /*total number of processes*/
  #endif

  if (argc>1)
    {
      randomReset();

      /*Init parameters*/
      CreateFileName(NULL,arg[1],NULL,PARAM_EXT,&fparam);
      InitParametersFromFile(GetFileFullName(&fparam),&parameters);

      /*Read the problem from file*/
      CreateFileName(NULL,arg[1],NULL,CUIK_EXT,&fcuik);
      InitCuikSystemFromFile(&parameters,GetFileFullName(&fcuik),&cuiksystem);

      /*Check if a state file is available*/
      if (p==0)
        {
          CreateFileName(NULL,arg[1],NULL,STATE_EXT,&fstate);
          f_state=fopen(GetFileFullName(&fstate),"rb");
          if (f_state)
            {
              restart=TRUE;
              fclose(f_state);
            }
          else
            restart=FALSE;
        }
      else
        restart=FALSE;
      

      /*Check if we can create the output file*/
      f_out=stdout; /* the default is stdout for all processes. 
                       Only process 0 has special output file */
      if (p==0)
        {
          CreateFileName(NULL,arg[1],NULL,SOL_EXT,&fsols);
          if (restart)
            f_out=fopen(GetFileFullName(&fsols),"a"); /*append data to an already existing file*/
          else
            f_out=fopen(GetFileFullName(&fsols),"w"); /*start a brand new output file*/

          if (!f_out)
            Error("Could not open main output file");
        }

      #if (!_QUIET)
        /*While the rest of processors read the parameter file, the 
          first processors stores data about the problem to be solved 
          next in the output file*/
        if (p==0)
          {
            if (restart)
              {
                fprintf(f_out,"\n==========================================================================\n");
                fprintf(f_out,"RESTARTING CUIK FROM A PREVIOUS EXECUTION STATE\n");
                fprintf(f_out,"WE ASSUME THAT THE .cuik FILE AND THE .param FILE HAVE NOT CHANGED");
                fprintf(f_out,"\n==========================================================================\n\n");
                fflush(f_out);
              }
            else
              {
                fprintf(f_out,"\n==========================================================================\n");
                PrintParameters(f_out,&parameters);
            
                /*Print the description of the problem to be solved*/
                fprintf(f_out,"\n==========================================================================\n");
                fprintf(f_out,"Equations from file: %s\n",GetFileFullName(&fcuik));
                f_in=fopen(GetFileFullName(&fcuik),"r");
                if (!f_in)
                  Error("Error opening input file");
                else
                  {
                    int c;

                    do { c=fgetc(f_in); if (c!=EOF) fprintf(f_out,"%c",c); } while(c!=EOF);
                    fclose(f_in);
                    fprintf(f_out,"\n"); 
                  }
         
                fprintf(f_out,"\n==========================================================================\n");
                PrintCuikSystemWithSimplification(&parameters,f_out,&cuiksystem);
                fprintf(f_out,"\n==========================================================================\n");
              }
            fflush(f_out);
          }
      #endif

      /* The main processors takes care of writing the solutions as they are 
         found by the slaves */
      if ((p==0)&&(!restart))
        { 
          fprintf(f_out,"SOLUTIONS (to input file %s):\n\n",GetFileFullName(&fcuik)); 
          fflush(f_out);
        }

      if (np<3) /*single cpu execution -> Do not use parallel cuik*/
        {
          if (p==0)
            SolveCuikSystem(&parameters,0,restart,GetFileFullName(&fstate),f_out,NULL,&cuiksystem); 
        }
      #if (_USE_MPI)
      else
        {
          MPI_Get_processor_name(name,&len);

          /*Execution on several cpu: one is the master and the rest are slaves*/
          /*First we wait all the slaves to be ready. We do not want to send out boxes
            if the slaves are not ready to receive them.*/
          if (p==0)
            {
              fprintf(stdout,"Main scheduler running on %s\n",name);
              fprintf(stdout,"Waiting all processes to read the param/cuik files\n"); 
              fflush(stdout);
              
              for(i=1;i<(unsigned int)np;i++)
                {
                  while ((MPI_Recv(&fileflag_in,1,MPI_UNSIGNED,i,50+i,MPI_COMM_WORLD,&status)!=MPI_SUCCESS)&&
                         (fileflag_in!=i));
                  fprintf(stdout,"Ping from process %u received\n",i);
                  fflush(stdout);
                }

              fprintf(stdout,"Starting scheduler\n");
              fflush(stdout); 

              MPI_SolveCuikSystem(&parameters,restart,GetFileFullName(&fstate),f_out,&cuiksystem); /* one master */
            }
          else
            {
              fprintf(stdout,"Starting sub-proces on processor %d running on %s\n",p,name);
              fflush(stdout); 
              /* Send a signal to the scheduler process (process number 0) indicating
                 that sub-process 'p' is ready to process boxes */
              MPI_Ssend(&p,1,MPI_UNSIGNED,0,50+p,MPI_COMM_WORLD);

              MPI_TreatBox(&parameters,&cuiksystem); /* and np-1 slaves */

              printf("Killing sub-process %u\n",p);
              fflush(stdout);
            }
        }
      #endif

      if (p==0) 
        {
          fprintf(f_out,"END OF THE SOLUTION FILE\n\n");
          fclose(f_out);
        }

      /*Delete  the parameters and the graph itself*/
      DeleteParameters(&parameters);
      DeleteCuikSystem(&cuiksystem);
      
      DeleteFileName(&fcuik);
      DeleteFileName(&fparam);

      if (p==0)
        {
          DeleteFileName(&fsols);
 
          /*Remove the last state file generated*/
          remove(GetFileFullName(&fstate));
          DeleteFileName(&fstate);
        }
    }
  else
    {
      if (p==0) /* Only one error message */
        {
          fprintf(stderr,"  Wrong number of parameters.\n");
          fprintf(stderr,"  Use:\n");   
          fprintf(stderr,"      cuik <problem filename>.cuik \n");
          fprintf(stderr,"  where <problem filename> contains the kinematic equations\n");
          fprintf(stderr,"    (the '.cuik' extension is not required)\n");
        }
    }

  #if (_USE_MPI)
    MPI_Finalize();
  #endif

  return(EXIT_SUCCESS);
}