From d4ef791c513ebba705495733475c28f005187550 Mon Sep 17 00:00:00 2001
From: Mark Grondona <mgrondona@llnl.gov>
Date: Tue, 25 Jun 2002 00:44:42 +0000
Subject: [PATCH] o updates to some option names and other various cleanup
items.
---
doc/man/man1/srun.1 | 2 +
src/srun/Makefile.am | 2 +-
src/srun/env.c | 1 +
src/srun/env.h | 6 +-
src/srun/opt.c | 1441 +++++++++++++++++++++---------------------
src/srun/opt.h | 4 +-
src/srun/srun.c | 18 +-
7 files changed, 741 insertions(+), 733 deletions(-)
diff --git a/doc/man/man1/srun.1 b/doc/man/man1/srun.1
index af2e8d40749..d295522fa54 100644
--- a/doc/man/man1/srun.1
+++ b/doc/man/man1/srun.1
@@ -1,3 +1,5 @@
+\." $Id$
+.\"
.TH SRUN "1" "February 2002" "srun 0.1" "slurm components"
.SH "NAME"
srun \- run parallel jobs
diff --git a/src/srun/Makefile.am b/src/srun/Makefile.am
index 36f214a2ffc..827ecbdd4c4 100644
--- a/src/srun/Makefile.am
+++ b/src/srun/Makefile.am
@@ -5,5 +5,5 @@ INCLUDES = $(POPT_INCLUDES)
bin_PROGRAMS = srun
srun_SOURCES = srun.c opt.c env.c opt.h env.h
-srun_LDFLAGS =
+srun_LDFLAGS = $(top_srcdir)/src/common/libcommon.la
srun_LDADD = $(POPT_LIBS)
diff --git a/src/srun/env.c b/src/srun/env.c
index 98a00b15336..21b60b0c05d 100644
--- a/src/srun/env.c
+++ b/src/srun/env.c
@@ -1,4 +1,5 @@
/*
+ * $Id$
*
* env.c : environment manipulation
*/
diff --git a/src/srun/env.h b/src/srun/env.h
index 5d582d9f655..ede76189f53 100644
--- a/src/srun/env.h
+++ b/src/srun/env.h
@@ -1,4 +1,6 @@
-/* */
+/* $Id$
+ *
+ */
#ifndef _HAVE_ENV_H
#define _HAVE_ENV_H
@@ -8,7 +10,7 @@
*
* Set a variable in the callers environment. Args are printf style.
* XXX Space is allocated on the heap and will never be reclaimed.
- * Example: setenvf("RMS_RANK=%d", rank);
+ * Example: setenvf("MPI_RANK=%d", rank);
*/
int setenvf(const char *fmt, ...);
diff --git a/src/srun/opt.c b/src/srun/opt.c
index 2f1268750b6..08fd2677669 100644
--- a/src/srun/opt.c
+++ b/src/srun/opt.c
@@ -1,64 +1,72 @@
-/* $Id$ */
+/* $Id$ */
-#include "config.h"
+/* opt.c */
+/* options processing for srun */
+
+#if HAVE_CONFIG_H
+# include <config.h>
+#endif
-#include <string.h> /* strcpy, strncasecmp */
+
+#include <string.h> /* strcpy, strncasecmp */
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
-#include <stdarg.h> /* va_start */
-#include <stdlib.h> /* getenv */
-#include <pwd.h> /* getpwuid */
-#include <ctype.h> /* isdigit */
+#include <stdarg.h> /* va_start */
+#include <stdlib.h> /* getenv */
+#include <pwd.h> /* getpwuid */
+#include <ctype.h> /* isdigit */
#include <sys/param.h> /* MAXPATHLEN */
+#include <src/common/log.h>
+#include <src/common/xstring.h>
+
#include "opt.h"
#include "env.h"
-#define tf_(b) (b == true) ? "true" : "false"
-#define __DEBUG 1
+#define __DEBUG
/*---[ popt definitions ]------------------------------------------------*/
/* generic OPT_ definitions -- mainly for use with env vars
* (not to be confused with POPT_* definitions)
*/
-#define OPT_NONE 0x00
-#define OPT_INT 0x01
-#define OPT_STRING 0x02
+#define OPT_NONE 0x00
+#define OPT_INT 0x01
+#define OPT_STRING 0x02
/* specific options, used with popt (and env var processing) */
-#define OPT_NPROCS 0x03
-#define OPT_CPUS 0x04
-#define OPT_NODES 0x05
-#define OPT_PARTITION 0x06
-#define OPT_BASENODE 0x07
-#define OPT_DISTRIB 0x08
-#define OPT_OUTPUT 0x09
-#define OPT_INPUT 0x0a
-#define OPT_ERROR 0x0b
-#define OPT_CORE 0x0c
-#define OPT_VERBOSE 0x0d
-#define OPT_DEBUG 0x0e
-#define OPT_ALLOCATE 0x0f
-#define OPT_ATTACH 0x10
-#define OPT_CONST 0x11
-#define OPT_VERSION 0x12
-#define OPT_JOIN 0x13
-#define OPT_STEAL 0x14
-#define OPT_CDDIR 0x15
+#define OPT_NPROCS 0x03
+#define OPT_CPUS 0x04
+#define OPT_NODES 0x05
+#define OPT_PARTITION 0x06
+#define OPT_BASENODE 0x07
+#define OPT_DISTRIB 0x08
+#define OPT_OUTPUT 0x09
+#define OPT_INPUT 0x0a
+#define OPT_ERROR 0x0b
+#define OPT_CORE 0x0c
+#define OPT_VERBOSE 0x0d
+#define OPT_DEBUG 0x0e
+#define OPT_ALLOCATE 0x0f
+#define OPT_ATTACH 0x10
+#define OPT_CONST 0x11
+#define OPT_VERSION 0x12
+#define OPT_JOIN 0x13
+#define OPT_STEAL 0x14
+#define OPT_CDDIR 0x15
/* constraint type options */
-#define OPT_MINCPUS 0x50
-#define OPT_REALMEM 0x51
-#define OPT_VIRTMEM 0x52
-#define OPT_TMPDISK 0x53
-#define OPT_CONTIG 0x54
-#define OPT_NODELIST 0x55
-#define OPT_CONSTRAINT 0x56
+#define OPT_MINCPUS 0x50
+#define OPT_REALMEM 0x51
+#define OPT_VIRTMEM 0x52
+#define OPT_TMPDISK 0x53
+#define OPT_CONTIG 0x54
+#define OPT_NODELIST 0x55
+#define OPT_CONSTRAINT 0x56
#ifndef POPT_TABLEEND
@@ -67,149 +75,149 @@
/* options related to attach mode only */
struct poptOption attachTable[] = {
- { "attach", 'a', POPT_ARG_STRING, &opt.attach, OPT_ATTACH,
- "attach to running job with job id = id",
- "id"
- },
- { "join", 'j', POPT_ARG_NONE, &opt.join, 0,
- "join with running job",
- },
- { "steal", 's', POPT_ARG_NONE, NULL, OPT_STEAL,
- "steal connection to running job",
- },
- POPT_TABLEEND
+ { "attach", 'a', POPT_ARG_STRING, &opt.attach, OPT_ATTACH,
+ "attach to running job with job id = id",
+ "id"
+ },
+/* { "join", 'j', POPT_ARG_NONE, &opt.join, 0,
+ "join with running job",
+ },
+ { "steal", 's', POPT_ARG_NONE, NULL, OPT_STEAL,
+ "steal connection to running job",
+ }, */
+ POPT_TABLEEND
};
/* options directly related to allocate-only mode */
struct poptOption allocateTable[] = {
- { "allocate", 'A', POPT_ARG_NONE, &opt.allocate, OPT_ALLOCATE,
- "allocate resources and spawn a shell",
- },
- POPT_TABLEEND
+ { "allocate", 'A', POPT_ARG_NONE, &opt.allocate, OPT_ALLOCATE,
+ "allocate resources and spawn a shell",
+ },
+ POPT_TABLEEND
};
/* define constraint options here */
struct poptOption constraintTable[] = {
- { "mincpus", '\0', POPT_ARG_INT, &opt.mincpus, OPT_MINCPUS,
- "minimum number of cpus per node",
- "n"
- },
- { "mem", '\0', POPT_ARG_STRING, NULL, OPT_REALMEM,
- "minimum amount of real memory",
- "MB"
- },
- { "tmp", '\0', POPT_ARG_STRING, NULL, OPT_TMPDISK,
- "minimum amount of temp disk",
- "MB"
- },
- { "constraint", 'C' , POPT_ARG_STRING, &opt.constraints,
- OPT_CONSTRAINT, "specify a list of constraints",
- "list"
- },
- { "contiguous", '\0', POPT_ARG_NONE, &opt.contiguous, OPT_CONTIG,
- "demand a contiguous range of nodes",
- },
- { "nodelist", 'w', POPT_ARG_STRING, &opt.nodelist, OPT_NODELIST,
- "request a specific list of hosts",
- "host1,host2,..."
- },
- POPT_TABLEEND
+ { "mincpus", '\0', POPT_ARG_INT, &opt.mincpus, OPT_MINCPUS,
+ "minimum number of cpus per node",
+ "n"
+ },
+ { "mem", '\0', POPT_ARG_STRING, NULL, OPT_REALMEM,
+ "minimum amount of real memory",
+ "MB"
+ },
+ { "tmp", '\0', POPT_ARG_STRING, NULL, OPT_TMPDISK,
+ "minimum amount of temp disk",
+ "MB"
+ },
+ { "constraint", 'C' , POPT_ARG_STRING, &opt.constraints,
+ OPT_CONSTRAINT, "specify a list of constraints",
+ "list"
+ },
+ { "contiguous", '\0', POPT_ARG_NONE, &opt.contiguous, OPT_CONTIG,
+ "demand a contiguous range of nodes",
+ },
+ { "nodelist", 'w', POPT_ARG_STRING, &opt.nodelist, OPT_NODELIST,
+ "request a specific list of hosts",
+ "host1,host2,..."
+ },
+ POPT_TABLEEND
};
-
+
/* options that affect parallel runs (may or may not apply to modes
* above
*/
struct poptOption runTable[] = {
- { "nprocs", 'n', POPT_ARG_INT, &opt.nprocs, OPT_NPROCS,
- "number of processes to run",
- "nprocs"
- },
- { "cpus", 'c', POPT_ARG_INT, &opt.cpus, OPT_CPUS,
- "number of cpus required per process",
- "ncpus"
- },
- { "nodes", 'N', POPT_ARG_INT, &opt.nodes, OPT_NODES,
- "number of nodes on which to run",
- "nnodes"
- },
- { "partition", 'p', POPT_ARG_STRING, &opt.partition, OPT_PARTITION,
- "partition requested",
- "partition"
- },
- { "cddir", 'D', POPT_ARG_STRING, NULL, OPT_CDDIR,
- "change current working directory of remote procs",
- "path"
- },
- { "immediate", 'I', POPT_ARG_NONE, &opt.immediate, 0,
- "exit if resources are not immediately available",
- },
- { "overcommit", 'O', POPT_ARG_NONE, &opt.overcommit, 0,
- "overcommit resources",
- },
- { "label", 'l', POPT_ARG_NONE, &opt.labelio, 0,
- "prepend task number to lines of stdout/err",
- },
- { "distribution", 'm', POPT_ARG_STRING, 0, OPT_DISTRIB,
- "distribution method for processes",
- "(block|cyclic)"
- },
- { "job-name", 'J', POPT_ARG_STRING, &opt.job_name, 0,
- "name of job",
- "jobname"
- },
- { "output", 'o', POPT_ARG_STRING, 0, OPT_OUTPUT,
- "location of stdout redirection",
- "out"
- },
- { "input", 'i', POPT_ARG_STRING, 0, OPT_INPUT,
- "location of stdin redirection",
- "in"
- },
- { "error", 'e', POPT_ARG_STRING, 0, OPT_ERROR,
- "location of stderr redirection",
- "err"
- },
-/* { "corefile-format", '\0', POPT_ARG_STRING, &opt.core_format, 0,
- "corefile output format",
- "format"
- },
-*/ { "verbose", 'v', 0, 0, OPT_VERBOSE,
- "verbose operation",
- },
- { "debug", 'd', 0, 0, OPT_DEBUG,
- "enable debug",
- },
- POPT_TABLEEND
+ { "nprocs", 'n', POPT_ARG_INT, &opt.nprocs, OPT_NPROCS,
+ "number of processes to run",
+ "nprocs"
+ },
+ { "cpus-per-task", 'c', POPT_ARG_INT, &opt.cpus, OPT_CPUS,
+ "number of cpus required per process",
+ "ncpus"
+ },
+ { "nodes", 'N', POPT_ARG_INT, &opt.nodes, OPT_NODES,
+ "number of nodes on which to run",
+ "nnodes"
+ },
+ { "partition", 'p', POPT_ARG_STRING, &opt.partition, OPT_PARTITION,
+ "partition requested",
+ "partition"
+ },
+ { "cddir", 'D', POPT_ARG_STRING, NULL, OPT_CDDIR,
+ "change current working directory of remote procs",
+ "path"
+ },
+ { "immediate", 'I', POPT_ARG_NONE, &opt.immediate, 0,
+ "exit if resources are not immediately available",
+ },
+ { "overcommit", 'O', POPT_ARG_NONE, &opt.overcommit, 0,
+ "overcommit resources",
+ },
+ { "label", 'l', POPT_ARG_NONE, &opt.labelio, 0,
+ "prepend task number to lines of stdout/err",
+ },
+ { "distribution", 'm', POPT_ARG_STRING, 0, OPT_DISTRIB,
+ "distribution method for processes",
+ "(block|cyclic)"
+ },
+ { "job-name", 'J', POPT_ARG_STRING, &opt.job_name, 0,
+ "name of job",
+ "jobname"
+ },
+ { "output", 'o', POPT_ARG_STRING, 0, OPT_OUTPUT,
+ "location of stdout redirection",
+ "out"
+ },
+ { "input", 'i', POPT_ARG_STRING, 0, OPT_INPUT,
+ "location of stdin redirection",
+ "in"
+ },
+ { "error", 'e', POPT_ARG_STRING, 0, OPT_ERROR,
+ "location of stderr redirection",
+ "err"
+ },
+/* { "corefile-format", '\0', POPT_ARG_STRING, &opt.core_format, 0,
+ "corefile output format",
+ "format"
+ },
+*/ { "verbose", 'v', 0, 0, OPT_VERBOSE,
+ "verbose operation",
+ },
+ { "debug", 'd', 0, 0, OPT_DEBUG,
+ "enable debug",
+ },
+ POPT_TABLEEND
};
/* table of "other" options (just version information for now) */
struct poptOption otherTable[] = {
- { "version", 'V', POPT_ARG_NONE, 0, OPT_VERSION,
- "output version information and exit"
- },
- POPT_TABLEEND
+ { "version", 'V', POPT_ARG_NONE, 0, OPT_VERSION,
+ "output version information and exit"
+ },
+ POPT_TABLEEND
};
/* full option table: */
struct poptOption options[] = {
- { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &runTable, 0,
- "Parallel run options:", NULL
- },
- { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &allocateTable, 0,
- "Allocate only:", NULL
- },
- { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &attachTable, 0,
- "Attach to running job:", NULL
- },
- { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &constraintTable, 0,
- "Constraint options:"
- },
- POPT_AUTOHELP
- { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &otherTable, 0,
- "Other options:", NULL
- },
- POPT_TABLEEND
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &runTable, 0,
+ "Parallel run options:", NULL
+ },
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &allocateTable, 0,
+ "Allocate only:", NULL
+ },
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &attachTable, 0,
+ "Attach to running job:", NULL
+ },
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &constraintTable, 0,
+ "Constraint options:"
+ },
+ POPT_AUTOHELP
+ { NULL, '\0', POPT_ARG_INCLUDE_TABLE, &otherTable, 0,
+ "Other options:", NULL
+ },
+ POPT_TABLEEND
};
/*---[ end popt definitions ]---------------------------------------------*/
@@ -226,22 +234,22 @@ struct poptOption options[] = {
* option to set. Otherwise, process var based on "type" in opt_env.
*/
struct env_vars_t {
- const char *var;
- int type;
- void *arg;
+ const char *var;
+ int type;
+ void *arg;
};
struct env_vars_t env_vars[] = {
- { "SLURM_DEBUG", OPT_DEBUG, NULL },
- { "SLURM_NPROCS", OPT_INT, &opt.nprocs },
- { "SLURM_CPUS_PER_TASK", OPT_INT, &opt.cpus },
- { "SLURM_NNODES", OPT_INT, &opt.nodes },
- { "SLURM_PARTITION", OPT_STRING, &opt.partition },
- { "SLURM_STDINMODE", OPT_INPUT, &opt.input },
- { "SLURM_STDOUTMODE", OPT_OUTPUT, &opt.output },
- { "SLURM_STDERRMODE", OPT_ERROR, &opt.error },
- { "SLURM_DISTRIBUTION", OPT_DISTRIB, NULL },
- { NULL, 0, NULL }
+ { "SLURM_DEBUG", OPT_DEBUG, NULL },
+ { "SLURM_NPROCS", OPT_INT, &opt.nprocs },
+ { "SLURM_CPUS_PER_TASK", OPT_INT, &opt.cpus },
+ { "SLURM_NNODES", OPT_INT, &opt.nodes },
+ { "SLURM_PARTITION", OPT_STRING, &opt.partition},
+ { "SLURM_STDINMODE", OPT_INPUT, &opt.input },
+ { "SLURM_STDOUTMODE", OPT_OUTPUT, &opt.output },
+ { "SLURM_STDERRMODE", OPT_ERROR, &opt.error },
+ { "SLURM_DISTRIBUTION", OPT_DISTRIB, NULL },
+ { NULL, 0, NULL }
};
/* forward declarations of static functions
@@ -251,58 +259,49 @@ struct env_vars_t env_vars[] = {
/*
* fill in default options
*/
-static void opt_default();
+static void opt_default(void);
/* set options based upon env vars
*/
-static void opt_env();
+static void opt_env(void);
/* set options based upon commandline args
*/
static void opt_args(int, char **);
-/* verity options sanity
+/* verify options sanity
*/
static bool opt_verify(poptContext, bool, bool, bool);
/* list known options and their settings
*/
-static void opt_list();
+static void opt_list(void);
/*---[ end forward declarations of static functions ]---------------------*/
int
initialize_and_process_args(int argc, char *argv[])
{
- /* initialize option defaults */
- opt_default();
+ /* initialize option defaults */
+ opt_default();
- /* initialize options with env vars */
- opt_env();
+ /* initialize options with env vars */
+ opt_env();
- /* initialize options with argv */
- opt_args(argc, argv);
+ /* initialize options with argv */
+ opt_args(argc, argv);
#ifdef __DEBUG
- opt_list();
+ opt_list();
#endif
- return 1;
+ return 1;
}
-static char *
-xbasename(char *path)
-{
- char *p;
-
- p = strchr(path, '/');
- return(p ? (p + 1) : path);
-}
-
static void
print_version()
{
- printf("%s %s\n", PACKAGE, VERSION);
+ printf("%s %s\n", PACKAGE, VERSION);
}
/*
@@ -316,23 +315,24 @@ print_version()
static enum io_t
verify_iotype(char **name)
{
- enum io_t type;
- char *p = *name;
- int end = strlen(p) - 1;
-
- /* name must have form "file.%" to be IO_PER_TASK */
- if (p[end] == '%') {
- type = IO_PER_TASK;
- p[end] = '\0'; /* no longer need % char */
-
- } else if (strncasecmp(p, "normal", (size_t) 6) != 0)
- type = IO_ALL;
- else if (strncasecmp(p, "none", (size_t) 4) != 0)
- type = IO_NONE;
- else
- type = IO_NORMAL;
-
- return type;
+ enum io_t type;
+ char *p = *name;
+ int end = strlen(p) - 1;
+
+ /* name must have form "file.%" to be IO_PER_TASK */
+ if (p[end] == '%') {
+ type = IO_PER_TASK;
+ p[end] = '\0'; /* no longer need % char */
+
+ } else if (strncasecmp(p, "normal", (size_t) 6) != 0) {
+ type = IO_ALL;
+ } else if (strncasecmp(p, "none", (size_t) 4) != 0) {
+ type = IO_NONE;
+ } else {
+ type = IO_NORMAL;
+ }
+
+ return type;
}
/*
@@ -342,16 +342,16 @@ verify_iotype(char **name)
static enum distribution_t
verify_dist_type(const char *arg)
{
- enum distribution_t result = DIST_UNKNOWN;
+ enum distribution_t result = DIST_UNKNOWN;
- if (strncasecmp(arg, "cyclic", strlen(arg)) == 0)
- result = DIST_CYCLIC;
- else if (strncasecmp(arg, "block", strlen(arg)) == 0)
- result = DIST_BLOCK;
- else
- result = DIST_UNKNOWN;
+ if (strncasecmp(arg, "cyclic", strlen(arg)) == 0)
+ result = DIST_CYCLIC;
+ else if (strncasecmp(arg, "block", strlen(arg)) == 0)
+ result = DIST_BLOCK;
+ else
+ result = DIST_UNKNOWN;
- return result;
+ return result;
}
/*
@@ -362,49 +362,47 @@ verify_dist_type(const char *arg)
static long
to_bytes(const char *arg)
{
- char *buf;
- char *endptr;
- int end;
- int multiplier = 1;
- long result;
-
- buf = strdup(arg);
+ char *buf;
+ char *endptr;
+ int end;
+ int multiplier = 1;
+ long result;
- end = strlen(buf) - 1;
+ buf = strdup(arg);
- if (isdigit(buf[end])) {
- result = strtol(buf, &endptr, 10);
-
- if (*endptr != '\0')
- result = -result;
+ end = strlen(buf) - 1;
- } else {
+ if (isdigit(buf[end])) {
+ result = strtol(buf, &endptr, 10);
+
+ if (*endptr != '\0')
+ result = -result;
- switch(toupper(buf[end])) {
+ } else {
- case 'G':
- multiplier = 1024;
- break;
+ switch(toupper(buf[end])) {
- case 'M':
- /* do nothing */
- break;
+ case 'G':
+ multiplier = 1024;
+ break;
- default:
- multiplier = -1;
- }
+ case 'M':
+ /* do nothing */
+ break;
- buf[end] = '\0';
+ default:
+ multiplier = -1;
+ }
- result = multiplier * strtol(buf, &endptr, 10);
+ buf[end] = '\0';
- if (*endptr != '\0')
- result = -result;
+ result = multiplier * strtol(buf, &endptr, 10);
- }
+ if (*endptr != '\0')
+ result = -result;
+ }
-
- return result;
+ return result;
}
@@ -414,111 +412,117 @@ to_bytes(const char *arg)
static void
set_allocate_mode_env_vars()
{
- int rc;
-
- if (opt.output == IO_ALL) {
- /* all output to single file*/
- rc = setenvf("SLURM_OUTPUT=%s", opt.ofname);
- } else if (opt.output == IO_PER_TASK) {
- /* output is per task, need to put '%' char back */
- rc = setenvf("SLURM_OUTPUT=%s%%", opt.ofname);
- }
-
- if (opt.error == IO_ALL) {
- rc = setenvf("SLURM_ERROR=%s", opt.efname);
- } else if (opt.output == IO_PER_TASK) {
- rc = setenvf("SLURM_ERROR=%s%%", opt.efname);
- }
-
- if (opt.input == IO_ALL) {
- rc = setenvf("SLURM_INPUT=%s", opt.ifname);
- } else if (opt.input == IO_PER_TASK) {
- rc = setenvf("SLURM_INPUT=%s%%", opt.ifname);
- }
+ int rc;
+
+ if (opt.output == IO_ALL) {
+ /* all output to single file*/
+ rc = setenvf("SLURM_OUTPUT=%s", opt.ofname);
+ } else if (opt.output == IO_PER_TASK) {
+ /* output is per task, need to put '%' char back */
+ rc = setenvf("SLURM_OUTPUT=%s%%", opt.ofname);
+ }
+
+ if (opt.error == IO_ALL) {
+ rc = setenvf("SLURM_ERROR=%s", opt.efname);
+ } else if (opt.output == IO_PER_TASK) {
+ rc = setenvf("SLURM_ERROR=%s%%", opt.efname);
+ }
+
+ if (opt.input == IO_ALL) {
+ rc = setenvf("SLURM_INPUT=%s", opt.ifname);
+ } else if (opt.input == IO_PER_TASK) {
+ rc = setenvf("SLURM_INPUT=%s%%", opt.ifname);
+ }
}
/*
* print error message to stderr with opt.progname prepended
*/
+#undef USE_ARGERROR
+#if USE_ARGERROR
static void argerror(const char *msg, ...)
{
- va_list ap;
- char buf[256];
+ va_list ap;
+ char buf[256];
- va_start(ap, msg);
- vsnprintf(buf, sizeof(buf), msg, ap);
+ va_start(ap, msg);
+ vsnprintf(buf, sizeof(buf), msg, ap);
- fprintf(stderr, "%s: %s\n",
- opt.progname ? opt.progname : "srun",
- buf);
- va_end(ap);
+ fprintf(stderr, "%s: %s\n",
+ opt.progname ? opt.progname : "srun",
+ buf);
+ va_end(ap);
}
-
+#else
+# define argerror error
+#endif /* USE_ARGERROR */
+
/*
* opt_default(): used by initialize_and_process_args to set defaults
*/
static void
opt_default()
{
- char buf[MAXPATHLEN+1];
- struct passwd *pw;
+ char buf[MAXPATHLEN+1];
+ struct passwd *pw;
- if ((pw = getpwuid(getuid())) != NULL) {
- strncpy(opt.user, pw->pw_name, MAX_USERNAME);
- opt.uid = pw->pw_uid;
- } else
- argerror("who are you?");
+ if ((pw = getpwuid(getuid())) != NULL) {
+ strncpy(opt.user, pw->pw_name, MAX_USERNAME);
+ opt.uid = pw->pw_uid;
+ } else
+ argerror("who are you?");
- if ((getcwd(buf, MAXPATHLEN)) == NULL) {
- argerror("getcwd failed\n");
- exit(1);
- }
+ if ((getcwd(buf, MAXPATHLEN)) == NULL) {
+ argerror("getcwd failed\n");
+ exit(1);
+ }
+
+ opt.cwd = strdup(buf);
- opt.cwd = strdup(buf);
+ opt.progname = NULL;
+
+ opt.nprocs = 1;
+ opt.cpus = 1;
+ opt.nodes = 1;
+ opt.partition = NULL;
- opt.progname = NULL;
-
- opt.nprocs = 1;
- opt.cpus = 1;
- opt.nodes = 1;
- opt.partition = NULL;
+ opt.job_name = "";
+
+ opt.distribution = DIST_BLOCK;
- opt.job_name = "";
-
- opt.distribution = DIST_BLOCK;
+ opt.output = IO_NORMAL;
+ opt.input = IO_NORMAL;
+ opt.error = IO_NORMAL;
+ opt.ofname = NULL;
+ opt.ifname = NULL;
+ opt.efname = NULL;
- opt.output = IO_NORMAL;
- opt.input = IO_NORMAL;
- opt.error = IO_NORMAL;
- opt.ofname = NULL;
- opt.ifname = NULL;
- opt.efname = NULL;
+ opt.core_format = "normal";
- opt.core_format = "normal";
+ opt.labelio = false;
+ opt.overcommit = false;
- opt.labelio = false;
- opt.overcommit = false;
+ opt.immediate = false;
- opt.immediate = false;
+ opt.allocate = false;
+ opt.attach = NULL;
+ opt.join = false;
- opt.allocate = false;
- opt.attach = NULL;
- opt.join = false;
+ _verbose = 0;
+ _debug = 0;
- verbose = 0;
- debug = 0;
+ /* constraint default (-1 is no constraint) */
+ opt.mincpus = -1;
+ opt.realmem = -1;
+ opt.tmpdisk = -1;
- /* constraint default (-1 is no constraint) */
- opt.mincpus = -1;
- opt.realmem = -1;
- opt.tmpdisk = -1;
- opt.constraints = NULL;
- opt.contiguous = false;
- opt.nodelist = NULL;
+ opt.constraints = NULL;
+ opt.contiguous = false;
+ opt.nodelist = NULL;
- mode = MODE_NORMAL;
+ mode = MODE_NORMAL;
}
@@ -530,277 +534,265 @@ opt_default()
static void
opt_env()
{
- char *val;
- char *end;
- struct env_vars_t *e = env_vars;
-
- while (e->var) {
-
- if (debug > 0)
- fprintf(stderr, "looking for env var %s\n", e->var);
-
- if ((val = getenv(e->var)) != NULL) {
-
- if (debug > 0)
- fprintf(stderr, "now processing env var %s=%s\n",
- e->var, val);
-
- switch (e->type) {
- case OPT_STRING:
- *((char **)e->arg) = strdup(val);
- break;
-
- case OPT_INT:
- if (val != NULL ) {
- *((int *)e->arg) = (int)strtol(val, &end, 10);
-
- if (!(end && *end == '\0')) {
- fprintf(stderr, "%s=%s invalid"
- ". ignoring...\n",
- e->var, val);
- }
- }
- break;
-
- case OPT_DEBUG:
- if (val != NULL) {
- debug = (int) strtol(val, &end, 10);
- if (!(end && *end == '\0')) {
- fprintf(stderr, "%s=%s invalid\n",
- e->var, val);
- }
- }
- break;
-
- case OPT_INPUT:
- case OPT_OUTPUT:
- case OPT_ERROR:
- if (val != NULL) {
- *((char **)e->arg) = strdup(val);
- }
- break;
-
- case OPT_DISTRIB:
- {
- enum distribution_t dt =
- verify_dist_type(val);
-
- if (dt == DIST_UNKNOWN) {
- argerror("\"%s=%s\" -- "
- "invalid distribution type."
- " ignoring...",
- e->var, val);
- } else
- opt.distribution = dt;
-
- }
- break;
-
- default:
- /* do nothing */
- break;
- }
+ char *val;
+ char *end;
+ struct env_vars_t *e = env_vars;
+
+ while (e->var) {
+
+ debug2("looking for env var %s\n", e->var);
+
+ if ((val = getenv(e->var)) != NULL) {
+
+ debug2("now processing env var %s=%s\n", e->var, val);
+ switch (e->type) {
+
+ case OPT_STRING:
+ *((char **)e->arg) = strdup(val);
+ break;
+
+ case OPT_INT:
+ if (val != NULL ) {
+ *((int *)e->arg) = (int)strtol(val, &end, 10);
+
+ if (!(end && *end == '\0')) {
+ error("%s=%s invalid. ignoring...\n", e->var, val);
+ }
+ }
+ break;
+
+ case OPT_DEBUG:
+ if (val != NULL) {
+ _debug = (int) strtol(val, &end, 10);
+ if (!(end && *end == '\0')) {
+ fprintf(stderr, "%s=%s invalid\n", e->var, val);
+ }
+ }
+ break;
+
+ case OPT_INPUT:
+ case OPT_OUTPUT:
+ case OPT_ERROR:
+ if (val != NULL) {
+ *((char **)e->arg) = strdup(val);
+ }
+ break;
+
+ case OPT_DISTRIB:
+ {
+ enum distribution_t dt =
+ verify_dist_type(val);
+
+ if (dt == DIST_UNKNOWN) {
+ argerror("\"%s=%s\" -- invalid distribution type."
+ " ignoring...", e->var, val);
+ } else
+ opt.distribution = dt;
+
+ }
+ break;
+
+ default:
+ /* do nothing */
+ break;
}
- e++;
}
-
+ e++;
+ }
+
+
}
/*
* opt_args() : set options via commandline args and popt
*/
-static void
+ static void
opt_args(int ac, char ** av)
{
- int rc;
- int i;
- bool nprocs_set, nnodes_set, cpus_set;
- const char **rest;
- const char *arg;
- poptContext optctx;
-
- opt.progname = xbasename(av[0]);
-
- optctx = poptGetContext("srun", ac, (const char **)av, options,
- POPT_CONTEXT_POSIXMEHARDER);
-
- poptSetOtherOptionHelp(optctx, "[OPTIONS...] executable [args...]");
-
- poptReadDefaultConfig(optctx, 0);
-
- /* first pass through args to see if attach or allocate mode
- * are set
- */
- while ((rc = poptGetNextOpt(optctx)) > 0) {
- arg = poptGetOptArg(optctx);
-
- switch (rc) {
- case OPT_VERSION:
- print_version();
- exit(0);
- break;
-
- case OPT_ATTACH:
- if (opt.allocate) {
- argerror("cannot simultaneously allocate "
- "and attach");
- exit(1);
- }
- mode = MODE_ATTACH;
- opt.attach = strdup(arg);
- break;
-
- case OPT_ALLOCATE:
- if (opt.attach != NULL) {
- argerror("cannot simultaneously allocate "
- "and attach");
- exit(1);
- }
- mode = MODE_ALLOCATE;
- break;
-
- default:
- break;
- /* do nothing */
+ int rc;
+ int i;
+ bool nprocs_set, nnodes_set, cpus_set;
+ const char **rest;
+ const char *arg;
+ poptContext optctx;
+
+ opt.progname = xbasename(av[0]);
+
+ optctx = poptGetContext("srun", ac, (const char **)av, options,
+ POPT_CONTEXT_POSIXMEHARDER);
+
+ poptSetOtherOptionHelp(optctx, "[OPTIONS...] executable [args...]");
+
+ poptReadDefaultConfig(optctx, 0);
+
+ /* first pass through args to see if attach or allocate mode
+ * are set
+ */
+ while ((rc = poptGetNextOpt(optctx)) > 0) {
+ arg = poptGetOptArg(optctx);
+
+ switch (rc) {
+ case OPT_VERSION:
+ print_version();
+ exit(0);
+ break;
+
+ case OPT_ATTACH:
+ if (opt.allocate) {
+ argerror("cannot simultaneously allocate and attach");
+ exit(1);
}
+ mode = MODE_ATTACH;
+ opt.attach = strdup(arg);
+ break;
+
+ case OPT_ALLOCATE:
+ if (opt.attach != NULL) {
+ argerror("cannot simultaneously allocate and attach.");
+ exit(1);
+ }
+ mode = MODE_ALLOCATE;
+ break;
+
+ default:
+ break;
+ /* do nothing */
}
+ }
+
+
+ poptResetContext(optctx);
+
+ nprocs_set = false;
+ nnodes_set = false;
+ cpus_set = false;
+
+ while ((rc = poptGetNextOpt(optctx)) > 0) {
+ arg = poptGetOptArg(optctx);
- poptResetContext(optctx);
-
- nprocs_set = false;
- nnodes_set = false;
- cpus_set = false;
-
-
- while ((rc = poptGetNextOpt(optctx)) > 0) {
- arg = poptGetOptArg(optctx);
-
- switch (rc) {
- case OPT_VERBOSE:
- verbose++;
- break;
-
- case OPT_DEBUG:
- debug++;
- break;
-
- case OPT_OUTPUT:
- opt.ofname = strdup(arg);
- opt.output = verify_iotype(&opt.ofname);
- break;
-
- case OPT_INPUT:
- opt.ifname = strdup(arg);
- opt.input = verify_iotype(&opt.ifname);
- break;
-
- case OPT_ERROR:
- opt.efname = strdup(arg);
- opt.error = verify_iotype(&opt.efname);
- break;
-
- case OPT_DISTRIB:
- opt.distribution = verify_dist_type(arg);
- if (opt.distribution == DIST_UNKNOWN) {
- argerror("Error: distribution type `%s' "
- "is not recognized", arg);
- poptPrintUsage(optctx, stderr, 0);
- exit(1);
- }
- break;
-
- case OPT_NPROCS:
- nprocs_set = true;
- break;
-
- case OPT_CPUS:
- cpus_set = true;
- break;
-
- case OPT_NODES:
- nnodes_set = true;
- break;
-
- case OPT_REALMEM:
- opt.realmem = (int) to_bytes(arg);
- if (opt.realmem < 0) {
- argerror("Error: invalid memory constraint %s",
- arg);
- exit(1);
- }
- break;
-
- case OPT_TMPDISK:
- opt.tmpdisk = to_bytes(arg);
- if (opt.tmpdisk < 0) {
- argerror("Error: invalid tmp disk constraint %s",
- arg);
- exit(1);
- }
- break;
-
- case OPT_CDDIR:
- free(opt.cwd);
- opt.cwd = strdup(arg);
- break;
-
- case OPT_JOIN:
- if (opt.attach == NULL) {
- argerror("Error: --join only makes sense "
- "with --attach");
- exit(1);
- }
- opt.join = true;
- break;
-
- case OPT_STEAL:
- if (opt.attach == NULL) {
- argerror("Error: --steal only makes sense "
- "with --attach");
- exit(1);
- }
- opt.join = false;
- break;
-
- default:
- break;
- /* do nothing */
+ switch (rc) {
+ case OPT_VERBOSE:
+ _verbose++;
+ break;
+
+ case OPT_DEBUG:
+ _debug++;
+ break;
+
+ case OPT_OUTPUT:
+ opt.ofname = strdup(arg);
+ opt.output = verify_iotype(&opt.ofname);
+ break;
+
+ case OPT_INPUT:
+ opt.ifname = strdup(arg);
+ opt.input = verify_iotype(&opt.ifname);
+ break;
+
+ case OPT_ERROR:
+ opt.efname = strdup(arg);
+ opt.error = verify_iotype(&opt.efname);
+ break;
+
+ case OPT_DISTRIB:
+ opt.distribution = verify_dist_type(arg);
+ if (opt.distribution == DIST_UNKNOWN) {
+ argerror("Error: distribution type `%s' is not recognized", arg);
+ poptPrintUsage(optctx, stderr, 0);
+ exit(1);
}
- }
-
+ break;
+
+ case OPT_NPROCS:
+ nprocs_set = true;
+ break;
+
+ case OPT_CPUS:
+ cpus_set = true;
+ break;
+
+ case OPT_NODES:
+ nnodes_set = true;
+ break;
+
+ case OPT_REALMEM:
+ opt.realmem = (int) to_bytes(arg);
+ if (opt.realmem < 0) {
+ argerror("Error: invalid memory constraint %s",
+ arg);
+ exit(1);
+ }
+ break;
+
+ case OPT_TMPDISK:
+ opt.tmpdisk = to_bytes(arg);
+ if (opt.tmpdisk < 0) {
+ argerror("Error: invalid tmp disk constraint %s",
+ arg);
+ exit(1);
+ }
+ break;
- if (rc < -1) {
- argerror("bad argument %s: %s",
- poptBadOption(optctx, POPT_BADOPTION_NOALIAS),
- poptStrerror(rc));
- poptPrintUsage(optctx, stderr, 0);
+ case OPT_CDDIR:
+ free(opt.cwd);
+ opt.cwd = strdup(arg);
+ break;
- exit(1);
- }
+ case OPT_JOIN:
+ if (opt.attach == NULL) {
+ argerror("Error: --join only makes sense with --attach");
+ exit(1);
+ }
+ opt.join = true;
+ break;
- rest = poptGetArgs(optctx);
- remote_argc = 0;
+ case OPT_STEAL:
+ if (opt.attach == NULL) {
+ argerror("Error: --steal only makes sense with --attach");
+ exit(1);
+ }
+ opt.join = false;
+ break;
- if (rest != NULL) {
- while (rest[remote_argc] != NULL)
- remote_argc++;
+ default:
+ break;
+ /* do nothing */
}
+ }
- remote_argv = (char **) malloc(remote_argc*sizeof(char *));
- for (i = 0; i < remote_argc; i++)
- remote_argv[i] = strdup(rest[i]);
+ if (rc < -1) {
+ argerror("bad argument %s: %s",
+ poptBadOption(optctx, POPT_BADOPTION_NOALIAS),
+ poptStrerror(rc));
+ poptPrintUsage(optctx, stderr, 0);
- if (!opt_verify(optctx, nnodes_set, cpus_set, nprocs_set)) {
- poptPrintUsage(optctx, stderr, 0);
- exit(1);
- }
+ exit(1);
+ }
- poptFreeContext(optctx);
+ rest = poptGetArgs(optctx);
+ remote_argc = 0;
+
+ if (rest != NULL) {
+ while (rest[remote_argc] != NULL)
+ remote_argc++;
+ }
+
+ remote_argv = (char **) malloc(remote_argc*sizeof(char *));
+
+ for (i = 0; i < remote_argc; i++)
+ remote_argv[i] = strdup(rest[i]);
+
+ if (!opt_verify(optctx, nnodes_set, cpus_set, nprocs_set)) {
+ poptPrintUsage(optctx, stderr, 0);
+ exit(1);
+ }
+
+ poptFreeContext(optctx);
}
@@ -810,209 +802,204 @@ opt_args(int ac, char ** av)
*/
static bool
opt_verify(poptContext optctx,
- bool nodes_set, bool cpus_set, bool procs_set)
+ bool nodes_set, bool cpus_set, bool procs_set)
{
- bool verified = true;
+ bool verified = true;
- if (mode == MODE_ATTACH) { /* attach to a running job */
- if (nodes_set || cpus_set || procs_set) {
- argerror("do not specific a node allocation "
- "with --attach (-a)");
- verified = false;
- }
+ if (mode == MODE_ATTACH) { /* attach to a running job */
+ if (nodes_set || cpus_set || procs_set) {
+ argerror("do not specific a node allocation "
+ "with --attach (-a)");
+ verified = false;
+ }
- if (constraints_given()) {
- argerror("do not specify any constraints with "
- "--attach (-a)");
- verified = false;
- }
+ if (constraints_given()) {
+ argerror("do not specify any constraints with "
+ "--attach (-a)");
+ verified = false;
+ }
- /* XXX check here to see if job to attach to exists ? */
-
- /* XXX what other args are incompatible with attach mode? */
-
- } else {
-
- if (mode == MODE_ALLOCATE) {
-
- /*
- if (remote_argc > 0) {
- argerror("Error: do not specify a remote "
- "command with --allocate (-A)");
- verified = false;
- }
- */
-
- /* set output/input/err (an whatever else) as
- * env vars so they will be "defaults" in allocate
- * subshell
- */
- set_allocate_mode_env_vars();
-
- } else {
-
- if (remote_argc == 0) {
- argerror("Error: must supply remote command");
- verified = false;
- }
- }
+ /* XXX check here to see if job to attach to exists ? */
+ /* XXX what other args are incompatible with attach mode? */
- /* check for realistic arguments */
- if (opt.nprocs <= 0) {
- fprintf(stderr, "%s: invalid number of processes (-n %d)\n",
- opt.progname, opt.nprocs);
- verified = false;
- }
+ } else {
- if (opt.cpus <= 0) {
- fprintf(stderr, "%s: invalid number of cpus per process"
- "(-n %d)\n", opt.progname, opt.cpus);
- verified = false;
- }
+ if (mode == MODE_ALLOCATE) {
- if (opt.nodes <= 0) {
- fprintf(stderr, "%s: invalid number of nodes (-N %d)\n",
- opt.progname, opt.nodes);
- verified = false;
- }
+ /*
+ if (remote_argc > 0) {
+ argerror("Error: do not specify a remote "
+ "command with --allocate (-A)");
+ verified = false;
+ }
+ */
+
+ /* set output/input/err (an whatever else) as
+ * env vars so they will be "defaults" in allocate
+ * subshell
+ */
+ set_allocate_mode_env_vars();
+
+ } else {
- /* massage the numbers */
- if (nodes_set && !procs_set) {
- /* 1 proc / node default */
- opt.nprocs = opt.nodes;
+ if (remote_argc == 0) {
+ argerror("Error: must supply remote command");
+ verified = false;
+ }
+ }
- } else if (nodes_set && procs_set) {
- /* make sure # of procs >= nodes */
- if (opt.nprocs < opt.nodes) {
+ /* check for realistic arguments */
+ if (opt.nprocs <= 0) {
+ fprintf(stderr, "%s: invalid number of processes (-n %d)\n",
+ opt.progname, opt.nprocs);
+ verified = false;
+ }
- argerror("Warning: can't run %d "
- "processes on %d nodes, setting "
- "nodes to %d", opt.nprocs,
- opt.nodes, opt.nprocs);
+ if (opt.cpus <= 0) {
+ fprintf(stderr, "%s: invalid number of cpus per process (-n %d)\n",
+ opt.progname, opt.cpus);
+ verified = false;
+ }
- opt.nodes = opt.nprocs;
- }
+ if (opt.nodes <= 0) {
+ fprintf(stderr, "%s: invalid number of nodes (-N %d)\n",
+ opt.progname, opt.nodes);
+ verified = false;
+ }
- } else if (procs_set && !nodes_set) {
+ /* massage the numbers */
+ if (nodes_set && !procs_set) {
+ /* 1 proc / node default */
+ opt.nprocs = opt.nodes;
- opt.nodes = opt.nprocs;
+ } else if (nodes_set && procs_set) {
- }
+ /* make sure # of procs >= nodes */
+ if (opt.nprocs < opt.nodes) {
+ argerror("Warning: can't run %d processes on %d nodes, setting "
+ "nodes to %d", opt.nprocs, opt.nodes, opt.nprocs);
+ opt.nodes = opt.nprocs;
+ }
+ } else if (procs_set && !nodes_set) {
+ opt.nodes = opt.nprocs;
}
+ }
+
- return verified;
+ return verified;
}
#ifdef __DEBUG
/* generate meaningful output message based on io type and "filename" */
-char *
+ char *
print_io_t_with_filename(enum io_t type, char *filename)
{
- char buf[256];
-
- switch (type) {
- case IO_ALL:
- snprintf(buf, 256, "%s (file `%s')",
- format_io_t(type),
- filename);
- break;
-
- case IO_PER_TASK:
- snprintf(buf, 256, "%s (file `%s<task_id>')",
- format_io_t(type),
- filename);
- break;
-
- case IO_NORMAL:
- snprintf(buf, 256, "normal");
- break;
-
- default:
- snprintf(buf, 256, "error, unknown type");
- break;
- }
- return strdup(buf);
+ char buf[256];
+
+ switch (type) {
+ case IO_ALL:
+ snprintf(buf, 256, "%s (file `%s')",
+ format_io_t(type),
+ filename);
+ break;
+
+ case IO_PER_TASK:
+ snprintf(buf, 256, "%s (file `%s<task_id>')",
+ format_io_t(type),
+ filename);
+ break;
+
+ case IO_NORMAL:
+ snprintf(buf, 256, "normal");
+ break;
+
+ default:
+ snprintf(buf, 256, "error, unknown type");
+ break;
+ }
+ return strdup(buf);
}
-static char *
+ static char *
print_constraints()
{
- char buf[256];
+ char buf[256];
- buf[0] = '\0';
+ buf[0] = '\0';
- if (opt.mincpus > 0)
- snprintf(buf, 256, "mincpus=%d", opt.mincpus);
+ if (opt.mincpus > 0)
+ snprintf(buf, 256, "mincpus=%d", opt.mincpus);
- if (opt.realmem > 0)
- snprintf(buf, 256, "%s mem=%dM", buf, opt.realmem);
+ if (opt.realmem > 0)
+ snprintf(buf, 256, "%s mem=%dM", buf, opt.realmem);
- if (opt.tmpdisk > 0)
- snprintf(buf, 256, "%s tmp=%ldM", buf, opt.tmpdisk);
+ if (opt.tmpdisk > 0)
+ snprintf(buf, 256, "%s tmp=%ldM", buf, opt.tmpdisk);
- if (opt.contiguous == true)
- snprintf(buf, 256, "%s contiguous", buf);
+ if (opt.contiguous == true)
+ snprintf(buf, 256, "%s contiguous", buf);
- if (opt.nodelist != NULL)
- snprintf(buf, 256, "%s nodelist=%s", buf, opt.nodelist);
+ if (opt.nodelist != NULL)
+ snprintf(buf, 256, "%s nodelist=%s", buf, opt.nodelist);
- if (opt.constraints != NULL)
- snprintf(buf, 256, "%s constraints=`%s'", buf,
- opt.constraints);
+ if (opt.constraints != NULL)
+ snprintf(buf, 256, "%s constraints=`%s'", buf,
+ opt.constraints);
- return strdup(buf);
+ return strdup(buf);
}
-static void
+#define tf_(b) (b == true) ? "true" : "false"
+
+ static void
opt_list()
{
- int i;
-
- printf("\ndefined options for program `%s'\n", opt.progname);
- printf("------------ ---------------------\n");
-
- printf("user : `%s'\n", opt.user);
- printf("uid : %ld\n" , (long)opt.uid);
- printf("cwd : %s\n" , opt.cwd);
- printf("nprocs : %d\n", opt.nprocs);
- printf("cpus/proc : %d\n", opt.cpus);
- printf("nodes : %d\n", opt.nodes);
- printf("total cpus : %d\n", opt.nprocs * opt.cpus);
- printf("partition : %s\n",
- opt.partition == NULL ? "default" : opt.partition);
- printf("job name : `%s'\n", opt.job_name);
- printf("distribution: %s\n",
- format_distribution_t(opt.distribution));
- printf("output : %s\n",
- print_io_t_with_filename(opt.output, opt.ofname));
- printf("error : %s\n",
- print_io_t_with_filename(opt.error, opt.efname));
- printf("input : %s\n",
- print_io_t_with_filename(opt.input, opt.ifname));
- printf("core format : %s\n", opt.core_format);
- printf("verbose : %d\n" , verbose);
- printf("debug : %d\n" , debug);
- printf("immediate : %s\n" , tf_(opt.immediate));
- printf("label output: %s\n" , tf_(opt.labelio));
- printf("allocate : %s\n" , tf_(opt.allocate));
- printf("attach : `%s'\n", opt.attach);
- printf("overcommit : %s\n" , tf_(opt.overcommit));
- printf("\n");
- printf("constraints : %s\n" , print_constraints());
- printf("\n");
- printf("remote command :");
-
- for (i = 0; i < remote_argc; i++)
- printf(" %s", remote_argv[i]);
- printf("\n");
+ int i;
+
+ info("\ndefined options for program `%s'\n", opt.progname);
+ info("------------ ---------------------\n");
+
+ info("user : `%s'", opt.user);
+ info("uid : %ld" , (long)opt.uid);
+ info("cwd : %s" , opt.cwd);
+ info("nprocs : %d", opt.nprocs);
+ info("cpus/proc : %d", opt.cpus);
+ info("nodes : %d", opt.nodes);
+ info("total cpus : %d", opt.nprocs * opt.cpus);
+ info("partition : %s",
+ opt.partition == NULL ? "default" : opt.partition);
+ info("job name : `%s'", opt.job_name);
+ info("distribution: %s",
+ format_distribution_t(opt.distribution));
+ info("output : %s",
+ print_io_t_with_filename(opt.output, opt.ofname));
+ info("error : %s",
+ print_io_t_with_filename(opt.error, opt.efname));
+ info("input : %s",
+ print_io_t_with_filename(opt.input, opt.ifname));
+ info("core format : %s", opt.core_format);
+ info("verbose : %d" , _verbose);
+ info("debug : %d" , _debug);
+ info("immediate : %s" , tf_(opt.immediate));
+ info("label output: %s" , tf_(opt.labelio));
+ info("allocate : %s" , tf_(opt.allocate));
+ info("attach : `%s'", opt.attach);
+ info("overcommit : %s" , tf_(opt.overcommit));
+ info(" ");
+ info("constraints : %s" , print_constraints());
+ info(" ");
+ fprintf(stderr, "remote command :");
+
+ for (i = 0; i < remote_argc; i++)
+ fprintf(stderr, " %s", remote_argv[i]);
+ fprintf(stderr, "\n");
}
#endif /* __DEBUG */
-
diff --git a/src/srun/opt.h b/src/srun/opt.h
index 4f9dd5d4dfd..cdab3127e36 100644
--- a/src/srun/opt.h
+++ b/src/srun/opt.h
@@ -33,8 +33,8 @@ typedef enum {false, true} bool;
/* global variables relating to user options */
char **remote_argv;
int remote_argc;
-int debug;
-int verbose;
+int _debug;
+int _verbose;
/* mutually exclusive modes for srun */
enum modes {
diff --git a/src/srun/srun.c b/src/srun/srun.c
index da15913e9b3..27e1261da39 100644
--- a/src/srun/srun.c
+++ b/src/srun/srun.c
@@ -1,4 +1,4 @@
-/* */
+/* $Id$ */
#ifdef HAVE_CONFIG_H
# include <config.h>
@@ -11,17 +11,33 @@
#include <stdio.h>
#include <stdlib.h>
+#include <src/common/log.c>
+
#include <opt.h>
#include <env.h>
+/*
+ * forward declaration of static funcs
+ */
+static void create_job_spec(void);
+
int
main(int ac, char **av)
{
+ log_options_t logopt = LOG_OPTS_STDERR_ONLY;
+
+ log_init(xbasename(av[0]), logopt, 0, NULL);
+
/* set default options, process commandline arguments, and
* verify some basic values
*/
initialize_and_process_args(ac, av);
+ /* now global "opt" should be filled in and available,
+ * create a job_spec from opt
+ */
+
exit(0);
}
+
--
GitLab