From:	CRDGW2::CRDGW2::MRGATE::"SMTP::CRVAX.SRI.COM::RELAY-INFO-VAX" 13-AUG-1989 15:43
To:	MRGATE::"ARISIA::EVERHART"
Subj:	Re: Chain_submit

Received: From KL.SRI.COM by CRVAX.SRI.COM with TCP; Sun, 13 AUG 89 11:45:48 PDT
Received: from ucbvax.Berkeley.EDU by KL.SRI.COM with TCP; Sun, 13 Aug 89 11:38:08 PDT
Received: by ucbvax.Berkeley.EDU (5.61/1.37)
	id AA03015; Sun, 13 Aug 89 11:09:45 -0700
Received: from USENET by ucbvax.Berkeley.EDU with netnews
	for info-vax@kl.sri.com (info-vax@kl.sri.com)
	(contact usenet@ucbvax.Berkeley.EDU if you have questions)
Date: 11 Aug 89 04:43:08 GMT
From: uhccux!munnari.oz.au!otc!metro!basser!usage!ccadfa!anucsd!bdm@ames.arc.nasa.gov  (Brendan McKay)
Organization: Computer Science, Australian National Uni, Canberra
Subject: Re: Chain_submit
Message-Id: <1104@anucsd.oz>
References: <890809094422.0000496D0B1@grouch.JPL.NASA.GOV>
Sender: info-vax-request@kl.sri.com
To: info-vax@kl.sri.com


I have a product called AUTOMAN4, written in VMS Pascal, which in effect
implements a private queue for batch jobs.  It provides for far more
detailed control over priorities and dependencies between jobs than do the
regular batch queues.  It does not require special privileges and does
not use extra processes.  It works.

The HELP file is appended below.  I am NOT prepared to post the program,
or to e-mail it to sites outside Australia.  However, I'll be happy to
provide a copy to anyone who sends me a tape (small half-inch tape; I'll
write it at 1600bpi in BACKUP format) or $US20 to buy one.  The cost is
NIL if you don't work for a military organization or on a project funded
by one.  If you do fit one of those categories, sorry you can't have it.
[flame away...]  It is NOT public-domain.

The tape will contain .OBJ files so that you can link it even if you don't
have a Pascal compiler.

Brendan McKay
Computer Science Dpeartment
Australian National University
GPO Box 4, ACT 2601
Australia.

e-mail:  bdm@anucsd.oz   or   bdm@anucsd.oz.au
fax:  +61 62 480 026

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

1 AUTOMAN4
   Private queue system.  Version 2.1.

  Usage:

   @USRDISK1:[DCS.SUPER.AUTOMAN]SETUP
   AUTOMAN4  [file[,...]]

2 Overview
   AUTOMAN4 is a program which can be used to maintain a queue of jobs,
   here called "entries", in a similar (but smarter) manner to that used
   by the VMS batch queues.  Its intended purpose is to enable its user
   to make maximum use of a single batch run, and to "submit" an arbitrary
   number of jobs without the need to put them all into the regular queues.

   Features not offered by the regular queues include
       * dependencies between entries (see /PREREQUISITES and /STREAM)
       * automatic resubmission a controllable number of times
                (see /CYCLES,/STOPCYCLE and /RESUBDELAY)
       * scheduling according to cpu time available (see Scheduling).
       * allowance for the differing speeds of processors in a network
                (see /DEFAULTS=BENCHMARK and /SCALED)
       * user control over defaults such as log-file location

   There are seven major functions of AUTOMAN4:

        AUTOMAN4/HELP             - what it says
        AUTOMAN4/INITIALIZE       - create empty queue
        AUTOMAN4/DELETE/ENTRY=n   - delete entry(s) from queue
        AUTOMAN4/SIGNAL/ENTRY=n   - force exit of image running in entry
        AUTOMAN4/RUN              - choose an entry for running
        AUTOMAN4/ENTRY=n          - modify existing entry(s)
        AUTOMAN4 file,...         - insert new entry(s)

