Chacox.h File Reference

#include <stdio.h>
#include <string.h>
#include "../../classes/classes.h"

Go to the source code of this file.

Macros
#define	__FUNCT__   "Chacox"

Functions
int	Chacox (int nvtxs, int *start, int *adjacency, int *vwgts, float *ewgts, float *x, float *y, float *z, short *assignment, double options[10], int *nparts, double *goal)
int	input_parse (char *outassignname, char *outfilename, int *architecture, int *ndims_tot, int mesh_dims[3], int *global_method, int *local_method, int *rqi_flag, int *vmax, int *ndims, int *nprocs, double options[10], int *nparts)
double	chaco_seconds (void)

Macro Definition Documentation

__FUNCT__

#define __FUNCT__   "Chacox"

Definition at line 43 of file Chacox.h.

Function Documentation

Chacox()

int Chacox	(	int	nvtxs,
		int *	start,
		int *	adjacency,
		int *	vwgts,
		float *	ewgts,
		float *	x,
		float *	y,
		float *	z,
		short *	assignment,
		double	options[10],
		int *	nparts,
		double *	goal
	)

Definition at line 7 of file Chacox.cpp.

{
   #ifdef _HAVE_CHACO_ //only works if Chaco library has been compiled in.
 
   extern int     Using_Main;                   /* is main routine being called?                */
   extern char   *PARAMS_FILENAME;              /* name of file with parameter updates          */
   extern double  EIGEN_TOLERANCE;              /* tolerance for eigen calculations             */
   extern int     OUTPUT_ASSIGN;                /* whether to write assignment to file          */
   extern int     DEBUG_MEMORY;                 /* debug memory allocation and freeing?         */
   extern int     DEBUG_TRACE;                  /* trace main execution path                    */
   extern int     DEBUG_PARAMS;                 /* debug flag for reading parameters            */
   extern long    RANDOM_SEED;                  /* seed for random number generators            */
   extern int     ECHO;                         /* controls amount of output                    */
   extern int     PROMPT;                       /* prompt for input or not?                     */
   extern int     PRINT_HEADERS;                /* print lines for output sections?             */
   extern int     MATCH_TYPE;                   /* matching routine to call                     */
   extern double  input_time;                   /* times data file input                        */
   extern double  start_time;                   /* time partitioning starts                     */
   FILE          *params_file;                  /* file with parameter value updates            */
   int            global_method;                /* global partitioning method                   */
   int            local_method;                 /* local partitioning method                    */
   double         eigtol;                       /* tolerance in eigenvector calculation         */
   int            ndims;                        /* dimension of recursive partitioning          */
   int            architecture;                 /* 0 => hypercube, d => d-dimensional mesh      */
   int            ndims_tot;                    /* total number of cube dimensions to divide    */
   int            mesh_dims[3];                 /* dimensions of mesh of processors             */
   long           seed;                         /* for random graph mutations                   */
   int            rqi_flag;                     /* use RQI/Symmlq eigensolver?                  */
   int            vmax;                         /* if so, how many vertices to coarsen down to? */
   char           outassignname[NAME_LENGTH];   /* assignment output file name                  */
   char           outfilename[NAME_LENGTH];     /* name of output file                          */
   char          *outassignptr;                 /* name or null pointer for output assignment   */
   char          *outfileptr;                   /* name or null pointer for output file         */
   int            nprocs;                       /* number of processors being divided into      */
   double         time;                         /* timing marker                                */
   int            flag;                         /* return code from input routines              */
   double        *smalloc();                    /* safe version of malloc                       */
   //double       seconds();                    /* returns elapsed time in seconds              */
   /*int sfree(), interface(), affirm();
   void input_queries()  , smalloc_stats(), read_params(), clear_timing();  */
 
   int i,tvwgt;
   double tgoal;
 
   if (DEBUG_TRACE > 0) {
      _printf_("<Entering main>\n");
   }
 
   if (PRINT_HEADERS) {
      _printf_("\n                    Chaco 2.0\n");
      _printf_("          Sandia National Laboratories\n\n");
   }
 
   Using_Main = TRUE;
   params_file = fopen(PARAMS_FILENAME, "r");
   if (params_file == NULL && DEBUG_PARAMS > 1) {
      printf("Parameter file `%s' not found; using default parameters.\n",PARAMS_FILENAME);
   }
 
   start_time = time = chaco_seconds();
 
   read_params(params_file);
 
   flag = input_parse(outassignname, outfilename,
           &architecture, &ndims_tot, mesh_dims,
           &global_method, &local_method, &rqi_flag, &vmax, &ndims, &nprocs,
           options, nparts);
   if (flag)
      return(flag);
 
   if (OUTPUT_ASSIGN > 0)
      outassignptr = outassignname;
   else
      outassignptr = NULL;
 
   if (ECHO < 0)
      outfileptr = outfilename;
   else
      outfileptr = NULL;
 
   if ((int)options[OPT_VWGTS] && vwgts) {
      printf("%s -- Applying weights for %d vertices.\n",__FUNCT__,nvtxs);
      tvwgt = 0;
      for (i=0; i<nvtxs; i++)
         tvwgt += vwgts[i];
   }
   else {
      tvwgt = nvtxs;
      if      ( (int)options[OPT_VWGTS] && !vwgts)
         printf("%s -- Vertex weight flag=%d, but no vertex weights specified.\n",__FUNCT__,(int)options[OPT_VWGTS]);
      else if (!(int)options[OPT_VWGTS] &&  vwgts)
         printf("%s -- Vertex weight flag=%d, so specified vertex weights ignored.\n",__FUNCT__,(int)options[OPT_VWGTS]);
   }
 
   if ((int)options[OPT_EWGTS] && ewgts) {
      printf("%s -- Applying weights for %d edges.\n",
            __FUNCT__,start[nvtxs]/2);
   }
   else {
      if      ( (int)options[OPT_EWGTS] && !ewgts)
         printf("%s -- Edge weight flag=%d, but no edge weights specified.\n",__FUNCT__,(int)options[OPT_EWGTS]);
      else if (!(int)options[OPT_EWGTS] &&  ewgts)
         printf("%s -- Edge weight flag=%d, so specified edge weights ignored.\n",__FUNCT__,(int)options[OPT_EWGTS]);
   }
 
    if (goal) {
        printf("%s -- Applying goals for %d sets.\n",
               __FUNCT__,nprocs);
        tgoal = 0.;
        for (i=0; i<nprocs; i++)
            tgoal += goal[i];
        for (i=0; i<nprocs; i++)
            goal[i] *= (double)tvwgt/tgoal;
    }
 
   input_time += chaco_seconds() - time;
 
   if (options[OPT_EIGTOL] > 0)
      eigtol = options[OPT_EIGTOL];
   else
      eigtol = EIGEN_TOLERANCE;
   if ((int)options[OPT_SEED] > 0)
      seed = (int)options[OPT_SEED];
   else
      seed = RANDOM_SEED;
 
/*  Chaco numbers vertices from 1 and the Matlab sparse data structure
   numbers rows from 0, so increment the row indices for each column. */
 
   for (i=0; i<start[nvtxs]; adjacency[i++]++);
 
   printf("\n%s -- Calling Chaco interface:\n\n",__FUNCT__);
   flag = interface(nvtxs, start, adjacency,
        ((int)options[OPT_VWGTS] && vwgts ? vwgts : NULL),
        ((int)options[OPT_EWGTS] && ewgts ? ewgts : NULL),
        x, y, z,
        outassignptr, outfileptr,
        assignment,
        architecture, ndims_tot, mesh_dims, goal,
        global_method, local_method, rqi_flag, vmax, ndims,
        eigtol, seed);
   printf("\n%s -- Chaco interface returning flag=%d.\n",__FUNCT__,flag);
 
/*  Reset adjacency matrix in case calling function needs it.  */
 
   for (i=0; i<start[nvtxs]; adjacency[i++]--);
 
   if (DEBUG_MEMORY > 0) {
      _printf_("\n");
      smalloc_stats();
   }
 
   if (params_file != NULL)
      fclose(params_file);
 
   if (DEBUG_TRACE > 1) {
      _printf_("<Leaving main>\n");
   }
 
   return(0);
 
   #else //ifdef _HAVE_CHACO_
   return (0);
   #endif
}

