parameters.c

/*
**  Probabilistic latent semantic analysis (PLSA, multiprocessor version)
**  Copyright (C) 2009-2010  by Raymond Wan (r.wan@aist.go.jp)
**
**  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 _GNU_SOURCE
#include <getopt.h>

#include <stdlib.h>
#include <stdio.h>
#include <limits.h>                                  /*  UINT_MAX  */
#include <string.h>
#include <stdbool.h>

#include "PLSA_MP_Config.h"
#if HAVE_MPI
#include <mpi.h>
#endif

#if HAVE_OPENMP
#include <omp.h>
#endif

#include "wmalloc.h"
#include "plsa-defn.h"
#include "parameters.h"

/*!  Print out usage information  */
void usage (char *progname) {
  fprintf (stderr, "Probabilistic Latent Semantic Analysis (multiprocessor)\n");
  fprintf (stderr, "=======================================================\n\n");
  fprintf (stderr, "Usage:  %s [options]\n\n", progname);
  fprintf (stderr, "Options:\n");
  fprintf (stderr, "--base <file>      :  Base filename for output file.\n");
  fprintf (stderr, "--cooccur <file>   :  Co-occurrence filename.\n");
  fprintf (stderr, "--clusters <int>   :  Number of clusters.\n");
  fprintf (stderr, "--seed <int>       :  Random seed.\n");
  fprintf (stderr, "                   :    (Default:  current time).\n");
  fprintf (stderr, "--maxiter <int>    :  Maximum iterations.\n");
  fprintf (stderr, "--text             :  Text mode (I/O is in text, not binary).\n");
  fprintf (stderr, "--snapshot <int>   :  Output snapshots p(x,y) at regular intervals.\n");
  fprintf (stderr, "                   :    (Default:  Do not output).\n");
  fprintf (stderr, "--openmp <int>     :  Number of OpenMP threads to use.\n");
  fprintf (stderr, "                   :    (Default:  Maximum for PC).\n");
  fprintf (stderr, "--verbose          :  Verbose mode.\n");
  fprintf (stderr, "--debug            :  Debugging output.\n");
  fprintf (stderr, "--rounding         :  Round using %u as the multiplication factor.\n", ROUND_DIGITS);
  fprintf (stderr, "--nooutput         :  Suppress outputting p(x,y) to file.\n");

  fprintf (stderr, "\nCompile-time settings:\n  ");
  fprintf (stderr, "     MPI:                              ");
#if HAVE_MPI
  fprintf (stderr, "Enabled\n");
#else
  fprintf (stderr, "Disabled\n");
#endif
  fprintf (stderr, "    OpenMP:                              ");
#if HAVE_OPENMP
  fprintf (stderr, "Enabled\n");
#else
  fprintf (stderr, "Disabled\n");
#endif

  fprintf (stderr, "\nPLSA version:  %s (%s)\n\n", __DATE__, __TIME__);

  exit (EXIT_SUCCESS);
}


bool checkSettings (INFO *info) {
  if (info -> co_fn == NULL) {
    fprintf (stderr, "==\tError:  Co-occurrence filename required with the --cooccur option.\n");
    return false;
  }

  if (info -> maxiter == 0) {
    fprintf (stderr, "==\tError:  Maximum number of iterations required with the --maxiter option.\n");
    return false;
  }

  if (info -> num_clusters == 0) {
    fprintf (stderr, "==\tError:  Number of clusters required with the --clusters option.\n");
    return false;
  }

  if (info -> num_clusters >= MAX_CLUSTERS) {
    fprintf (stderr, "==\tError:  The maximum number of clusters is %u because of the MPI message tag lengths.  Please change MAX_CLUSTERS in plsa-defn.h and re-compile.\n", MAX_CLUSTERS);
    return false;
  }

  if (info -> base_fn == NULL) {
    fprintf (stderr, "==\tError:  Base filename required with the --base option.\n");
    return false;
  }

  if (info -> world_size > info -> num_clusters) {
    fprintf (stderr, "==\tWarning:  The number of processors is more than the number of clusters.  Increasing the number of clusters.");
    info -> num_clusters = info -> world_size;
  }

  if (info -> verbose) {
    if (info -> world_id == MAINPROC) {
      fprintf (stderr, "Settings\n");
      fprintf (stderr, "--------\n");
      fprintf (stderr, "==\tBase filename:                                  %s\n", info -> base_fn);
      fprintf (stderr, "==\tCo-occurrence filename:                         %s\n", info -> co_fn);
      fprintf (stderr, "==\tProbability data type:                          ");
      if (sizeof (PROBNODE) == 4) {
        fprintf (stderr, "float\n");
      }
      else if (sizeof (PROBNODE) == 8) {
        fprintf (stderr, "double\n");
      }
      else {
        fprintf (stderr, "Unknown!\n");
      }
      fprintf (stderr, "==\tClusters:                                       %u\n", info -> num_clusters);
      if (info -> seed != UINT_MAX) {
        fprintf (stderr, "==\tRandom seed:                                    %u\n", info -> seed);
      }
      else {
        fprintf (stderr, "==\tRandom seed:                                    [from time]\n");
      }
      fprintf (stderr, "==\tExponent difference [utils.h::addLogsFloat]:    %.8f\n", LN_LIMIT);
      fprintf (stderr, "==\tTermination conditions\n");
      fprintf (stderr, "==\t  Maximum EM iterations:                        %u\n", info -> maxiter);
      fprintf (stderr, "==\t  Percentage difference:                        %f\n", ML_DELTA);
      fprintf (stderr, "==\tText mode:                                      %s\n", (info -> textio) ? "yes" : "no");
      fprintf (stderr, "==\tRounding:                                       %s\n", (info -> rounding) ? "yes" : "no");
      if (info -> rounding) {
        fprintf (stderr, "==\tRounding factor:                                %u\n", ROUND_DIGITS);
      }
      fprintf (stderr, "==\tSuppress output to file:                        %s\n", (info -> no_output) ? "yes" : "no");
    }
#if HAVE_MPI
    fprintf (stderr, "==\tMPI:                                            OK\n");
    fprintf (stderr, "==\t  My ID:                                        %d\n", info -> world_id);
    fprintf (stderr, "==\t  Number of processes:                          %d\n", info -> world_size);
    fprintf (stderr, "==\t  Block range:                                  %u - %u\n", info -> block_start, info -> block_end);
    fprintf (stderr, "==\t  Block size:                                   %u\n", info -> block_size);
#else
    fprintf (stderr, "==\tMPI information:                                Not enabled\n");
#endif
#if HAVE_OPENMP
    fprintf (stderr, "==\tOpen MP:                                        OK\n");
    fprintf (stderr, "==\t  Number of threads:                            %u\n", info -> threads);
#else
    fprintf (stderr, "==\tOpen MP:                                        Not enabled\n");
#endif
    fprintf (stderr, "\n\n");
  }

  return true;
}