2 Examples

   To define the AUTOMAN4 command, use
     @[<fill this in>.AUTOMAN]SETUP
   (This is conveniently done in your LOGIN.COM file.
    The command can be abbreviated as AU.)

   To initialize a queue file:
    $ AU/INIT

   To insert the command file TEST.COM into the queue, with MINIMUM
   cpu requirements of 2 hours and 30 minutes:
    $ AU TEST/CPU=2:30

   To examine the contents of the queue:
    $ AU/SHOW
        (Use /PEEK instead of /SHOW to get a briefer listing. )

   In order to manipulate an entry already in the queue, you need to know
   its entry number.  This is the first item given for the entry by both
   /PEEK and /SHOW.  Suppose there is an entry numbered 97.

   To examine this entry alone:
    $ AU/ENTRY=97/SHOW=S

   To modify the priority and log file of the entry:
    $ AU/ENTRY=97/PRIO=6/LOG=[]FRED

   To delete the entry:
    $ AU/ENTRY=97/DELETE

   To select an entry for running:
    $ AU/RUN
   This would normally be done by a batch job such as the one given under
   Drivers.  The effect is to choose an entry which is eligible to run,
   as determined by its cpu requirements etc..  The full rules are given
   under Scheduling.  This entry is put into state CURR and a lot of
   logical names and symbols are defined which can then be used to
   execute the entry.  See /RUN for more details.  The next time you
   run AUTOMAN4 from the same process, AUTOMAN4 assumes that you have
   finished with that entry and deletes it from the queue (but see
   /STILLRUNNING).  AUTOMAN4 is smart enough not to touch a CURR entry
   put into that state by another process, including a process on
   another machine on the same cluster.

2 Drivers
   The intended use of AUTOMAN4 is that it be driven by a command file
   run as a batch job.  There are a number of ways of doing this.  The
   method below has proved itself well.

   The file AUTOMAN_SYS:AUTOSHELL.COM contains these commands:

 $ write sys$output - ! 'f$verify(0)
 "AUTOMAN entry started on ''f$getsyi("NODENAME")' at ''f$time()'."
 $ write sys$output -
 "Command file:  ''f$logical("AUTOMAN_COM")'"
 $ write sys$output ""
 $ cpu_start = f$getjpi("","CPUTIM")
 $ set noon
 $ set verify
 $ @AUTOMAN_COM 'AUTOMAN_PARAM' -
 !-----------------------------------------------------------------------
 !-----------------------------------------------------------------------
 $ cpu_end = f$getjpi("","CPUTIM")   ! 'f$verify(0)
 $ cpu_used = (cpu_end - cpu_start + 50) / 100
 $ cpu_min = cpu_used / 60
 $ cpu_sec = cpu_used - 60 * cpu_min
 $ write sys$output ""
 $ write sys$output "AUTOMAN entry finished on ''f$getsyi("NODENAME")'",-
 " at ''f$time()'.  Cpu used = ''cpu_min':''cpu_sec'."

   It assumes that the logical name AUTOMAN_COM points at the command
   file to be run and that the DCL symbol AUTOMAN_PARAM contains the
   parameter list.  These are defined by AUTOMAN4 when /RUN is used (q.v.).

   The following command file can now by run as a batch job.  It is
   available as AUTOMAN_SYS:AUTODRIVER.COM.

 $! driver job for AUTOMAN4
 $
 $! this job could resubmit itself here
 $
 $ set message AUTOMAN_SYS:automess
 $ info = "Running on node ''f$getsyi("NODENAME")'."
 $
 $run_loop:
 $ on error then goto bomb
 $
 $ if f$search("sys$login:automan4.halt") .nes. "" then goto req_halt
 $ AUTOMAN_OK = "F"
 $ AUTOMAN4/run/sh=s              ! get next job to run, if any
 $ if .not. AUTOMAN_OK then goto finished
 $ cpu_start_pts = f$getjpi("","cputim") / 100         ! in seconds
 $ cpu_min = cpu_start_pts / 60
 $ cpu_sec = cpu_start_pts - cpu_min * 60
 $ info = "running job at ''f$time()'; cpu = ''cpu_min':''cpu_sec'"
 $ assign sys$output sys$error
 $ set noon
 $ set process/name="''AUTOMAN_ID'"
 $
 $ set default sys$login
 $ open/write/share AUTOMAN_OUT AUTOMAN_LOG
 $ @AUTOMAN_SYS:AUTOSHELL/output=AUTOMAN_OUT                     ! run it
 $ close AUTOMAN_OUT
 $
 $ set verify
 $ cpu_finish_pts = f$getjpi("","cputim") / 100         ! in seconds
 $ cpu_min = cpu_finish_pts / 60
 $ cpu_sec = cpu_finish_pts - cpu_min * 60
 $ info = "finished at ''f$time()'; cpu = ''cpu_min':''cpu_sec'"
 $ if f$logical("sys$error") .nes. f$logical("sys$output") then -
   deassign sys$error
 $ goto run_loop
 $finished:
 $ info = "that's all till next time"
 $ AUTOMAN4/peek
 $ exit
 $bomb:
 $ info = "error condition encountered"
 $ exit
 $req_halt:
 $ info = "halting as per request"
 $ del sys$login:automan4.halt;
 $ AUTOMAN4/peek

   The action of this command file is to repeatedly select entries from
   the AUTOMAN4 queue and run them.  This continues until no entries are
   eligible to run.  The log file for each entry will contain a header
   giving the host name, the date-time and the command file name, and a
   trailer giving the termination time and the cpu used (as mm:ss).

   To get the batch job to exit after completing the execution of the
   current entry, create a file SYS$LOGIN:AUTOMAN4.HALT.  The job will
   delete that file and stop before attempting to run another entry.
   Alternately, use the /DIEAFTER qualifier on the current entry.

   To abort execution of the current entry without aborting the whole job,
   see /SIGNAL.

   The /SIGNAL command requires the use of a remote server when the
   process to receive the signal is on another machine.  The file
   AUTOMAN_SYS:AUTOREMOTE.COM suffices:

 $! network object for AUTOMAN4
 $! simply get one line and execute it as a DCL command
 $ open/write link sys$net:
 $ read link line
 $ define/nolog sys$output link
 $ define/nolog sys$error link
 $ 'line'
 $ close link
 $ exit

   See Installing_AUTOMAN4 (under FinePrint) for more details.

