New additions:
- tst_ library code.
- new quickhit tests
- more general code cleanup
diff --git a/lib/parse_opts.c b/lib/parse_opts.c
new file mode 100644
index 0000000..af5e6dd
--- /dev/null
+++ b/lib/parse_opts.c
@@ -0,0 +1,1206 @@
+/*
+ * Copyright (c) 2000 Silicon Graphics, Inc. All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * Further, this software is distributed without any warranty that it is
+ * free of the rightful claim of any third person regarding infringement
+ * or the like. Any license provided herein, whether implied or
+ * otherwise, applies only to this software file. Patent licenses, if
+ * any, provided herein do not apply to combinations of this program with
+ * other software, or any other product whatsoever.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write the Free Software Foundation, Inc., 59
+ * Temple Place - Suite 330, Boston MA 02111-1307, USA.
+ *
+ * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
+ * Mountain View, CA 94043, or:
+ *
+ * http://www.sgi.com
+ *
+ * For further information regarding this notice, see:
+ *
+ * http://oss.sgi.com/projects/GenInfo/NoticeExplan/
+ */
+
+/* $Id: parse_opts.c,v 1.1 2000/07/27 17:13:18 alaffin Exp $ */
+
+/**********************************************************
+ *
+ * OS Testing - Silicon Graphics, Inc.
+ *
+ * FUNCTION NAME : parse_opts
+ *
+ * FUNCTION TITLE : parse standard & user options for system call tests
+ *
+ * SYNOPSIS:
+ * #include "usctest.h"
+ *
+ * char *parse_opts(ac, av, user_optarr)
+ * int ac;
+ * char **av;
+ * option_t user_optarr[];
+ *
+ * AUTHOR : William Roske/Richard Logan
+ *
+ * INITIAL RELEASE : UNICOS 7.0
+ *
+ * DESCRIPTION
+ * The parse_opts library routine takes that argc and argv parameters
+ * recevied by main() and an array of structures defining user options.
+ * It parses the command line setting flag and argument locations
+ * associated with the options. It uses mc_getoptv to do the actual
+ * cmd line parsing.
+ *
+ * This module contains the functions usc_global_setup_hook and
+ * usc_test_looping, which are called by marcos defined in usctest.h.
+ *
+ * RETURN VALUE
+ * parse_opts returns a pointer to an error message if an error occurs.
+ * This pointer is (char *)NULL if parsing is successful.
+ *
+ *#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#**/
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/signal.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+
+#ifdef _CRAYMPP
+#include <mpp/shmem.h>
+#endif /* _CRAYMPP */
+
+#if UNIT_TEST
+#include <time.h>
+#endif /* UNIT_TEST */
+
+#include "test.h"
+#define _USC_LIB_ 1 /* indicates we are the library to the usctest.h include */
+#include "usctest.h"
+#include "mc_getopt.h"
+
+#ifndef USC_COPIES
+#define USC_COPIES "USC_COPIES"
+#endif
+
+#ifndef UNIT_TEST
+#define UNIT_TEST 0
+#endif
+
+#ifndef DEBUG
+#define DEBUG 0
+#endif
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+extern int errno;
+
+/* The timing information block. */
+struct tblock tblock={0,((long) -1)>>1,0,0};
+
+/* temp variable to store old signal action to be restored after pause */
+int (*_TMP_FUNC)(void);
+
+/* Define flags and args for standard options */
+int STD_FUNCTIONAL_TEST=1, /* flag indicating to do functional testing code */
+ STD_TIMING_ON=0, /* flag indicating to print timing stats */
+ STD_PAUSE=0, /* flag indicating to pause before actual start, */
+ /* for contention mode */
+ STD_INFINITE=0, /* flag indciating to loop forever */
+ STD_LOOP_COUNT=1, /* number of iterations */
+ STD_COPIES=1, /* number of copies */
+ STD_ERRNO_LOG=0; /* flag indicating to do errno logging */
+
+float STD_LOOP_DURATION=0.0, /* duration value in fractional seconds */
+ STD_LOOP_DELAY=0.0; /* loop delay value in fractional seconds */
+
+
+char **STD_opt_arr = NULL; /* array of option strings */
+int STD_nopts=0, /* number of elements in STD_opt_arr */
+ STD_argind=1; /* argv index to next argv element */
+ /* (first argument) */
+ /* To getopt users, it is like optind */
+
+/*
+ * The following variables are to support system testing additions.
+ */
+static int STD_TP_barrier=0; /* flag to do barrier in TEST_PAUSE */
+ /* 2 - wait_barrier(), 3 - set_barrier(), * - barrier() */
+static int STD_LP_barrier=0; /* flag to do barrier in TEST_LOOPING */
+ /* 2 - wait_barrier(), 3 - set_barrier(), * - barrier() */
+static int STD_TP_shmem_sz=0; /* shmalloc this many words per pe in TEST_PAUSE */
+static int STD_LD_shmem=0; /* flag to do shmem_puts and shmem_gets during delay */
+static int STD_LP_shmem=0; /* flag to do shmem_puts and gets during TEST_LOOPING */
+static int STD_LD_recfun=0; /* do recressive function calls in loop delay */
+static int STD_LP_recfun=0; /* do recressive function calls in TEST_LOOPING */
+static int STD_TP_sbrk=0; /* do sbrk in TEST_PAUSE */
+static int STD_LP_sbrk=0; /* do sbrk in TEST_LOOPING */
+static char *STD_start_break=0; /* original sbrk size */
+#ifdef _CRAYMPP
+static long *STD_shmem=NULL; /* array of shmalloc space */
+static int MyPE=-1, Npe=-1; /* */
+#endif
+static int Debug=0;
+
+/*
+ * Structure for usc_recressive_func argument
+ */
+struct usc_bigstack_t {
+ char space[4096];
+};
+
+static struct usc_bigstack_t *STD_bigstack=NULL;
+
+static int add_option(char *option, char **opt_arr[], int *nopts);
+static int rm_option(char *option, char **opt_arr[], int *nopts);
+
+
+/*
+ * Counter of errnos returned (-e option). Indexed by errno.
+ * Make the array USC_MAX_ERRNO long. That is the first Fortran
+ * Lib errno. No syscall should return an errno that high.
+ */
+int STD_ERRNO_LIST[USC_MAX_ERRNO];
+
+/* define the string length for Mesg and Mesg2 strings */
+#define STRLEN 2048
+
+static char Mesg[STRLEN]; /* holds possible return string */
+static char Mesg2[STRLEN]; /* holds possible return string */
+static void usc_recressive_func();
+
+/*
+ * Define bits for options that might have env variable default
+ */
+#define OPT_iteration 01
+#define OPT_nofunccheck 02
+#define OPT_duration 04
+#define OPT_delay 010
+#define OPT_copies 020
+
+
+/**********************************************************************
+ * parse_opts:
+ **********************************************************************/
+char *
+parse_opts(int ac, char **av, option_t *user_optarr)
+{
+ int found; /* flag to indicate that an option specified was */
+ /* found in the user's list */
+ char chr; /* used in converting option arguments */
+ int k; /* scratch integer for returns and short time usage */
+ float ftmp; /* tmp float for parsing env variables */
+ char *ptr; /* used in getting env variables */
+ int options=0; /* no options specified */
+ int ind; /* index */
+ int cnt; /* counter */
+ int num; /* size of a string */
+ char *opt; /* return of mc_getoptv */
+
+ /*
+ * If not the first time this function is called, release the old STD_opt_arr
+ * vector.
+ */
+
+ if ( STD_opt_arr != NULL ) {
+ free(STD_opt_arr);
+ STD_opt_arr=NULL;
+ }
+
+ /*
+ * Define standard options known to the parse_opts package.
+ * Each option is added to the end of the STD_opt_arr array.
+ */
+ if ( add_option(ITERATIONS, &STD_opt_arr, &STD_nopts) == -1)
+ return Mesg2;
+ if ( add_option(DELAY, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+ if ( add_option(DURATION, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+ if ( add_option(NOFUNC, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+ if ( add_option(SETUP_PAUSE, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+ if ( add_option(COPIES, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+ if ( add_option(USC_HELP, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+ if ( add_option(TIMING, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+ if ( add_option(ERRNO_LOGGING, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+
+ /* validate input array of options and build STD_opt_arr */
+
+ if ( user_optarr != (option_t *) NULL ) {
+ for(cnt=0; user_optarr[cnt].option != (char *) NULL; cnt++ ) {
+ /*
+ * Determine if user option already in STD_opt_arr.
+ * If the option is listed twice (in even numbers), it is disabled.
+ * To disable the option, remove it from the option from STD_opt_arr.
+ */
+ for(ind=0; ind<STD_nopts; ind++) {
+ if (strcmp(user_optarr[cnt].option, STD_opt_arr[ind]) == 0 ) {
+ /*
+ * user option already in STD_opt_arry, which means to
+ * disable that option. Remove that option from STD_opt_arr.
+ */
+ rm_option(user_optarr[cnt].option, &STD_opt_arr, &STD_nopts);
+ break;
+ }
+ }
+
+ /*
+ * User's option is not already in STD_opt_arr so it needs to be
+ * added.
+ */
+ if ( ind >= STD_nopts ) {
+ num=strlen(user_optarr[cnt].option);
+
+ /*
+ * If the last character is ":", make sure arg pointer
+ * is not NULL.
+ */
+ if ( user_optarr[cnt].option[num-1] == ':' ) {
+
+ if ( user_optarr[cnt].arg == NULL ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - option:\"%s\" expecting argument, NO POINTER GIVEN",
+ user_optarr[cnt].option);
+ return(Mesg2);
+ }
+
+ } else {
+ /*
+ * The option does not require an argument, make sure
+ * user_optarr[cnt].flag is pointing to something.
+ * The flag is optional when argument is required.
+ */
+ if ( user_optarr[cnt].flag == NULL ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - option:\"%s\" NO FLAG LOCATION GIVEN",
+ user_optarr[cnt].option);
+ return(Mesg2);
+
+ }
+ }
+
+ /*
+ * Add the users option to the STD_opt_arr array.
+ */
+ if ( add_option(user_optarr[cnt].option, &STD_opt_arr, &STD_nopts) == -1 )
+ return Mesg2;
+
+ } /* new option */
+ } /* end of options loop */
+ } /* end of user options */
+
+#if DEBUG > 1
+ printf("STD_nopts = %d\n", STD_nopts);
+#endif
+
+
+ /*
+ * Loop through av parsing options.
+ */
+ while ( (opt=mc_getoptv(ac, av, 0, STD_nopts, STD_opt_arr)) != MC_DONE ) {
+
+ STD_argind = mc_optind;
+
+#if DEBUG > 0
+ printf("parse_opts: mc_getoptv returned '%s'\n", opt);
+#endif
+ if ( strcmp(opt, MC_UNKNOWN_OPTION) == 0 ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - Unknown option: \"-%s\"",
+ mc_optopt);
+ return Mesg2;
+
+ } else if ( strcmp(opt, MC_AMBIGUOUS_OPTION) == 0 ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - option \"-%s\" is not unique, be more specific",
+ mc_optopt);
+ return Mesg2;
+
+ } else if ( strcmp(opt, MC_MISSING_OPTARG) == 0 ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - option \"-%s\" is missing its argument",
+ mc_optopt);
+ return Mesg2;
+
+ } else if ( strcmp(opt, ITERATIONS) == 0 ) {
+ options |= OPT_iteration;
+ if ( sscanf(mc_optarg, "%i%c", &STD_LOOP_COUNT, &chr) != 1) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - Argument for -%s option MUST be NUMERIC",
+ mc_optopt);
+ return(Mesg2);
+ }
+
+ if ( STD_LOOP_COUNT == 0 ) /* if arg is 0, set infinite loop flag */
+ STD_INFINITE=1;
+
+ } else if ( strcmp(opt, DELAY) == 0 ) {
+ options |= OPT_delay;
+ if ( sscanf(mc_optarg, "%f%c", &STD_LOOP_DELAY, &chr) != 1 ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - Argument for -%s option MUST be NUMERIC",
+ mc_optopt);
+ return(Mesg2);
+ }
+
+ } else if ( strcmp(opt, DURATION) == 0 ) {
+ options |= OPT_duration;
+ if ( sscanf(mc_optarg, "%f%c", &STD_LOOP_DURATION, &chr) != 1 ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - Argument for -%s option MUST be NUMERIC",
+ mc_optopt);
+ return(Mesg2);
+ }
+
+ if ( STD_LOOP_DURATION == 0.0 ) {
+ STD_INFINITE=1;
+ }
+
+ } else if ( strcmp(opt, COPIES) == 0 ) {
+ options |= OPT_copies;
+ if ( sscanf(mc_optarg, "%i%c", &STD_COPIES, &chr) != 1 ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - Argument for -%s option MUST be NUMERIC",
+ mc_optopt);
+ return(Mesg2);
+ }
+
+ } else if ( strcmp(opt, NOFUNC) == 0 ) {
+ STD_FUNCTIONAL_TEST=0;
+ } else if ( strcmp(opt, SETUP_PAUSE) == 0 ) {
+ STD_PAUSE=1;
+ } else if ( strcmp(opt, TIMING) == 0 ) {
+ STD_TIMING_ON=1;
+ } else if ( strcmp(opt, ERRNO_LOGGING) == 0 ) {
+ STD_ERRNO_LOG=1;
+ } else if ( strcmp(opt, USC_HELP) == 0 ) {
+ printf(STD_opts_help());
+ exit(0);
+ } else {
+ /* Check all the user specified options */
+ found=0;
+ for(ind=0; user_optarr[ind].option != (char *) NULL; ind++) {
+
+ if ( strcmp(opt, user_optarr[ind].option) == 0 ) {
+ /* Yup, This is a user option, set the flag and look for argument */
+ if ( user_optarr[ind].flag != NULL ) {
+ *user_optarr[ind].flag=1;
+ }
+ found++;
+
+ /* If option requires arg, save pointer */
+ num=strlen(user_optarr[ind].option);
+ /* save the argument at the user's location */
+ if ( user_optarr[ind].option[num-1] == ':' ) {
+ *user_optarr[ind].arg=mc_optarg;
+ }
+ break; /* option found - break out of the for loop */
+ }
+ }
+ /* This condition "should never happen". SO CHECK FOR IT!!!! */
+ if ( ! found ) {
+ sprintf(Mesg2,
+ "parse_opts: ERROR - option:\"%s\" NOT FOUND... INTERNAL ERROR", opt);
+ return(Mesg2);
+ }
+ }
+
+ } /* end of while */
+
+ STD_argind = mc_optind;
+
+ /*
+ * Turn on debug
+ */
+ if ( (ptr=getenv("USC_DEBUG")) != NULL ) {
+ Debug=1;
+ printf("env USC_DEBUG is defined, turning on debug\n");
+ }
+ if ( (ptr=getenv("USC_VERBOSE")) != NULL ) {
+ Debug=1;
+ printf("env USC_VERBOSE is defined, turning on debug\n");
+ }
+
+ /*
+ * If the USC_ITERATION_ENV environmental variable is set to
+ * a number, use that number as iteration count (same as -c option).
+ * The -c option with arg will be used even if this env var is set.
+ */
+ if ( !(options & OPT_iteration) && (ptr=getenv(USC_ITERATION_ENV)) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1) {
+ if ( k == 0 ) { /* if arg is 0, set infinite loop flag */
+ STD_INFINITE=1;
+ if ( Debug )
+ printf("Using env %s, set STD_INFINITE to 1\n",
+ USC_ITERATION_ENV);
+ } else { /* else, set the loop count to the arguement */
+ STD_LOOP_COUNT=k;
+ if ( Debug )
+ printf("Using env %s, set STD_LOOP_COUNT to %d\n",
+ USC_ITERATION_ENV, k);
+ }
+ }
+ }
+
+ /*
+ * If the USC_NO_FUNC_CHECK environmental variable is set, we'll
+ * unset the STD_FUNCTIONAL_TEST variable.
+ */
+ if ( !(options & OPT_nofunccheck) && (ptr=getenv(USC_NO_FUNC_CHECK)) != NULL ) {
+ STD_FUNCTIONAL_TEST=0; /* Turn off functional testing */
+ if ( Debug )
+ printf("Using env %s, set STD_FUNCTIONAL_TEST to 0\n",
+ USC_NO_FUNC_CHECK);
+ }
+
+ /*
+ * If the USC_LOOP_WALLTIME environmental variable is set,
+ * use that number as duration (same as -I option).
+ * The -I option with arg will be used even if this env var is set.
+ */
+
+ if ( !(options & OPT_duration) && (ptr=getenv(USC_LOOP_WALLTIME)) != NULL ) {
+ if ( sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0 ) {
+ STD_LOOP_DURATION=ftmp;
+ if ( Debug )
+ printf("Using env %s, set STD_LOOP_DURATION to %f\n",
+ USC_LOOP_WALLTIME, ftmp);
+ if ( STD_LOOP_DURATION == 0.0 ) { /* if arg is 0, set infinite loop flag */
+ STD_INFINITE=1;
+ if ( Debug )
+ printf("Using env %s, set STD_INFINITE to 1\n", USC_LOOP_WALLTIME);
+ }
+ }
+ }
+ if ( !(options & OPT_duration) && (ptr=getenv("USC_DURATION")) != NULL ) {
+ if ( sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0 ) {
+ STD_LOOP_DURATION=ftmp;
+ if ( Debug )
+ printf("Using env USC_DURATION, set STD_LOOP_DURATION to %f\n", ftmp);
+ if ( STD_LOOP_DURATION == 0.0 ) { /* if arg is 0, set infinite loop flag */
+ STD_INFINITE=1;
+ if ( Debug )
+ printf("Using env USC_DURATION, set STD_INFINITE to 1\n");
+ }
+ }
+ }
+ /*
+ * If the USC_LOOP_DELAY environmental variable is set,
+ * use that number as delay in factional seconds (same as -P option).
+ * The -P option with arg will be used even if this env var is set.
+ */
+ if ( !(options & OPT_delay) && (ptr=getenv(USC_LOOP_DELAY)) != NULL ) {
+ if ( sscanf(ptr, "%f", &ftmp) == 1 && ftmp >= 0.0 ) {
+ STD_LOOP_DELAY=ftmp;
+ if ( Debug )
+ printf("Using env %s, set STD_LOOP_DELAY = %f\n",
+ USC_LOOP_DELAY, ftmp);
+ }
+ }
+
+ /*
+ * If the USC_COPIES environmental variable is set,
+ * use that number as copies (same as -c option).
+ * The -c option with arg will be used even if this env var is set.
+ */
+ if ( !(options & OPT_copies) && (ptr=getenv(USC_COPIES)) != NULL ) {
+ if ( sscanf(ptr, "%d", &STD_COPIES) == 1 && STD_COPIES >= 0 ) {
+ if ( Debug )
+ printf("Using env %s, set STD_COPIES = %d\n",
+ USC_COPIES, STD_COPIES);
+ }
+ }
+
+ /*
+ * The following are special system testing envs to turn on special
+ * hooks in the code.
+ */
+ if ( (ptr=getenv("USC_TP_BARRIER")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_TP_barrier=k;
+ }
+ else
+ STD_TP_barrier=1;
+ if ( Debug )
+ printf("using env USC_TP_BARRIER, Set STD_TP_barrier to %d\n",
+ STD_TP_barrier);
+ }
+
+ if ( (ptr=getenv("USC_LP_BARRIER")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_LP_barrier=k;
+ }
+ else
+ STD_LP_barrier=1;
+ if ( Debug )
+ printf("using env USC_LP_BARRIER, Set STD_LP_barrier to %d\n",
+ STD_LP_barrier);
+ }
+
+ if ( (ptr=getenv("USC_TP_SHMEM")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_TP_shmem_sz=k;
+ if ( Debug )
+ printf("Using env USC_TP_SHMEM, Set STD_TP_shmem_sz to %d\n",
+ STD_TP_shmem_sz);
+ }
+ }
+
+ if ( (ptr=getenv("USC_LP_SHMEM")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_LP_shmem=k;
+ if ( Debug )
+ printf("Using env USC_LP_SHMEM, Set STD_LP_shmem to %d\n",
+ STD_LP_shmem);
+ }
+ }
+
+ if ( (ptr=getenv("USC_LD_SHMEM")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_LD_shmem=k;
+ if ( Debug )
+ printf("Using env USC_LD_SHMEM, Set STD_LD_shmem to %d\n",
+ STD_LD_shmem);
+ }
+ }
+
+ if ( (ptr=getenv("USC_TP_SBRK")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_TP_sbrk=k;
+ if ( Debug )
+ printf("Using env USC_TP_SBRK, Set STD_TP_sbrk to %d\n",
+ STD_TP_sbrk);
+ }
+ }
+
+ if ( (ptr=getenv("USC_LP_SBRK")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_LP_sbrk=k;
+ if ( Debug )
+ printf("Using env USC_LP_SBRK, Set STD_LP_sbrk to %d\n",
+ STD_LP_sbrk);
+ }
+ }
+
+ if ( (ptr=getenv("USC_LP_RECFUN")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_LP_recfun=k;
+ if ( STD_bigstack != (struct usc_bigstack_t *)NULL )
+ STD_bigstack=(struct usc_bigstack_t *)
+ malloc(sizeof(struct usc_bigstack_t));
+ if ( Debug )
+ printf("Using env USC_LP_RECFUN, Set STD_LP_recfun to %d\n",
+ STD_LP_recfun);
+ }
+ }
+
+ if ( (ptr=getenv("USC_LD_RECFUN")) != NULL ) {
+ if ( sscanf(ptr, "%i", &k) == 1 && k >= 0 ) {
+ STD_LD_recfun=k;
+ if ( STD_bigstack != (struct usc_bigstack_t *)NULL )
+ STD_bigstack=(struct usc_bigstack_t *)
+ malloc(sizeof(struct usc_bigstack_t));
+ if ( Debug )
+ printf("Using env USC_LD_RECFUN, Set STD_LD_recfun to %d\n",
+ STD_LD_recfun);
+ }
+ }
+
+#if UNIT_TEST
+ printf("The following variables after option and env parsing:\n");
+ printf("STD_FUNCTIONAL_TEST = %d\n", STD_FUNCTIONAL_TEST);
+ printf("STD_LOOP_DURATION = %f\n", STD_LOOP_DURATION);
+ printf("STD_LOOP_DELAY = %f\n", STD_LOOP_DELAY);
+ printf("STD_COPIES = %d\n", STD_COPIES);
+ printf("STD_LOOP_COUNT = %d\n", STD_LOOP_COUNT);
+ printf("STD_INFINITE = %d\n", STD_INFINITE);
+ printf("STD_TIMING_ON = %d\n", STD_TIMING_ON);
+ printf("STD_ERRNO_LOG = %d\n", STD_ERRNO_LOG);
+ printf("STD_PAUSE = %d\n", STD_PAUSE);
+#endif
+
+ return((char *) NULL);
+
+} /* end of parse_opts */
+
+/***********************************************************************
+ * This function will remove option from the opt_arr array and
+ * decrement the value of nopts. If option is not at the end
+ * of the opt_arr, the remaining elements are moved up in the array.
+ *
+ ***********************************************************************/
+static int
+rm_option(char *option, char **opt_arr[], int *nopts)
+{
+ int ind;
+ int found=0;
+
+ for (ind=0; ind<*nopts; ind++) {
+ if ( found ) {
+ /*
+ * Move all opt_arr elements down in the array
+ */
+ if ( ind == (*nopts) ) {
+ (*opt_arr)[ind] = NULL;
+ } else {
+ (*opt_arr)[ind-1] = (*opt_arr)[ind];
+ }
+
+ } else if ( strcmp(option, (*opt_arr)[ind]) == 0 ) {
+ found=ind+1;
+ }
+ }
+ if ( found ) {
+ (*nopts)--;
+#if DEBUG > 1
+ printf("removed %s option from opt_arr, opt_arr[%d] = %s\n",
+option, found-1, (*opt_arr)[found-1]);
+#endif
+ }
+
+ return 0;
+}
+
+/***********************************************************************
+ * This function will add option to the end of opt_arr array and
+ * increment the value of nopts. The array space will be realloc'ed
+ * to make space for the element.
+ *
+ ***********************************************************************/
+static int
+add_option(char *option, char **opt_arr[], int *nopts)
+{
+
+ if ( (*opt_arr=(char **)realloc(*opt_arr, sizeof(char * ) * (*nopts+1))) ==
+ (char **)NULL ) {
+ sprintf(Mesg2, "parse_opts: ERROR: realloc(arr, %ld) failed, errno:%d %s",
+ (long)sizeof(char * ) * (*nopts+1), errno, strerror(errno));
+ return -1;
+ }
+
+ (*opt_arr)[*nopts] = option;
+
+#if DEBUG > 1
+ printf("adding opt_arr[%d] = %s\n", *nopts, (*opt_arr)[*nopts]);
+#endif
+ (*nopts)++;
+
+ return 0;
+}
+
+/*********************************************************************
+ * STD_opts() - return a usage string for the STD_OPTIONS.
+ *********************************************************************/
+char *
+STD_opts()
+{
+ int ind;
+
+ Mesg2[0] = '\0';
+
+ /*
+ * generate usage string from the standard options in STD_opt_arr
+ */
+ for(ind=0; ind<STD_nopts; ind++) {
+ if ( strcmp(ITERATIONS, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, ITERATIONS_USE);
+ }else if ( strcmp(DELAY, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, DELAY_USE);
+ }else if ( strcmp(DURATION, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, DURATION_USE);
+ }else if ( strcmp(COPIES, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, COPIES_USE);
+ }else if ( strcmp(NOFUNC, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, NOFUNC_USE);
+ }else if ( strcmp(SETUP_PAUSE, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, SETUP_PAUSE_USE);
+ }else if ( strcmp(TIMING, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, TIMING_USE);
+ }else if ( strcmp(ERRNO_LOGGING, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, ERRNO_LOGGING_USE);
+ }else if ( strcmp(USC_HELP, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg2, HELP_USE);
+ }
+ }
+
+ return Mesg2;
+}
+
+/*********************************************************************
+ * STD_opts_help() - return a help string for the STD_OPTIONS.
+ *********************************************************************/
+char *
+STD_opts_help()
+{
+ int ind;
+
+ sprintf(Mesg, " Options and option args can NOT be concatenated.\n\
+ You can use smallest unique string that identifies an option\n");
+
+ /*
+ * generate usage string from the standard options in STD_opt_arr
+ */
+ for(ind=0; ind<STD_nopts; ind++) {
+ if ( strcmp(ITERATIONS, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, ITERATIONS_HELP);
+ }else if ( strcmp(DELAY, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, DELAY_HELP);
+ }else if ( strcmp(DURATION, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, DURATION_HELP);
+ }else if ( strcmp(COPIES, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, COPIES_HELP);
+ }else if ( strcmp(NOFUNC, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, NOFUNC_HELP);
+ }else if ( strcmp(SETUP_PAUSE, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, SETUP_PAUSE_HELP);
+ }else if ( strcmp(TIMING, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, TIMING_HELP);
+ }else if ( strcmp(ERRNO_LOGGING, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, ERRNO_LOGGING_HELP);
+ }else if ( strcmp(USC_HELP, STD_opt_arr[ind]) == 0 ) {
+ strcat(Mesg, USC_HELP_HELP);
+ }
+ }
+
+ return Mesg;
+}
+
+/*
+ * routine to goto when we get the SIGUSR1 for STD_PAUSE
+ */
+void STD_go(int sig)
+{
+ return;
+}
+
+/***********************************************************************
+ * This function will do desired end of global setup test
+ * hooks.
+ * Currently it will only do a pause waiting for sigusr1 if
+ * STD_PAUSE is set.
+ *
+ ***********************************************************************/
+int
+usc_global_setup_hook()
+{
+ int cnt;
+
+ /*
+ * Fork STD_COPIES-1 copies.
+ */
+ for(cnt=1;cnt<STD_COPIES;cnt++) {
+ switch(fork() ) {
+ case -1:
+ fprintf(stderr, "%s: fork() failed, errno:%d %s\n",
+ __FILE__, errno, strerror(errno));
+ break;
+ case 0: /* child */
+ cnt=STD_COPIES; /* to stop the forking */
+ break;
+
+ default: /* parent */
+ break;
+ }
+ }
+
+
+
+#ifdef _CRAYMPP
+ MyPE = sysconf(_SC_CRAY_VPE);
+ Npe = sysconf(_SC_CRAY_NPES);
+#endif
+
+ /*
+ * pause waiting for sigusr1.
+ */
+ if ( STD_PAUSE ) {
+ _TMP_FUNC = (int (*)())signal(SIGUSR1, STD_go);
+ pause();
+ signal(SIGUSR1, (void (*)())_TMP_FUNC);
+ }
+
+#ifdef _CRAYMPP
+ if ( STD_TP_shmem_sz ) {
+ if ( (STD_shmem=(long *)shmalloc(STD_TP_shmem_sz*sizeof(long)*Npe)) == NULL ) {
+ STD_TP_shmem_sz=0;
+ }
+ else {
+ bzero(STD_shmem, STD_TP_shmem_sz*sizeof(long)*Npe);
+ if ( Debug )
+ printf("shmalloc(%d*%d*%d=%d) successful, pid:%d\n",
+ STD_TP_shmem_sz, sizeof(long), Npe,
+ STD_TP_shmem_sz*sizeof(long)*Npe, getpid());
+ }
+ }
+
+ if ( STD_TP_barrier ) {
+ switch (STD_TP_barrier) {
+ case 2:
+ wait_barrier();
+ if ( Debug )
+ printf("after wait_barrier, pid : %d\n", getpid());
+ break;
+
+ case 3:
+ set_barrier();
+ if ( Debug )
+ printf("after set_barrier, pid : %d\n", getpid());
+ break;
+
+ default:
+ barrier();
+ if ( Debug )
+ printf("after barrier, pid : %d\n", getpid());
+ }
+ }
+
+#endif /* _CRAYMPP */
+
+ if ( STD_TP_sbrk || STD_LP_sbrk) {
+ STD_start_break=sbrk(0); /* get original sbreak size */
+ }
+
+ if ( STD_TP_sbrk ) {
+ sbrk(STD_TP_sbrk);
+ if ( Debug )
+ printf("after sbrk(%d)\n", STD_TP_sbrk);
+ }
+ return 0;
+}
+
+#define USECS_PER_SEC 1000000 /* microseconds per second */
+
+/***********************************************************************
+ * This function returns the number of get_current_time()'s return
+ * per second.
+ ***********************************************************************/
+
+static int
+get_timepersec()
+{
+#if CRAY
+ return sysconf(_SC_CLK_TCK); /* clocks per second */
+#else
+ return USECS_PER_SEC; /* microseconds per second */
+#endif /* CRAY */
+
+}
+
+/***********************************************************************
+ * this function will get current time in clocks if on a CRAY system
+ * or in microseconds since 1970.
+ ***********************************************************************/
+static int
+get_current_time()
+{
+ struct timeval curtime;
+#if CRAY
+ return _rtc(); /* clocks since last boot */
+#else
+
+ gettimeofday(&curtime, NULL);
+
+ /* microseconds since 1970 */
+ return (curtime.tv_sec*USECS_PER_SEC) + curtime.tv_usec;
+
+#endif
+
+}
+
+/***********************************************************************
+ *
+ * This function will determine if test should continue iterating
+ * If the STD_INFINITE flag is set, return 1.
+ * If the STD_LOOP_COUNT variable is set, compare it against
+ * the counter.
+ * If the STD_LOOP_DURATION variable is set, compare current time against
+ * calculated stop_time.
+ * This function will return 1 until all desired looping methods
+ * have been met.
+ *
+ * counter integer is supplied by the user program.
+ ***********************************************************************/
+int
+usc_test_looping(counter)
+int counter;
+{
+ static int first_time = 1;
+ static int stop_time = 0; /* stop time in rtc or usecs */
+ static int delay; /* delay in clocks or usecs */
+ int hz=0; /* clocks per second or usecs per second */
+ int ct, end; /* current time, end delay time */
+ int keepgoing=0; /* used to determine return value */
+#ifdef _CRAYMPP
+ long word;
+ int pe;
+#endif
+
+ /*
+ * If this is the first iteration and we are looping for
+ * duration of STD_LOOP_DURATION seconds (fractional) or
+ * doing loop delays, get the clocks per second.
+ */
+ if ( first_time ) {
+
+ first_time=0;
+ if ( STD_LOOP_DELAY || STD_LOOP_DURATION ) {
+ hz = get_timepersec();
+ }
+
+ /*
+ * If looping for duration, calculate stop time in
+ * clocks.
+ */
+
+ if ( STD_LOOP_DURATION) {
+ ct=get_current_time();
+ stop_time=(int)((float)hz * STD_LOOP_DURATION) + ct;
+ }
+
+ /*
+ * If doing delay each iteration, calcuate the number
+ * of clocks for each delay.
+ */
+ if ( STD_LOOP_DELAY ) {
+ delay=(int)((float)hz * STD_LOOP_DELAY);
+ }
+
+ }
+
+ /*
+ * if delay each iteration, loop for delay clocks.
+ * This will not be done on first iteration.
+ * The delay will happen before determining if
+ * there will be another iteration.
+ */
+ else if ( STD_LOOP_DELAY ) {
+ ct=get_current_time();
+ end=ct+delay;
+ while ( ct < end ) {
+ /*
+ * The following are special test hooks in the delay loop.
+ */
+ if ( STD_LD_recfun ) {
+ if ( Debug )
+ printf("calling usc_recressive_func(0, %d, &STD_bigstack)\n",
+ STD_LD_recfun);
+ usc_recressive_func(0, STD_LD_recfun, &STD_bigstack);
+ }
+
+ ct=get_current_time();
+ }
+ }
+
+ if ( STD_INFINITE ) {
+ keepgoing++;
+ }
+
+ if ( STD_LOOP_COUNT && counter < STD_LOOP_COUNT ) {
+ keepgoing++;
+ }
+
+ if ( STD_LOOP_DURATION != 0.0 && get_current_time() < stop_time ) {
+ keepgoing++;
+ }
+
+ if ( keepgoing == 0 )
+ return 0;
+
+ /*
+ * The following code allows special system testing hooks.
+ */
+
+ if ( STD_LP_recfun ) {
+ if ( Debug )
+ printf("calling usc_recressive_func(0, %d, &STD_bigstack)\n",
+ STD_LP_recfun);
+ usc_recressive_func(0, STD_LP_recfun, &STD_bigstack);
+ }
+
+ if ( STD_LP_sbrk ) {
+ if ( Debug )
+ printf("about to do sbrk(%d)\n", STD_LP_sbrk);
+ sbrk(STD_LP_sbrk);
+ }
+
+#ifdef _CRAYMPP
+ if ( STD_LP_shmem ) {
+ if ( (pe=MyPE-1) < 0 ) /* put to be lower pe #*/
+ pe=Npe;
+ word=MyPE;
+
+ if ( Debug )
+ printf("about to do shmem_put\n");
+ shmem_put(&STD_shmem[pe], &STD_shmem[MyPE], STD_TP_shmem_sz, pe);
+
+
+ }
+ if ( STD_TP_barrier ) {
+ switch (STD_TP_barrier) {
+ case 2:
+ wait_barrier();
+ if ( Debug )
+ printf("after wait_barrier, pid : %d\n", getpid());
+ break;
+
+ case 3:
+ set_barrier();
+ if ( Debug )
+ printf("after set_barrier, pid : %d\n", getpid());
+ break;
+
+ default:
+ barrier();
+ if ( Debug )
+ printf("after barrier, pid : %d\n", getpid());
+ }
+ }
+ if ( STD_LP_shmem > 1) {
+ if ( (pe=MyPE+1) > Npe ) /* get from higher pe # */
+ pe=0;
+ word=MyPE;
+
+ if ( Debug )
+ printf("about to do shmem_get\n");
+ shmem_get(&STD_shmem[MyPE], &STD_shmem[pe], STD_TP_shmem_sz, pe);
+ }
+
+
+#endif /* _CRAYMPP */
+
+
+ if ( keepgoing )
+ return 1;
+ else
+ return 0; /* done - stop iterating */
+}
+
+
+/*
+ * This function recressively calls itself max times.
+ */
+static void
+usc_recressive_func(cnt, max, bstack)
+int cnt;
+int max;
+struct usc_bigstack_t bstack;
+{
+ if ( cnt < max )
+ usc_recressive_func(cnt+1, max, bstack);
+
+}
+
+#if UNIT_TEST
+/******************************************************************************
+ * UNIT TEST CODE
+ * UNIT TEST CODE
+ *
+ * this following code is provide so that unit testing can
+ * be done fairly easily.
+ ******************************************************************************/
+
+int Help = 0;
+int Help2 = 0;
+char *ptr;
+
+/*
+ * Code from usctest.h that not part of this file since we are the library.
+ */
+
+struct usc_errno_t TEST_VALID_ENO[USC_MAX_ERRNO];
+
+ /***********************************************************************
+ * Globals for returning the return code and errno from the system call
+ * test macros.
+ ***********************************************************************/
+int TEST_RETURN;
+int TEST_ERRNO;
+
+ /***********************************************************************
+ * temporary variables for determining max and min times in TEST macro
+ ***********************************************************************/
+long btime, etime, tmptime;
+
+
+
+/* for test specific parse_opts options */
+option_t Options[] = {
+ { "help", &Help2, NULL }, /* -help option */
+ { "h", &Help, NULL }, /* -h option */
+ { TIMING, NULL, NULL}, /* disable -timing option */
+
+#if INVALID_TEST_CASES
+ { "missingflag", NULL, &ptr }, /* error */
+ { "missingarg:", &Help, NULL }, /* error */
+#endif /* INVALID_TEST_CASES */
+
+ { NULL, NULL, NULL }
+};
+
+
+main(argc, argv)
+int argc;
+char **argv;
+{
+ int lc;
+ char *msg;
+ struct timeval t;
+ int cnt;
+
+ if ( (msg=parse_opts(argc, argv,
+ (option_t *) Options)) != (char *) NULL ) {
+ printf("ERROR : %s\n", msg);
+ exit(1);
+ }
+
+ if ( Help ) {
+ printf("****** -h option *****\n");
+ printf("Usage %s %s[-help]\n", argv[0], STD_opts());
+ printf("%s -help : print this help message and exit\n",
+ STD_opts_help());
+ exit(0);
+ }
+
+ if ( Help2 ) {
+ printf("****** -help option *****\n");
+ printf("Usage %s %s[-help]\n", argv[0], STD_opts());
+ printf("%s -help : print this help message and exit\n",
+ STD_opts_help());
+ exit(0);
+ }
+
+ TEST_PAUSE;
+
+ for (lc=0; TEST_LOOPING(lc); lc++) {
+
+ TEST( gettimeofday(&t, NULL) );
+ printf("iter=%d: sec:%d, usec:%6.6d %s", lc+1, t.tv_sec,
+ t.tv_usec, ctime(&t.tv_sec));
+ }
+
+
+ TEST_CLEANUP;
+
+ exit(0);
+}
+
+#endif /* UNIT_TEST */