input_parse()

int input_parse	(	char *	outassignname,
		char *	outfilename,
		int *	architecture,
		int *	ndims_tot,
		int	mesh_dims[3],
		int *	global_method,
		int *	local_method,
		int *	rqi_flag,
		int *	vmax,
		int *	ndims,
		int *	nprocs,
		double	options[10],
		int *	nparts
	)

Definition at line 10 of file input_parse.cpp.

{
 
   #ifdef _HAVE_CHACO_ //only works if Chaco library has been compiled in.
 
   extern int SEQUENCE; /* sequence instead of partition graph? */
   extern int ARCHITECTURE;   /* 0=> hypercube, d=> d-dimensional mesh */
   extern int OUTPUT_ASSIGN;  /* write assignments to file? */
   extern int ECHO;     /* copy input to screen? results to file? */
   extern int DEBUG_TRACE; /* trace main execution path */
   extern int PROMPT;      /* prompt for input? */
   extern int MATCH_TYPE;      /* max-matching routine to call */
   int       eigensolver;  /* which kind of eigensolver to use */
 
   if (DEBUG_TRACE > 0) {
      _printf_("<Entering input_parse>\n");
   }
 
   if (PROMPT) {
      _printf_("Parallel machine architecture:\n");
      _printf_("  (0) Hypercube\n");
      _printf_("  (1) One-dimensional mesh\n");
      _printf_("  (2) Two-dimensional mesh\n");
      _printf_("  (3) Three-dimensional mesh\n");
   }
   *architecture = (int)options[OPT_ARCH];
   if (*architecture < 0 || *architecture > 3) {
      printf("%s -- Architecture %d must be between 0 and 3.\n",__FUNCT__,*architecture);
      return(-1);
   }
 
   /* Name output assignment file. */
   if (PROMPT)
      _printf_("Assignment output file: ");
   outassignname = NULL;
 
   /* Name output results file. */
   if (PROMPT)
      _printf_("File name for saving run results: ");
   outfilename = NULL;
 
   /* Initialize the method flags */
   *rqi_flag = 0;
   *global_method = 0;
 
   /* Get global method, if any. */
   if (SEQUENCE) {
      *global_method = 2;
   }
   else {
      if (PROMPT) {
         _printf_("Global partitioning method:\n");
         _printf_("  (1) Multilevel-KL\n");
         _printf_("  (2) Spectral\n");
         _printf_("  (3) Inertial\n");
         _printf_("  (4) Linear\n");
         _printf_("  (5) Random\n");
         _printf_("  (6) Scattered\n");
         _printf_("  (7) Read-from-file\n");
      }
      *global_method = (int)options[OPT_GLOBAL];
      if (*global_method < 1 || *global_method > 7) {
         printf("%s -- Global method %d must be between 1 and 7.\n",__FUNCT__,*global_method);
         return(-1);
      }
   }
 
   if (*global_method == 7) { /* Name and open input assignment file. */
      if (PROMPT)
         _printf_("Assignment input file: ");
   }
 
   else if (*global_method == 3) {
      if (PROMPT)
         _printf_("Geometry input file name: ");
   }
 
   else if (*global_method == 2) {
      if (PROMPT) {
         _printf_("Eigensolver:\n");
         _printf_("  (1) Multilevel RQI/Symmlq\n");
         _printf_("  (2) Lanczos\n"); 
      }
      eigensolver = (int)options[OPT_RQI];
      if (eigensolver < 0 || eigensolver > 2) {
         printf("%s -- RQI/Symmlq flag %d must be between 0 and 2.\n",__FUNCT__,eigensolver);
         return(-1);
      }
      if (eigensolver == 1) {
         if (MATCH_TYPE == 5) {  /* geometric matching */
            if (PROMPT)
               _printf_("Geometry input file name: ");
         }
         *rqi_flag = 1;
         if (PROMPT)
            _printf_("Number of vertices to coarsen down to: ");
         *vmax = (int)options[OPT_VMAX];
         if (*vmax <= 0) {
            printf("%s -- Vmax %d must be greater then 0.\n",__FUNCT__,*vmax);
            return(-1);
         }
      }
      else if (eigensolver == 0 || eigensolver == 2) {
         *rqi_flag = 0;
      }
   }
 
   else if (*global_method == 1) {
      if (MATCH_TYPE == 5) {     /* geometric matching */
         if (PROMPT)
            _printf_("Geometry input file name: ");
      }
      if (PROMPT)
         _printf_("Number of vertices to coarsen down to: ");
      *vmax = (int)options[OPT_VMAX];
      if (*vmax <= 0) {
         printf("%s -- Vmax %d must be greater then 0.\n",__FUNCT__,*vmax);
         return(-1);
      }
   }
 
   if (SEQUENCE) {
      *local_method = 2;
      if (*architecture == 0) {
         *ndims_tot = 1;
      }
      else if (*architecture > 0) {
         mesh_dims[0] = 2;
         mesh_dims[1] = mesh_dims[2] = 1;
      }
      *ndims = 1;
      goto End_Label;
   }
 
   /* Get local method, if any */
   *local_method = 0;
   if (*global_method == 1)
      *local_method = 1;
   else {
      if (PROMPT) {
         _printf_("Local refinement method:\n");
         _printf_("  (1) Kernighan-Lin\n");
         _printf_("  (2) None\n");
      }
      *local_method = (int)options[OPT_LOCAL];
      if (*local_method < 1 || *local_method > 2) {
         printf("%s -- Local method %d must be 1 and 2.\n",__FUNCT__,*local_method);
         return(-1);
      }
   }
 
   /* Now learn about the parallel architecture. */
   if (*architecture == 0) {
   /* Get total number of hypercube dimensions in which to partition. */
      *ndims_tot = 0;
      if (PROMPT)
         _printf_("Total number of target hypercube dimensions: ");
      *ndims_tot = nparts[0];
      if (*ndims_tot < 1) {
         _printf_(" Number of divisions must be at least 1\n");
         printf("%s -- Number of divisions %d must be at least 1.\n",
               __FUNCT__,nparts[0]);
         return(-1);
      }
      *nprocs = 1 << (*ndims_tot);
   }
 
   else {         /* Get dimensions of mesh. */
      mesh_dims[1] = mesh_dims[2] = 1;
      if (*architecture == 2) {
         if (PROMPT)
            _printf_("X and Y extent of of 2-D mesh: ");
         mesh_dims[0] = nparts[0];
         mesh_dims[1] = nparts[1];
      }
      else if (*architecture == 3) {
         if (PROMPT)
            _printf_("X, Y and Z extent of 3-D mesh: ");
         mesh_dims[0] = nparts[0];
         mesh_dims[1] = nparts[1];
         mesh_dims[2] = nparts[2];
      }
      else {         /* Anything else => 1-D mesh */
         if (PROMPT)
            _printf_("Size of 1-D mesh: ");
         mesh_dims[0] = nparts[0];
         *architecture = 1;
      }
      *nprocs = mesh_dims[0] * mesh_dims[1] * mesh_dims[2];
   }
 
   /* Get number of dimensions in which to partition at each level. */
   *ndims = 0;
   if (*nprocs <= 3) {
      *ndims = 1;
   }
   else if (*nprocs <= 7) {
      if (PROMPT) {
         _printf_("Partitioning dimension: \n");
         _printf_("  (1) Bisection\n");
         _printf_("  (2) Quadrisection\n");
      }
      *ndims = (int)options[OPT_NDIMS];
      if (*ndims < 1 || *ndims > 2) {
         printf("%s -- Ndims %d must be 1 or 2 for %d processors.\n",__FUNCT__,*ndims,*nprocs);
         return(-1);
      }
   }
   else {
      if (PROMPT) {
         _printf_("Partitioning dimension: \n");
         _printf_("  (1) Bisection\n");
         _printf_("  (2) Quadrisection\n");
         _printf_("  (3) Octasection\n");
      }
      *ndims = (int)options[OPT_NDIMS];
      if (*ndims < 1 || *ndims > 3) {
         printf("%s -- Ndims %d must be between 1 and 3 for %d processors.\n",__FUNCT__,*ndims,*nprocs);
         return(-1);
      }
   }
End_Label: 
 
   if (*global_method == 1 || *rqi_flag) {
      if (*vmax < 2 * (1 << *ndims)) {
         *vmax = 2 * (1 << *ndims);
      }
   }
 
   return(0);
 
   #else //#ifdef _HAVE_CHACO_ 
   return(0);
   #endif
}

chaco_seconds()

double chaco_seconds

(

void

)

Definition at line 10 of file chaco_seconds.cpp.

                          {
 
   double    curtime;
 
#ifdef RUSAGE_SELF
 
/* This timer is faster and more robust (if it exists). */
    struct rusage rusage;
    /*int getrusage(); commenting this out. not sure why it's there anymore
    *as it clobbers the prototype int getrusag(int target,rusage* results) which 
    *is defined in the <sys/time.h> and <sys/resource.h> header files. Leaving it 
    *for reference in case we have a problem here in the future*/
 
    getrusage(RUSAGE_SELF, &rusage);
    curtime = ((rusage.ru_utime.tv_sec + rusage.ru_stime.tv_sec) +
       1.0e-6 * (rusage.ru_utime.tv_usec + rusage.ru_stime.tv_usec));
 
#else
 
/* ANSI timer, but lower resolution & wraps around after ~36 minutes. */
 
    curtime = clock()/((double) CLOCKS_PER_SEC);
 
#endif
 
    return (curtime);
}