2 Scheduling
   The "most eligible entry to run" is chosen from those entries in
   state PEND which have no unsatisfied prerequisites, whose cpu
   requirements are less than the available cpu time for the current
   process (allowing 10 sec. safety margin; also see /SCALED) and which
   are not in the same non-zero stream as an entry already in CURR or
   DEAD state.
   Out of those entries, an entry is sought with the greatest priority
   and, subject to that, the earliest submission time and, subject to
   that, the smallest entry number.

   Entry numbers are always in order of the original submission, and
   never change.  The submission time is updated when an entry changes
   from state AFTE to state PEND.

   At most one entry can be "run" at any one time by any one process.
   When AUTOMAN4 is executed, any existing CURR entry for the current
   process is deleted from the queue (but see /STILLRUNNING).

2 FinePrint
3 Errors
   AUTOMAN4 reports errors and returns an error status by the usual
   VMS mechanism.  The table below lists AUTOMAN4's own status values.
   It is also possible to get error or fatal status values from the
   Pascal system, from the CLI system (e.g. unknown qualifier), from
   RMS and from DCL.

   value(hex)  name    severity          meaning

       1        -      SUCCESS   Everything succeeded.
   080280A0  NORUNENT  WARNING   /RUN was given, but there is no entry
                                  in the queue eligible to run.
   080280A8  NOENTNUM  WARNING   /DELETE was given, but no entry was
                                  named for deletion.
   180280B0  DUPPRE    WARNING   Duplicate entry specified (and ignored)
                                  for /PREREQUISITES qualifier.
   080280C8  DIEAFTER  WARNING   /RUN was given, but no entry was selected
                                  due to /DIEAFTER flag on previous CURR entry
   180280D0  VALTRUNC  WARNING   String-valued qualifier truncated.
   180280D8  ENTTRUNC  WARNING   AUTOMAN_ENTRY is limited to 255 characters.
   180280FC  ILLVALQ    FATAL    Illegal value for qualifier.
   18028104  NONEXENT   FATAL    Nonexistent entry named on /ENTRY or
                                  /PREREQUISITES qualifier.
   1802810C  NONEXCF    FATAL    Nonexistent command file given.
   18028114  QUELCKD    FATAL    The queue file is locked against
                                  access.  See Glitches.
   1802811C  BADQUEUE   FATAL    The queue file has illegal structure.
                                  (usually unexpected end-of-file)
   18028124  INITFAIL   FATAL    Unable to initialize queue file.
   1802812C  CANTSIG    FATAL    Attempt to send signal to nonexistent
                                  process or can't access network object
                                  on remote host.
   1802813C  NRFBENCH   FATAL    No room left to store host names and
                                  benchmark data.
   18028144  NRFENTRY   FATAL    No room for new entry.
   1802814C  CPUTIM     FATAL    Insufficient cpu time is remaining to
                                  modify the queue file safely.  It has been
                                  left in its previous state.
