star-phor

sphor_main.c (5542B)

---

 /* Copyright (C) 2024-2026 Centre National de la Recherche Scientifique
  * Copyright (C) 2024-2026 Clermont Auvergne INP
  * Copyright (C) 2024-2026 INSA Lyon
  * Copyright (C) 2024-2026 Institut Mines Télécom Albi-Carmaux
  * Copyright (C) 2024-2026 Institut National Polytechnique de Toulouse
  * Copyright (C) 2024-2026 |Méso|Star> (contact@meso-star.com)
  * Copyright (C) 2024-2026 PhotonLyX (info@photonlyx.com)
  * Copyright (C) 2024-2026 Université de Lorraine
  * Copyright (C) 2024-2026 Université Paul Sabatier
  * Copyright (C) 2024-2026 Université Toulouse - Jean Jaurès
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>. */
 
 #define _POSIX_C_SOURCE 200112L /* for getopt support */
 
 #include "sphor.h"
 
 #include <rsys/cstr.h>
 #include <rsys/mem_allocator.h>
 #include <rsys/rsys.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 struct args {
   int verbose; /* Verbosity level. Bigger values => more verbosity */
   int quit; /* Either stop (1) or continue (0) the execution */
   unsigned nthreads; /* hint: number of threads; defaults to all available
                         threads in the computer */
   size_t samples; /* number of realisations used during the Monte Carlo
                      integrating algorithm */
   char* input_filename; /* May be NULL <=> uses stdin */
   char* output_filename; /* May be NULL <=> uses stdout */
   int force; /* Either force overwriting (1) or return an error (0)
                 if the output file already exists */
 };
 
 #define ARGS_DEFAULT__ {0, 0, UINT_MAX, 10000, NULL, NULL, 0}
 
 static const struct args ARGS_DEFAULT =
   ARGS_DEFAULT__;
 
 static void
 usage(FILE* stream)
 {
   ASSERT(NULL != stream);
   fprintf(stream,
     "Usage: star-phor [-hvf] [-n samples] [-o output] [-t threads] [file]\n");
 }
 
 static res_T
 parse_args
   (struct args* args,
    int argc,
    char** argv)
 {
   unsigned long nreal;
   unsigned int nthreads;
   int opt = 0;
   char* arglist = "hfn:o:t:v";
   res_T res = RES_OK;
 
   ASSERT(NULL != args);
   ASSERT(NULL != argv);
   ASSERT(argc > 0);
 
   *args = ARGS_DEFAULT;
 
   while((opt = getopt(argc, argv, arglist)) != -1) {
     switch(opt) {
       case 'h':
         usage(stdout);
         args->quit = 1;
         break;
       /* Verbosity level */
       case 'v':
         /* Increase the verbosity level counter for each 'v' entered, up to a
          * maximum of 3.  We use the boolean value of (3 > args->verbose): if
          * the condition is true, it evaluates to 1, increasing the counter.
          * Otherwise, it evaluates to 0, leaving the counter unchanged. */
         args->verbose += (3 > args->verbose);
         break;
       /* Output filename */
       case 'o':
         args->output_filename = optarg;
         break;
       /* Force overwrite */
       case 'f':
         args->force = 1;
         break;
       /* Number of samples */
       case 'n':
         res = cstr_to_ulong(optarg, &nreal);
         if (res == RES_OK && nreal == 0) res = RES_BAD_ARG;
         args->samples = (size_t)nreal;
         break;
       /* Number of threads */
       case 't':
         res = cstr_to_uint(optarg, &nthreads);
         if (res == RES_OK && nthreads == 0) res = RES_BAD_ARG;
         args->nthreads = nthreads;
         break;
       default:
         res = RES_BAD_ARG;
         break;
     }
     if (RES_OK != res) {
       if (NULL != optarg) {
         fprintf(stderr, "Invalid option argument: %s -- %c\n", optarg, opt);
       }
       goto error;
     }
   }
 
   /* optind is a global variable that indexes the next argv to be processed */
   if (optind < argc) { /* True if not all the args have been processed */
     args->input_filename = argv[optind];
   }
 
 exit:
   return res;
 error:
   usage(stderr);
   goto exit;
 }
 
 int
 main (int argc, char** argv)
 {
   struct sphor* sphor = NULL;
   struct args args = ARGS_DEFAULT;
   struct sphor_create_args sphor_create_args = SPHOR_CREATE_ARGS_DEFAULT;
   size_t sz = 0;
   int err = EXIT_SUCCESS;
   res_T res = RES_OK;
 
   /* Process command line args */
   res = parse_args(&args, argc, argv);
   if (RES_OK != res) { goto error; }
   if (0 != args.quit) { goto exit; }
 
   /* Create sphor struct */
   sphor_create_args.verbose = args.verbose;
   sphor_create_args.samples = args.samples;
   sphor_create_args.nthreads = args.nthreads;
   sphor_create_args.force = args.force;
   sphor_create_args.input_filename = args.input_filename;
   sphor_create_args.output_filename = args.output_filename;
 
   res = sphor_create(&sphor_create_args, &sphor);
   if (RES_OK != res) { goto error; }
 
   /* Run simulation */
   res = sphor_run(sphor);
   if (RES_OK != res) { goto error; }
 
 exit:
   if (NULL != sphor) { SPHOR(ref_put(sphor)); }
   sz = mem_allocated_size();
   if (sz != 0) {
     char buffer[64] = {0}; /* Initialize all fields to 0 */
     size_to_cstr(sz, SIZE_ALL, NULL, buffer, sizeof(buffer));
     fprintf(stderr, "Memory leaks: %s\n", buffer);
     err = EXIT_FAILURE;
   }
   return err;
 error:
   err = EXIT_FAILURE;
   goto exit;
 }