bool processOptions (int argc, char *argv[], INFO *info) {
  int c = 0;

  char *base_fn = NULL;
  char *co_fn = NULL;
  unsigned int num_clusters = 0;
  unsigned int seed = UINT_MAX;
  unsigned int maxiter = 0;
  unsigned int snapshot = UINT_MAX;
  bool verbose = false;
  bool debug = false;
  bool textio = false;
  bool rounding = false;
  bool no_output = false;

  /*  Usage information if no arguments  */
  if (argc == 1) {
    usage (argv[0]);
  }

  while (1) {
    int option_index = 0;
    static struct option long_options[] = {
      {"base", 1, 0, 0},
      {"cooccur", 1, 0, 0},
      {"clusters", 1, 0, 0},
      {"seed", 1, 0, 0},
      {"maxiter", 1, 0, 0},
      {"snapshot", 1, 0, 0},
      {"openmp", 1, 0, 0},
      {"verbose", 0, 0, 0},
      {"debug", 0, 0, 0},
      {"text", 0, 0, 0},
      {"rounding", 0, 0, 0},
      {"nooutput", 0, 0, 0},
      {0, 0, 0, 0}
    };

    c = getopt_long (argc, argv, "", long_options, &option_index);
    if (c == -1) {
      break;
    }

    switch (c) {
      case 0:
        if (strcmp (long_options[option_index].name, "cooccur") == 0) {
          co_fn = wmalloc (strlen (optarg) + 1);
          co_fn = strcpy (co_fn, optarg);
        }
        else if (strcmp (long_options[option_index].name, "clusters") == 0) {
          num_clusters = atoi (optarg);
        }
        else if (strcmp (long_options[option_index].name, "seed") == 0) {
          seed = atoi (optarg);
        }
        else if (strcmp (long_options[option_index].name, "base") == 0) {
          base_fn = wmalloc (strlen (optarg) + 1);
          base_fn = strcpy (base_fn, optarg);
        }
        else if (strcmp (long_options[option_index].name, "maxiter") == 0) {
          maxiter = atoi (optarg);
        }
        else if (strcmp (long_options[option_index].name, "snapshot") == 0) {
          snapshot = atoi (optarg);
        }
        else if (strcmp (long_options[option_index].name, "openmp") == 0) {
#if HAVE_OPENMP
          /*  Check the previously set value, which is the maximum for the system  */
          if (atoi (optarg) > info -> threads) {
            fprintf (stderr, "==\tError:  The number of threads requested exceeds the number available in the system (%u).\n", info -> threads);
            exit (-1);
          }
          info -> threads = atoi (optarg);
          omp_set_num_threads (info -> threads);
#else
          fprintf (stderr, "==\tError:  OpenMP is not enabled; --openmp meaningless.\n");
          exit (-1);
#endif
        }
        else if (strcmp (long_options[option_index].name, "verbose") == 0) {
          verbose = true;
        }
        else if (strcmp (long_options[option_index].name, "debug") == 0) {
          debug = true;
        }
        else if (strcmp (long_options[option_index].name, "text") == 0) {
          textio = true;
        }
        else if (strcmp (long_options[option_index].name, "rounding") == 0) {
          rounding = true;
        }
        else if (strcmp (long_options[option_index].name, "nooutput") == 0) {
          no_output = true;
        }
        break;
      default:
        printf ("?? getopt returned character code 0%o ??\n", c);
        exit (EXIT_FAILURE);
    }
  }

  info -> base_fn = base_fn;
  info -> co_fn = co_fn;
  info -> num_clusters = num_clusters;
  info -> seed = seed;
  info -> maxiter = maxiter;
  info -> snapshot = snapshot;
  info -> verbose = verbose;
  info -> debug = debug;
  info -> textio = textio;
  info -> rounding = rounding;
  info -> no_output = no_output;

  /*  Set the range of clusters this process will handle  */
  info -> block_start = BLOCK_LOW (info ->  world_id, info -> world_size, info -> num_clusters);
  info -> block_end = BLOCK_HIGH (info ->  world_id, info -> world_size, info -> num_clusters);
  info -> block_size = BLOCK_SIZE (info ->  world_id, info -> world_size, info -> num_clusters);

  return true;
}