3 Glitches
   Access to queue file:  The nature of AUTOMAN4 is such that only one
   process at a time can have access to the queue file.  On the rare
   occasions when a conflict occurs (eg. you list the queue while a
   batch job is executing AUTOMAN4), the program will wait for access.
   It will only give up after trying every two seconds for one minute
   (if the process base priority is >= 4), or every ten seconds for
   five minutes (otherwise).

   Size limitations:  There is a limit of 2000 entries in the queue.
   The parameter list must have at most 255 characters altogether, after
   quotes have been doubled, parameters have been quoted (if necessary),
   and spaces have been inserted between parameters.  The comment string is
   limited to 80 characters.  The identification string is limited to
   15 characters.  Warnings will be issued if these bounds are exceeded.

   Dead entries:  When AUTOMAN4 is run on a network of more than one
   host, it is possible for an entry to remain in the queue in CURR
   state even though the process which put it there has died.  This
   is because it is too difficult to determine the existence or
   otherwise of a process on a host other than the current host. If
   a process dies before its CURR entry is removed (e.g. the machine
   crashes), that process will remain in the queue until AUTOMAN4 is
   run again on the same host, or until you remove that entry by hand.

3 Miscellaneous
   (1) When an entry is inserted, the entry number it is assigned is also
   assigned to the local DCL symbol AUTOMAN_ENTRY.  If more than one
   insertion is made at the same time, the value of AUTOMAN_ENTRY is
   a list of entry numbers, separated by commas.
   This feature enables batch jobs which insert entries to later delete
   or modify them, or to specify them as prerequisites for other entries.
   Note that entry numbers are unique for the life of the queue.  They
   are never reused.

   (2) The queue is maintained in a sequential file, with each entry
   occupying one record of 1024 bytes.  The first record holds the
   defaults for cpu time, etc..  The next 1-5 records hold a list of
   known hosts names and their benchmark figures (see /DEFAULTS).
   AUTOMAN4 operates by reading the entire file into memory, performing
   the requested operations, then writing the modified file back again.

   The following cleanup operations are performed as the file is read:
   (a) Any CURR entry which was put into that state by the current
   process is deleted, unless /STILLRUNNING is specified (qv).
   (b) Any CURR entry which was put into that state by a process on the
   current host which has since died is examined.  If it has been marked
   /CRITICAL, it is put into state DEAD.  Otherwise, it is listed then
   deleted.  In either case a warning message is issued.  AUTOMAN4 identifies
   processes by a (host,boot-time,pid) triple, to make identification safe.
   (c) Any AFTE entry for which the required time has past is changed
   to state PEND.

3 Qualifier_placement
   The qualifiers /CPUTIME, /SCALED, /LOG_FILE, /STREAM, /PRIORITY,
   /RESUBDELAY, /CYCLES, /COMMENTS, /IDENTIFICATION, /PARAMETERS,
   /PREREQUISITES, /DIEAFTER, /CRITICAL, /HOLD and /AFTER are positional.
   This means that they can be applied individually to the command files
   in an insertion command.  Alternatively, they can be applied to the verb
   (i.e. AUTOMAN4), in which case they apply to all input files except
   those for which they have been explicitly negated.

   The effect of this on a modification request (with /ENTRY) is
   determinable by experiment.  It is suggested that these qualifiers
   are only applied to the verb in this case.

3 Installing_AUTOMAN4

   The following command file can construct AUTOMAN4:

 $! making AUTOMAN4.EXE and AUTOMESS.EXE from AUTOMAN4.PAS (Pascal source),
 $!  AUTOMAN4.CLD (CDU source) and AUTOMAN4.MSG (Error message source) :
 $!
 $! if desired, edit "installation defaults":
 $!
 $!      const section of AUTOMAN4.PAS -
 $!            default_cpumin, default_resubdelay, default_priority,
 $!            default_logfile, default_queuename, help_command.
 $
 $ pascal/optim automan4                     ! makes automan4.obj
 $ message automan4/object=automess          ! makes automess.obj
 $ set commmand automan4/object=autotabs     ! makes autotabs.obj
 $ link/notrace automan4,autotabs,automess   ! makes automan4.exe
 $ link/share automess                       ! makes automess.exe
 $
 $! making help library AUTOMAN4.HLB from help source AUTOMAN4.HLP :
 $! Edit AUTOMAN4.HLP to reflect any changes made to AUTOMAN4.PAS.
 $
 $ library/create=block:76/help automan4 automan4

   To use automan4, two logical names and one symbol are required.
     AUTOMAN_SYS  is the directory which should hold AUTOMAN4.EXE,
                  AUTOMESS.EXE, AUTOMAN4.HLB, AUTODRIVER.COM,
                  AUTOSHELL.COM and AUTOREMOTE.COM.
     AUTOMAN_REM  is a command file which can service a remote /signal
                  request.  It must be visible to network jobs.  See
                  Drivers for a sample.
     AUTOMAN4 :== $AUTOMAN_SYS:AUTOMAN4 defines the AUTOMAN4 command.

