par(1)                      General Commands Manual                     par(1)

NAME

       par - parallel command processing

SYNOPSIS

       par  [-FHdefiqx]  [-c   command]  [-l   logfile]  [-n  #]  [-p #] [file
       [file...]]

DESCRIPTION

       par takes a list of files to run a command on.  The first line of  each
       file  begins  with  a  colon  (:) or a pound-sign (#).  If a colon, the
       remainder of the line is a command to run for each  of  the  subsequent
       lines.   If  a  pound-sign,  then  each  subsequent  line  is  a (self-
       contained) command, unless the -c option was specified, in  which  case
       the  lines  become  the  arguments replacing the braces ({}s) in the -c
       argument.

       The input file may also  be  specified  on  stdin,  in  the  format  as
       previously described.

       In  each of the cases where the lines of the file, following the first,
       are not commands (ie: colon or -c), instances of open-close braces ({})
       in the command will be replaced by these values.

       For example, an inputfile whose contents is:

            : echo {}
            a
            b
            c

       run with par like so:

            %par -q inputfile

       will produce the following output (order will vary):

            b
            a
            c

       The command-line options are as follows:

       -F     Omit the footer that normally follows the output of each job.

       -H     Omit the header that normally precedes the output of each job.

       -c     Command  to  be  run  on  each  of  the  arguments following the
              command-line options, where the first line of the input  file(s)
              begins with a pound-sign (#).

       -d     Print  debugging information on standard error (stderr).  Repeat
              the option up to three times for more verbosity.

       -e     Split args by spaces, rather than using  sh  -c.   Note:  -e  is
              incompatible with the -i option.

       -f     No  input  file  or  STDIN,  just  run a quantity of the command
              specified with -c.

       -i     Run   commands   interactively   through   (multiple)   xterm(1)
              processes.

       -l     Prefix  of  logfile  name,  as  in  prefix.N  where N is the par
              process number ([0..]).

              Default: par.log.<time>.[0..]

       -n N   Number of simultaneous processes.

              Default: 3

       -p N   Pause N seconds between running commands.

       -q     Quiet mode.  Omit the typical processing logs and do not  create
              the  log  files from -l, instead the children inherit stdout and
              stderr from par.  -q is mutually exclusive with the  -x  and  -l
              options and the option appearing last will take precedence.

       -x     View par logs in real-time via an xterm(1).

FILES

       par.log.T.N Log file; where T is the current time in seconds since the
       epoch and N is the par process number ([0..]).

HISTORY

       par  was  ported  from  the  perl version.  It differs in the following
       manner:


       A)     If par receives a HUP/INT/TERM/QUIT signal, it  does  not  print
              the commands that will not be run.


       B)     If  par  received  a  HUP/INT/TERM/QUIT signal, it does not exit
              immediately after sending kill to running jobs.   it  waits  for
              them  to exit so that they are cleaned-up properly.  If a second
              signal is received, it dies immediately.




                                 29 July 2019                           par(1)