2 Parameters
   The only parameter allowed is a list of zero or more command file
   names, separated by commas.  Wild characters are not allowed.  The
   default file type is ".COM".  The usual VAX treatment of file-spec
   lists is used, e.g., "[ABC]D,E,F" specifies files [ABC]D.COM,
   [ABC]E.COM and [ABC]F.COM.

   If /HELP, /INITIALIZE, /DELETE, SIGNAL or /RUN is given, no parameter
   may be given.  Otherwise, if /ENTRY is not given, the files specified
   are inserted into the queue.
   If /ENTRY is given, the files specified replace the command files
   for the entries specified.  Successive file-specs replace successive
   entries' command files, with excess file-specs ignored and excess
   entries not having their command files changed.

2 Qualifiers
/QUEUE=file
   Specifies the file which holds the queue.  Default is
   /QUEUE=SYS$LOGIN:AUTOMAN4.QUE.  Missing parts of the file spec are
   taken from that default.

/SILENT
   This causes suppression of most informational messages.  More serious
   messages appear regardless.

/SHOW=list
   If /SHOW is given, the contents of the queue are listed after any
   other requested operation (insert, delete, ...) is performed. /SHOW can
   be given in conjunction with any other qualifiers except /HELP.

   The options available are ALL (the default - list the whole queue),
   and SOME (restrict list to those entries which have just been inserted,
   put into CURR state, or named by /ENTRY).  The list can be further
   restricted by naming one or more entry states (CURR, PEND, AFTE, HOLD
   and DEAD) or their negations.

   The format is hopefully self-explanatory.  The first line contains
   the state, the entry number, and a time-spec.  For PEND and HOLD
   entries, the time-spec is the submission time.  For CURR entries
   it is the time that the entry entered the CURR state.  For AFTE
   entries, it is the maturation time (i.e. the value of /AFTER).
   The /CPUTIME value is followed by "S" if scaling is in effect
   (see /SCALED).  The stream number is shown unless it is stream 0.
   A "D" indicates the presence of the /DIEAFTER flag, and a "C"
   indicates the presence of the /CRITICAL flag.
   For CURR or DEAD entries, the listing also shows the host name and
   pid of the processes which put them into CURR state, and the entry
   number of the process automatically submitted (if any) then.

   The entries are listed in order of state, then priority, then
   entry number.  This is neither the actual order of running (for
   which see Scheduling) nor the physical order in the queue file.

   A further independent option, DEFAULTS, causes a display of the current
   defaults and benchmarks (see /DEFAULTS).

/PEEK=list
   If /PEEK is given, the contents of the queue are listed after any
   other requested operation (insert, delete, ...) is performed.  /PEEK
   can be given in conjunction with any other qualifiers except /HELP.

   The same options are available as for the /SHOW qualifier, but the
   listing is substantially abbreviated.

   /PEEK is a short form of /SHOW, with only one line of information
   displayed for each entry.  This contains the state, the entry number,
   the time-spec (see /SHOW), the identification (the value of
   /IDENTIFICATION, if any, or else the command file name (without the
   device, directory, version fields, and only type fields other than
   .COM), the cpu requirement (followed by "S" if it is to be /SCALED),
   the priority, a "D" for the /DIEAFTER flag, a "C" for the /CRITICAL
   flag, the cycle count (if other than one), the stream number (if other
   than zero) and the prerequisites (if any).

   /SHOW takes precedence over /PEEK.

/HELP
   Enter the HELP utility at the AUTOMAN4 node.  All other parameters
   and qualifiers are ignored.

/INITIALIZE
   Create a new queue file, of name as specified by the /QUEUE
   qualifier.  The only parameters which may sensibly be specified
   as well are /QUEUE and /DEFAULTS.

/READONLY
   This causes the queue file to be not modified, irrespective of what
   other qualifiers are given.   An informational message is written if
   the queue file would have changed if /READONLY hadn't been present.

/DELETE
   Delete the queue entries specified by the /ENTRY qualifier, which
   must be present if /DELETE is present.

/SIGNAL=n
   Send signal n to the processes running each of the entries specified
   by the /ENTRY qualifier.  The default value of n is %x08028134
   which causes the message
     %AUTOMAN4-F-ABORTED, image aborted by remote $FORCEX
   if the message file AUTOMAN_SYS:AUTOMESS.EXE is known to the
   process being aborted.
   The entry must be in CURR state.
   The signal is sent by means of the $FORCEX system service.  If the
   process is running an image, the normal effect will be that the image
   will exit with status equal to the value of the signal.  If the process
   is running DCL, probably nothing will happen.
   If the entry is running on another host, AUTOMAN4 will attempt to
   access that host using DECNET.  This can only work if you have a proxy
   set up on that remote host, as no facility for using a login name
   and password is provided.
   The specified entry may be modified with /DIEAFTER in the some command.

/RUN
   Choose the most eligible entry in PEND state (if any; see Scheduling
   for details) and change its state to CURR.  Define process logical
   names thus:
        AUTOMAN_COM = name of command file for this entry
        AUTOMAN_LOG = name of log file for this entry.
   Define local DCL symbols thus:
        AUTOMAN_OK = "T"
        AUTOMAN_CPU = cpu requirement for this entry (format hh:mm:ss)
        AUTOMAN_PARAM = parameter list for this entry (format
                                             "param1" "param2" ... )
        AUTOMAN_CYC = cycle count for this entry
        AUTOMAN_STR = stream number for this entry
        AUTOMAN_COMM = comment string for this entry
        AUTOMAN_ENTRY = entry number for entry automatically inserted,
                        if any (see below).
        AUTOMAN_ID = identification string for this entry (if nonempty),
                        name-field of command file spec, plus type field
                        if not '.COM' (otherwise).
                     This is truncated to 15 characters so that it can be
                        legally used as a process name.
   If no entry is eligible to run, define the local DCL symbol
        AUTOMAN_OK = "F"

   Nothing is actually "run".  If an eligible entry was found, it
   can later be run using the DCL command
        @AUTOMAN_COM/OUTP=AUTOMAN_LOG 'AUTOMAN_PARAM'
   A slightly better way is indicated in Drivers.

   If the entry chosen for running has a cycle count other than one
   (see /CYCLES), a new entry is inserted in the queue.  The new entry has
   the same specs as the entry chosen for running except that the
   submission time is the present, the cycle count is one less (0-1 = 0),
   and there are no prerequisites.  The association between the two entries
   is remembered by AUTOMAN4 in case /STOPCYCLE is applied the next time
   AUTOMAN4 is run by the same process.  (See /STOPCYCLE.)
   If the entry chosen for running has a resub-delay other than 0, the
   new entry is inserted in state AFTE, with the specified delay from the
   present.  Otherwise, it is inserted in state PEND.  (See /RESUBDELAY.)

   /RUN overrides /STILLRUNNING, making it impossible for a single process
   to have more than one CURR entry at a time.

   Also see /DIEAFTER.

/STILLRUNNING
   Do not delete any CURR entry belonging to the current process.  This is
   useful for applications where an entry is selected using /RUN, then
   some queue manipulations are performed before or while that entry is
   actually run.  Using /STILLRUNNING for these manipulations ensures that
   the CURR entry remains in the queue, where (for example) its stream
   number has effect.

   /STILLRUNNING is overridden by /RUN.  The default is /NOSTILLRUNNING.

/DIEAFTER
   As described in Scheduling, a CURR entry for the current process is
   deleted whenever AUTOMAN4 is run (exception: see /STILLRUNNING).
   If AUTOMAN4 is run with the /RUN qualifier, and a CURR entry deleted
   in this way had the /DIEAFTER flag, no entry is selected to run.
   Instead, AUTOMAN4 exits with the status DIEAFTER (see Errors).
   /DIEAFTER can also be used in conjunction with the /SIGNAL command.
   /NODIEAFTER is the default, but this can be changed (see /DEFAULTS).

/ENTRY=list
   Specify one or more entries in the queue by their entry numbers
   (which appear after the state when the queue is listed).  /ENTRY is
   used in conjunction with /DELETE to delete an entry, with /SHOW=SOME
   or /PEEK=SOME to list specified entries, with /SIGNAL to send signals
   to the processes running entries, or (if neither /HELP, /INITIALIZE
   nor /RUN is given), to specify an entry whose characteristics
   are to be modified.

   In general, /ENTRY takes a list of values, enclosed in parentheses and
   separated by commas if there is more than one.  Each value can be a
   single entry number, or a range of entry numbers of the form m:n.
   The range m:n specifies any existing entries which have entry numbers
   between m and n inclusive.  There must be at least one.  The variants
   ":", "m:" and ":n" mean "all entries", "entries m and above" and
   "entries 1 through n".

   Also, see /COPY.

/COPY
   This can be used in conjunction with /ENTRY to make a modified copy of
   an existing entry.  The entries named by /ENTRY are copied, then other
   qualifiers (like /CPU) can modify the copy.  The only changes made
   automatically are:
   * states CURR and DEAD are changed to PEND
   * the timestamp is set to the present (except for state AFTE)
   * the entry number is updated

/REVIVE
   This can be used in conjunction with /ENTRY to change an entry from
   state DEAD to state PEND.  It has no effect on entries in other states.
   To put it instead into HOLD or AFTE state, specify /HOLD or /AFTER
   as well as /REVIVE.  Also see /STOPCYCLE.

/CRITICAL
   Specify alternate action if this entry is found abandoned.  Instead of
   the entry being deleted, it is put into state DEAD.  (This is the only
   way of getting into state DEAD.)  The effect is that entries which name
   this entry as a prerequisite, or entries with the same non-zero stream
   number, will not be put into state CURR (see Scheduling).
   The default is /NOCRITICAL.  Also see /REVIVE.

/LOG_FILE=file
   Specify a log file spec.  Defaults are SYS$LOGIN: for the directory,
   same as the command file for the name, and .LOG for the type.  (These
   defaults can be changed; see /DEFAULTS.)
   /NOLOG is not allowed, though you can specify the null device NL: for
   the log file if you really don't to see the output.

/CPUTIME=t
   Specify the minimum cpu requirements for the entry.  The format needed
   is  h:m:s, where h, m and s are nonnegative integers or null( = 0),
   and trailing fields can be omitted.
   /CPUTIME=0, /CPUTIME=NONE and /CPUTIME=INFINITE are all equivalent to
   /CPUTIME=5:59:0, which is also the default for new entries.
   (This default can be changed; see /DEFAULTS.)
   Note that entries with cpu requirements greater than about a minute
   less than the cpu limit for the current process are liable to be
   never run.  Also see /SCALED.

/SCALED
   Specify that the /CPUTIME requirement is to be scaled according to
   processor speed when the entry is run.  Originally, all processors
   are regarded at having a speed of 1000, but other values can be
   specified using the /DEFAULTS command (q.v.).
   Note that the scaling is done according to the processor in use when
   the entry is selected to run; the processor in use when the entry is
   added to the queue is irrelevant.
   /NOSCALED is the default, but this can be changed (see /DEFAULTS).
   The /PEEK and /SHOW commands indicate scaling by an "S" after the cpu
   value.

/PRIORITY=n
   Specify a priority for the entry.  Any integer (+ve or -ve) is allowed.
   The default priority for new entries is 10.  (This can be changed; see
   /DEFAULTS.)

/AFTER=time
   Specify that the entry is to be held until after a specified time.
   Allowable formats include
        /AFTER="23-jul-1985:23:10:10"
        /AFTER=10:0:0                   (10am today)
        /AFTER="+2:0:0"                 (2 hrs from now)
        /AFTER=tomorrow                 (00:00:00 tommorrow),
   in general, any absolute or combination time.
   /NOAFTER has the effect of changing state AFTE to state PEND.  This
   is the same as /AFTER="+0", except that it doesn't effect entries in
   state HOLD.
   /AFTER with no value is equivalent to /AFTER="+0".
   /AFTER takes precedence over /HOLD.

/HOLD
   /HOLD specifies that the entry is to be put into state HOLD
   indefinitely.  /NOHOLD changes state HOLD to state PEND, but has
   no effect on jobs in state AFTE.

/PREREQUISITES=list
   The value of /PREREQUISITES is a list of up to 20 entry numbers of
   entries which must run before this one.  Those entries must already
   be in the queue.  As a special case, the entry number "0" refers
   to the entry in the queue with greatest entry number less than this one.

/STREAM=n
   /NOSTREAM is the same as /STREAM=0.  The value of /STREAM is a
   stream number attached to the entry.  No two entries with the same
   non-zero stream number can simultaneously be in CURR state.  See
   Scheduling.  Legal stream numbers range from 0 to 65535.
   The default stream for new entries is 0. (This can be changed;
   see /DEFAULTS.)

/PARAMETERS=list
   The value of /PARAMETERS is list of strings which are intended as
   parameters when the entry is run  (see /RUN).  By default, new
   entries have no parameters.  (This may be changed; see /DEFAULTS.)

/IDENTIFICATION=string
   Define a string of up to 15 characters as the "identification
   string" for the entry.  This string plays these roles:
   - as the "name" of an entry used by the /PEEK command
   - as the value of the symbol AUTOMAN_ID after an entry is "run"
        (see /RUN)
   The default value is null.

/CYCLES=n
   /NOCYCLES is the same as /CYCLES=1.  The value of /CYCLES is the
   number of times the entry is run before it disappears from the
   queue completely.  /CYCLES=0 specifies an infinite number of runs.
   The maximum finite value is 65535.  The default cycle count for
   new entries is 1.  (This can be changed; see /DEFAULTS.)
   To prevent more than one element of the cycle from being run at
   once, use a non-zero stream number (see /STREAM).
   Also see /STOPCYCLE and Scheduling.

/STOPCYCLE
   If a new entry was automatically submitted (see /RUN) the last time
   that AUTOMAN4 was executed with /RUN by this process, then that
   entry is deleted.  /STOPCYCLE can be specified along with any other
   qualifiers except /HELP and /INITIALIZE.
   /STOPCYCLE has a similar effect when reviving a DEAD entry using
   /REVIVE and /ENTRY.

/RESUBDELAY=time
   This specifies the real time which must elapse between the time an
   entry is automatically resubmitted (see /RUN) and the time at which
   that new entry can be put in CURR state.  The format is  h:m:s,
   where h, m and s are non-negative integers or null (=0), and
   trailing fields can be omitted.

   The default for new entries is 00:00:00.  (This can be changed; see
   /DEFAULTS.)  The maximum legal delay is 5965:13:55.

/COMMENTS=string
   The value of /COMMENTS is a string of from 1 to 80 characters.  It is
   displayed when the queue is listed with /SHOW, and copied into the DCL
   symbol AUTOMAN_COMM when an entry is selected for running (see /RUN).
   Otherwise, it has no effect.

/DEFAULTS=list
   This command allows various default qualifier values to be changed.
   The changes are "permanent", remaining until the next time they are
   changed by the same means, or until /INITIALIZE is performed.
   The argument to /DEFAULTS is a list of default-specs.  If the list
   has more than one default-spec, use commas between them and
   parentheses around the list.
   Each default-spec consists of a keyword and possibly a value.  Most of
   them can also be explicitely negated (like "nostream").

   keyword     installation          parameter affected
                 default

   cputime        5:59:00    default cputime value for new entries,
                             and the value inferred when /CPUTIME=0
                             or /CPUTIME=INFINITE is used.
   scaled           off      default /SCALED for new entries
   dieafter         off      default /DIEAFTER for new entries
   critical         off      default /CRITICAL for new entries
   resubdelay     0:00:00    default /RESUBDELAY value for new entries
   stream            0       default stream number for new entries
   cycles            1       default cycle count for new entries
   priority         10       default priority for new entries
   parameters      none      default parameters for new entries
   identification  null      default identification string
   comments        null      default comment string
   log_file  sys$login:.log  default fields for log file specs
                             The device, directory, name and type
                             fields of the log file specification are
                             taken first from the value of /LOG_FILE
                             (if any), then from the defaults (loc cit)
                             then from the fully expanded command file
                             specification.  Typical useful defaults:
                            log_file=[].log (type .LOG in current directory)
                            log_file=.log   (type .LOG in same directory
                                                as command file)
                            log_file=sys$login:.out  (in login directory
                                        with type .OUT)
   benchmark       1000      cpu speed benchmark (see /RUN,/SCALED)
                             "nobenchmark" removes all benchmarks except
                             those belonging to the current host or to
                             an entry in curr state.
   hostname      <current>   (list allowed) host-names associated with
                             benchmark.  The name is the host name as
                             retured by getsyi(nodename).

   To see the current default settings, use /SHOW=DEFAULTS.
   /DEFAULTS may be specified in conjunction with and qualifiers
   except /HELP.  In all cases, the defaults are changed before any other
   operations are performed.

