\input texinfo
@setfilename ./parallel_examples.info

@documentencoding utf-8

@node Top
@node GNU PARALLEL EXAMPLES
@chapter GNU PARALLEL EXAMPLES

@menu
* EXAMPLE@asis{:} Working as xargs -n1. Argument appending::
* EXAMPLE@asis{:} Simple network scanner::
* EXAMPLE@asis{:} Reading arguments from command line::
* EXAMPLE@asis{:} Inserting multiple arguments::
* EXAMPLE@asis{:} Context replace::
* EXAMPLE@asis{:} Compute intensive jobs and substitution::
* EXAMPLE@asis{:} Substitution and redirection::
* EXAMPLE@asis{:} Composed commands::
* EXAMPLE@asis{:} Composed command with perl replacement string::
* EXAMPLE@asis{:} Composed command with multiple input sources::
* EXAMPLE@asis{:} Calling Bash functions::
* EXAMPLE@asis{:} Function tester::
* EXAMPLE@asis{:} Continously show the latest line of output::
* EXAMPLE@asis{:} Log rotate::
* EXAMPLE@asis{:} Removing file extension when processing files::
* EXAMPLE@asis{:} Removing strings from the argument::
* EXAMPLE@asis{:} Download 24 images for each of the past 30 days::
* EXAMPLE@asis{:} Download world map from NASA::
* EXAMPLE@asis{:} Download Apollo-11 images from NASA using jq::
* EXAMPLE@asis{:} Download video playlist in parallel::
* EXAMPLE@asis{:} Prepend last modified date (ISO8601) to file name::
* EXAMPLE@asis{:} Save output in ISO8601 dirs::
* EXAMPLE@asis{:} Digital clock with "blinking" @asis{:}::
* EXAMPLE@asis{:} Aggregating content of files::
* EXAMPLE@asis{:} Breadth first parallel web crawler/mirrorer::
* EXAMPLE@asis{:} Process files from a tar file while unpacking::
* EXAMPLE@asis{:} Rewriting a for-loop and a while-read-loop::
* EXAMPLE@asis{:} Rewriting nested for-loops::
* EXAMPLE@asis{:} Finding the lowest difference between files::
* EXAMPLE@asis{:} for-loops with column names::
* EXAMPLE@asis{:} All combinations in a list::
* EXAMPLE@asis{:} From a to b and b to c::
* EXAMPLE@asis{:} Count the differences between all files in a dir::
* EXAMPLE@asis{:} Speeding up fast jobs::
* EXAMPLE@asis{:} Using shell variables::
* EXAMPLE@asis{:} Group output lines::
* EXAMPLE@asis{:} Tag output lines::
* EXAMPLE@asis{:} Colorize output::
* EXAMPLE@asis{:} Keep order of output same as order of input::
* EXAMPLE@asis{:} Parallel grep::
* EXAMPLE@asis{:} Grepping n lines for m regular expressions.::
* EXAMPLE@asis{:} Using remote computers::
* EXAMPLE@asis{:} Transferring of files::
* EXAMPLE@asis{:} Advanced file transfer::
* EXAMPLE@asis{:} Distributing work to local and remote computers::
* EXAMPLE@asis{:} Running the same command on remote computers::
* EXAMPLE@asis{:} Running 'sudo' on remote computers::
* EXAMPLE@asis{:} Using remote computers behind NAT wall::
* EXAMPLE@asis{:} Use sshpass with ssh::
* EXAMPLE@asis{:} Use outrun instead of ssh::
* EXAMPLE@asis{:} Slurm cluster::
* EXAMPLE@asis{:} Parallelizing rsync::
* EXAMPLE@asis{:} Use multiple inputs in one command::
* EXAMPLE@asis{:} Use a table as input::
* EXAMPLE@asis{:} Output to database::
* EXAMPLE@asis{:} Output to CSV-file for R::
* EXAMPLE@asis{:} Use XML as input::
* EXAMPLE@asis{:} Run the same command 10 times::
* EXAMPLE@asis{:} Working as cat | sh. Resource inexpensive jobs and evaluation::
* EXAMPLE@asis{:} Call program with FASTA sequence::
* EXAMPLE@asis{:} Call program with interleaved FASTQ records::
* EXAMPLE@asis{:} Processing a big file using more CPUs::
* EXAMPLE@asis{:} Grouping input lines::
* EXAMPLE@asis{:} Running more than 250 jobs workaround::
* EXAMPLE@asis{:} Working as mutex and counting semaphore::
* EXAMPLE@asis{:} Mutex for a script::
* EXAMPLE@asis{:} Start editor with filenames from stdin (standard input)::
* EXAMPLE@asis{:} Running sudo::
* EXAMPLE@asis{:} Run ping in parallel::
* EXAMPLE@asis{:} GNU Parallel as queue system/batch manager::
* EXAMPLE@asis{:} GNU Parallel as dir processor::
* EXAMPLE@asis{:} Locate the missing package::
@end menu

@node EXAMPLE: Working as xargs -n1. Argument appending
@section EXAMPLE: Working as xargs -n1. Argument appending

GNU @strong{parallel} can work similar to @strong{xargs -n1}.

To compress all html files using @strong{gzip} run:

@verbatim
  find . -name '*.html' | parallel gzip --best
@end verbatim

If the file names may contain a newline use @strong{-0}. Substitute FOO BAR with
FUBAR in all files in this dir and subdirs:

@verbatim
  find . -type f -print0 | \
    parallel -q0 perl -i -pe 's/FOO BAR/FUBAR/g'
@end verbatim

Note @strong{-q} is needed because of the space in 'FOO BAR'.

@node EXAMPLE: Simple network scanner
@section EXAMPLE: Simple network scanner

@strong{prips} can generate IP-addresses from CIDR notation. With GNU
@strong{parallel} you can build a simple network scanner to see which
addresses respond to @strong{ping}:

@verbatim
  prips 130.229.16.0/20 | \
    parallel --timeout 2 -j0 \
      'ping -c 1 {} >/dev/null && echo {}' 2>/dev/null
@end verbatim

@node EXAMPLE: Reading arguments from command line
@section EXAMPLE: Reading arguments from command line

GNU @strong{parallel} can take the arguments from command line instead of
stdin (standard input). To compress all html files in the current dir
using @strong{gzip} run:

@verbatim
  parallel gzip --best ::: *.html
@end verbatim

To convert *.wav to *.mp3 using LAME running one process per CPU run:

@verbatim
  parallel lame {} -o {.}.mp3 ::: *.wav
@end verbatim

@node EXAMPLE: Inserting multiple arguments
@section EXAMPLE: Inserting multiple arguments

When moving a lot of files like this: @strong{mv *.log destdir} you will
sometimes get the error:

@verbatim
  bash: /bin/mv: Argument list too long
@end verbatim

because there are too many files. You can instead do:

@verbatim
  ls | grep -E '\.log$' | parallel mv {} destdir
@end verbatim

This will run @strong{mv} for each file. It can be done faster if @strong{mv} gets
as many arguments that will fit on the line:

@verbatim
  ls | grep -E '\.log$' | parallel -m mv {} destdir
@end verbatim

In many shells you can also use @strong{printf}:

@verbatim
  printf '%s\0' *.log | parallel -0 -m mv {} destdir
@end verbatim

@node EXAMPLE: Context replace
@section EXAMPLE: Context replace

To remove the files @emph{pict0000.jpg} .. @emph{pict9999.jpg} you could do:

@verbatim
  seq -w 0 9999 | parallel rm pict{}.jpg
@end verbatim

You could also do:

@verbatim
  seq -w 0 9999 | perl -pe 's/(.*)/pict$1.jpg/' | parallel -m rm
@end verbatim

The first will run @strong{rm} 10000 times, while the last will only run
@strong{rm} as many times needed to keep the command line length short
enough to avoid @strong{Argument list too long} (it typically runs 1-2 times).

You could also run:

@verbatim
  seq -w 0 9999 | parallel -X rm pict{}.jpg
@end verbatim

This will also only run @strong{rm} as many times needed to keep the command
line length short enough.

@node EXAMPLE: Compute intensive jobs and substitution
@section EXAMPLE: Compute intensive jobs and substitution

If ImageMagick is installed this will generate a thumbnail of a jpg
file:

@verbatim
  convert -geometry 120 foo.jpg thumb_foo.jpg
@end verbatim

This will run with number-of-cpus jobs in parallel for all jpg files
in a directory:

@verbatim
  ls *.jpg | parallel convert -geometry 120 {} thumb_{}
@end verbatim

To do it recursively use @strong{find}:

@verbatim
  find . -name '*.jpg' | \
    parallel convert -geometry 120 {} {}_thumb.jpg
@end verbatim

Notice how the argument has to start with @strong{@{@}} as @strong{@{@}} will include path
(e.g. running @strong{convert -geometry 120 ./foo/bar.jpg
thumb_./foo/bar.jpg} would clearly be wrong). The command will
generate files like ./foo/bar.jpg_thumb.jpg.

Use @strong{@{.@}} to avoid the extra .jpg in the file name. This command will
make files like ./foo/bar_thumb.jpg:

@verbatim
  find . -name '*.jpg' | \
    parallel convert -geometry 120 {} {.}_thumb.jpg
@end verbatim

@node EXAMPLE: Substitution and redirection
@section EXAMPLE: Substitution and redirection

This will generate an uncompressed version of .gz-files next to the .gz-file:

@verbatim
  parallel zcat {} ">"{.} ::: *.gz
@end verbatim

Quoting of > is necessary to postpone the redirection. Another
solution is to quote the whole command:

@verbatim
  parallel "zcat {} >{.}" ::: *.gz
@end verbatim

Other special shell characters (such as * ; $ > < |  >> <<) also need
to be put in quotes, as they may otherwise be interpreted by the shell
and not given to GNU @strong{parallel}.

@node EXAMPLE: Composed commands
@section EXAMPLE: Composed commands

A job can consist of several commands. This will print the number of
files in each directory:

@verbatim
  ls | parallel 'echo -n {}" "; ls {}|wc -l'
@end verbatim

To put the output in a file called <name>.dir:

@verbatim
  ls | parallel '(echo -n {}" "; ls {}|wc -l) >{}.dir'
@end verbatim

Even small shell scripts can be run by GNU @strong{parallel}:

@verbatim
  find . | parallel 'a={}; name=${a##*/};' \
    'upper=$(echo "$name" | tr "[:lower:]" "[:upper:]");'\
    'echo "$name - $upper"'

  ls | parallel 'mv {} "$(echo {} | tr "[:upper:]" "[:lower:]")"'
@end verbatim

Given a list of URLs, list all URLs that fail to download. Print the
line number and the URL.

@verbatim
  cat urlfile | parallel "wget {} 2>/dev/null || grep -n {} urlfile"
@end verbatim

Create a mirror directory with the same filenames except all files and
symlinks are empty files.

@verbatim
  cp -rs /the/source/dir mirror_dir
  find mirror_dir -type l | parallel -m rm {} '&&' touch {}
@end verbatim

Find the files in a list that do not exist

@verbatim
  cat file_list | parallel 'if [ ! -e {} ] ; then echo {}; fi'
@end verbatim

@node EXAMPLE: Composed command with perl replacement string
@section EXAMPLE: Composed command with perl replacement string

You have a bunch of file. You want them sorted into dirs. The dir of
each file should be named the first letter of the file name.

@verbatim
  parallel 'mkdir -p {=s/(.).*/$1/=}; mv {} {=s/(.).*/$1/=}' ::: *
@end verbatim

@node EXAMPLE: Composed command with multiple input sources
@section EXAMPLE: Composed command with multiple input sources

You have a dir with files named as 24 hours in 5 minute intervals:
00:00, 00:05, 00:10 .. 23:55. You want to find the files missing:

@verbatim
  parallel [ -f {1}:{2} ] "||" echo {1}:{2} does not exist \
    ::: {00..23} ::: {00..55..5}
@end verbatim

@node EXAMPLE: Calling Bash functions
@section EXAMPLE: Calling Bash functions

If the composed command is longer than a line, it becomes hard to
read. In Bash you can use functions. Just remember to @strong{export -f} the
function.

@verbatim
  doit() {
    echo Doing it for $1
    sleep 2
    echo Done with $1
  }
  export -f doit
  parallel doit ::: 1 2 3

  doubleit() {
    echo Doing it for $1 $2
    sleep 2
    echo Done with $1 $2
  }
  export -f doubleit
  parallel doubleit ::: 1 2 3 ::: a b
@end verbatim

To do this on remote servers you need to transfer the function using
@strong{--env}:

@verbatim
  parallel --env doit -S server doit ::: 1 2 3
  parallel --env doubleit -S server doubleit ::: 1 2 3 ::: a b
@end verbatim

If your environment (aliases, variables, and functions) is small you
can copy the full environment without having to
@strong{export -f} anything. See @strong{env_parallel}.

@node EXAMPLE: Function tester
@section EXAMPLE: Function tester

To test a program with different parameters:

@verbatim
  tester() {
    if (eval "$@") >&/dev/null; then
      perl -e 'printf "\033[30;102m[ OK ]\033[0m @ARGV\n"' "$@"
    else
      perl -e 'printf "\033[30;101m[FAIL]\033[0m @ARGV\n"' "$@"
    fi
  }
  export -f tester
  parallel tester my_program ::: arg1 arg2
  parallel tester exit ::: 1 0 2 0
@end verbatim

If @strong{my_program} fails a red FAIL will be printed followed by the failing
command; otherwise a green OK will be printed followed by the command.

@node EXAMPLE: Continously show the latest line of output
@section EXAMPLE: Continously show the latest line of output

It can be useful to monitor the output of running jobs.

This shows the most recent output line until a job finishes. After
which the output of the job is printed in full:

@verbatim
  parallel '{} | tee >(cat >&3)' ::: 'command 1' 'command 2' \
    3> >(perl -ne '$|=1;chomp;printf"%.'$COLUMNS's\r",$_." "x100')
@end verbatim

@node EXAMPLE: Log rotate
@section EXAMPLE: Log rotate

Log rotation renames a logfile to an extension with a higher number:
log.1 becomes log.2, log.2 becomes log.3, and so on. The oldest log is
removed. To avoid overwriting files the process starts backwards from
the high number to the low number.  This will keep 10 old versions of
the log:

@verbatim
  seq 9 -1 1 | parallel -j1 mv log.{} log.'{= $_++ =}'
  mv log log.1
@end verbatim

@node EXAMPLE: Removing file extension when processing files
@section EXAMPLE: Removing file extension when processing files

When processing files removing the file extension using @strong{@{.@}} is
often useful.

Create a directory for each zip-file and unzip it in that dir:

@verbatim
  parallel 'mkdir {.}; cd {.}; unzip ../{}' ::: *.zip
@end verbatim

Recompress all .gz files in current directory using @strong{bzip2} running 1
job per CPU in parallel:

@verbatim
  parallel "zcat {} | bzip2 >{.}.bz2 && rm {}" ::: *.gz
@end verbatim

Convert all WAV files to MP3 using LAME:

@verbatim
  find sounddir -type f -name '*.wav' | parallel lame {} -o {.}.mp3
@end verbatim

Put all converted in the same directory:

@verbatim
  find sounddir -type f -name '*.wav' | \
    parallel lame {} -o mydir/{/.}.mp3
@end verbatim

@node EXAMPLE: Removing strings from the argument
@section EXAMPLE: Removing strings from the argument

If you have directory with tar.gz files and want these extracted in
the corresponding dir (e.g foo.tar.gz will be extracted in the dir
foo) you can do:

@verbatim
  parallel --plus 'mkdir {..}; tar -C {..} -xf {}' ::: *.tar.gz
@end verbatim

If you want to remove a different ending, you can use @{%string@}:

@verbatim
  parallel --plus echo {%_demo} ::: mycode_demo keep_demo_here
@end verbatim

You can also remove a starting string with @{#string@}

@verbatim
  parallel --plus echo {#demo_} ::: demo_mycode keep_demo_here
@end verbatim

To remove a string anywhere you can use regular expressions with
@{/regexp/replacement@} and leave the replacement empty:

@verbatim
  parallel --plus echo {/demo_/} ::: demo_mycode remove_demo_here
@end verbatim

@node EXAMPLE: Download 24 images for each of the past 30 days
@section EXAMPLE: Download 24 images for each of the past 30 days

Let us assume a website stores images like:

@verbatim
  https://www.example.com/path/to/YYYYMMDD_##.jpg
@end verbatim

where YYYYMMDD is the date and ## is the number 01-24. This will
download images for the past 30 days:

@verbatim
  getit() {
    date=$(date -d "today -$1 days" +%Y%m%d)
    num=$2
    echo wget https://www.example.com/path/to/${date}_${num}.jpg
  }
  export -f getit
  
  parallel getit ::: $(seq 30) ::: $(seq -w 24)
@end verbatim

@strong{$(date -d "today -$1 days" +%Y%m%d)} will give the dates in
YYYYMMDD with @strong{$1} days subtracted.

@node EXAMPLE: Download world map from NASA
@section EXAMPLE: Download world map from NASA

NASA provides tiles to download on earthdata.nasa.gov. Download tiles
for Blue Marble world map and create a 10240x20480 map.

@verbatim
  base=https://map1a.vis.earthdata.nasa.gov/wmts-geo/wmts.cgi
  service="SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0"
  layer="LAYER=BlueMarble_ShadedRelief_Bathymetry"
  set="STYLE=&TILEMATRIXSET=EPSG4326_500m&TILEMATRIX=5"
  tile="TILEROW={1}&TILECOL={2}"
  format="FORMAT=image%2Fjpeg"
  url="$base?$service&$layer&$set&$tile&$format"

  parallel -j0 -q wget "$url" -O {1}_{2}.jpg ::: {0..19} ::: {0..39}
  parallel eval convert +append {}_{0..39}.jpg line{}.jpg ::: {0..19}
  convert -append line{0..19}.jpg world.jpg
@end verbatim

@node EXAMPLE: Download Apollo-11 images from NASA using jq
@section EXAMPLE: Download Apollo-11 images from NASA using jq

Search NASA using their API to get JSON for images related to 'apollo
11' and has 'moon landing' in the description.

The search query returns JSON containing URLs to JSON containing
collections of pictures. One of the pictures in each of these
collection is @emph{large}.

@strong{wget} is used to get the JSON for the search query. @strong{jq} is then
used to extract the URLs of the collections. @strong{parallel} then calls
@strong{wget} to get each collection, which is passed to @strong{jq} to extract
the URLs of all images. @strong{grep} filters out the @emph{large} images, and
@strong{parallel} finally uses @strong{wget} to fetch the images.

@verbatim
  base="https://images-api.nasa.gov/search"
  q="q=apollo 11"
  description="description=moon landing"
  media_type="media_type=image"
  wget -O - "$base?$q&$description&$media_type" |
    jq -r .collection.items[].href |
    parallel wget -O - |
    jq -r .[] |
    grep large |
    parallel wget
@end verbatim

@node EXAMPLE: Download video playlist in parallel
@section EXAMPLE: Download video playlist in parallel

@strong{youtube-dl} is an excellent tool to download videos. It can,
however, not download videos in parallel. This takes a playlist and
downloads 10 videos in parallel.

@verbatim
  url='youtu.be/watch?v=0wOf2Fgi3DE&list=UU_cznB5YZZmvAmeq7Y3EriQ'
  export url
  youtube-dl --flat-playlist "https://$url" |
    parallel --tagstring {#} --lb -j10 \
      youtube-dl --playlist-start {#} --playlist-end {#} '"https://$url"'
@end verbatim

@node EXAMPLE: Prepend last modified date (ISO8601) to file name
@section EXAMPLE: Prepend last modified date (ISO8601) to file name

@verbatim
  parallel mv {} '{= $a=pQ($_); $b=$_;' \
    '$_=qx{date -r "$a" +%FT%T}; chomp; $_="$_ $b" =}' ::: *
@end verbatim

@strong{@{=} and @strong{=@}} mark a perl expression. @strong{pQ} perl-quotes the
string. @strong{date +%FT%T} is the date in ISO8601 with time.

@node EXAMPLE: Save output in ISO8601 dirs
@section EXAMPLE: Save output in ISO8601 dirs

Save output from @strong{ps aux} every second into dirs named
yyyy-mm-ddThh:mm:ss+zz:zz.

@verbatim
  seq 1000 | parallel -N0 -j1 --delay 1 \
    --results '{= $_=`date -Isec`; chomp=}/' ps aux
@end verbatim

@node EXAMPLE: Digital clock with "blinking" :
@section EXAMPLE: Digital clock with "blinking" :

The : in a digital clock blinks. To make every other line have a ':'
and the rest a ' ' a perl expression is used to look at the 3rd input
source. If the value modulo 2 is 1: Use ":" otherwise use " ":

@verbatim
  parallel -k echo {1}'{=3 $_=$_%2?":":" "=}'{2}{3} \
    ::: {0..12} ::: {0..5} ::: {0..9}
@end verbatim

@node EXAMPLE: Aggregating content of files
@section EXAMPLE: Aggregating content of files

This:

@verbatim
  parallel --header : echo x{X}y{Y}z{Z} \> x{X}y{Y}z{Z} \
  ::: X {1..5} ::: Y {01..10} ::: Z {1..5}
@end verbatim

will generate the files x1y01z1 .. x5y10z5. If you want to aggregate
the output grouping on x and z you can do this:

@verbatim
  parallel eval 'cat {=s/y01/y*/=} > {=s/y01//=}' ::: *y01*
@end verbatim

For all values of x and z it runs commands like:

@verbatim
  cat x1y*z1 > x1z1
@end verbatim

So you end up with x1z1 .. x5z5 each containing the content of all
values of y.

@node EXAMPLE: Breadth first parallel web crawler/mirrorer
@section EXAMPLE: Breadth first parallel web crawler/mirrorer

This script below will crawl and mirror a URL in parallel.  It
downloads first pages that are 1 click down, then 2 clicks down, then
3; instead of the normal depth first, where the first link link on
each page is fetched first.

Run like this:

@verbatim
  PARALLEL=-j100 ./parallel-crawl http://gatt.org.yeslab.org/
@end verbatim

Remove the @strong{wget} part if you only want a web crawler.

It works by fetching a page from a list of URLs and looking for links
in that page that are within the same starting URL and that have not
already been seen. These links are added to a new queue. When all the
pages from the list is done, the new queue is moved to the list of
URLs and the process is started over until no unseen links are found.

@verbatim
  #!/bin/bash

  # E.g. http://gatt.org.yeslab.org/
  URL=$1
  # Stay inside the start dir
  BASEURL=$(echo $URL | perl -pe 's:#.*::; s:(//.*/)[^/]*:$1:')
  URLLIST=$(mktemp urllist.XXXX)
  URLLIST2=$(mktemp urllist.XXXX)
  SEEN=$(mktemp seen.XXXX)

  # Spider to get the URLs
  echo $URL >$URLLIST
  cp $URLLIST $SEEN

  while [ -s $URLLIST ] ; do
    cat $URLLIST |
      parallel lynx -listonly -image_links -dump {} \; \
        wget -qm -l1 -Q1 {} \; echo Spidered: {} \>\&2 |
        perl -ne 's/#.*//; s/\s+\d+.\s(\S+)$/$1/ and
          do { $seen{$1}++ or print }' |
      grep -F $BASEURL |
      grep -v -x -F -f $SEEN | tee -a $SEEN > $URLLIST2
    mv $URLLIST2 $URLLIST
  done

  rm -f $URLLIST $URLLIST2 $SEEN
@end verbatim

@node EXAMPLE: Process files from a tar file while unpacking
@section EXAMPLE: Process files from a tar file while unpacking

If the files to be processed are in a tar file then unpacking one file
and processing it immediately may be faster than first unpacking all
files.

@verbatim
  tar xvf foo.tgz | perl -ne 'print $l;$l=$_;END{print $l}' | \
    parallel echo
@end verbatim

The Perl one-liner is needed to make sure the file is complete before
handing it to GNU @strong{parallel}.

@node EXAMPLE: Rewriting a for-loop and a while-read-loop
@section EXAMPLE: Rewriting a for-loop and a while-read-loop

for-loops like this:

@verbatim
  (for x in `cat list` ; do
    do_something $x
  done) | process_output
@end verbatim

and while-read-loops like this:

@verbatim
  cat list | (while read x ; do
    do_something $x
  done) | process_output
@end verbatim

can be written like this:

@verbatim
  cat list | parallel do_something | process_output
@end verbatim

For example: Find which host name in a list has IP address 1.2.3 4:

@verbatim
  cat hosts.txt | parallel -P 100 host | grep 1.2.3.4
@end verbatim

If the processing requires more steps the for-loop like this:

@verbatim
  (for x in `cat list` ; do
    no_extension=${x%.*};
    do_step1 $x scale $no_extension.jpg
    do_step2 <$x $no_extension
  done) | process_output
@end verbatim

and while-loops like this:

@verbatim
  cat list | (while read x ; do
    no_extension=${x%.*};
    do_step1 $x scale $no_extension.jpg
    do_step2 <$x $no_extension
  done) | process_output
@end verbatim

can be written like this:

@verbatim
  cat list | parallel "do_step1 {} scale {.}.jpg ; do_step2 <{} {.}" |\
    process_output
@end verbatim

If the body of the loop is bigger, it improves readability to use a function:

@verbatim
  (for x in `cat list` ; do
    do_something $x
    [... 100 lines that do something with $x ...]
  done) | process_output

  cat list | (while read x ; do
    do_something $x
    [... 100 lines that do something with $x ...]
  done) | process_output
@end verbatim

can both be rewritten as:

@verbatim
  doit() {
    x=$1
    do_something $x
    [... 100 lines that do something with $x ...]
  }
  export -f doit
  cat list | parallel doit
@end verbatim

@node EXAMPLE: Rewriting nested for-loops
@section EXAMPLE: Rewriting nested for-loops

Nested for-loops like this:

@verbatim
  (for x in `cat xlist` ; do
    for y in `cat ylist` ; do
      do_something $x $y
    done
  done) | process_output
@end verbatim

can be written like this:

@verbatim
  parallel do_something {1} {2} :::: xlist ylist | process_output
@end verbatim

Nested for-loops like this:

@verbatim
  (for colour in red green blue ; do
    for size in S M L XL XXL ; do
      echo $colour $size
    done
  done) | sort
@end verbatim

can be written like this:

@verbatim
  parallel echo {1} {2} ::: red green blue ::: S M L XL XXL | sort
@end verbatim

@node EXAMPLE: Finding the lowest difference between files
@section EXAMPLE: Finding the lowest difference between files

@strong{diff} is good for finding differences in text files. @strong{diff | wc -l}
gives an indication of the size of the difference. To find the
differences between all files in the current dir do:

@verbatim
  parallel --tag 'diff {1} {2} | wc -l' ::: * ::: * | sort -nk3
@end verbatim

This way it is possible to see if some files are closer to other
files.

@node EXAMPLE: for-loops with column names
@section EXAMPLE: for-loops with column names

When doing multiple nested for-loops it can be easier to keep track of
the loop variable if is is named instead of just having a number. Use
@strong{--header :} to let the first argument be an named alias for the
positional replacement string:

@verbatim
  parallel --header : echo {colour} {size} \
    ::: colour red green blue ::: size S M L XL XXL
@end verbatim

This also works if the input file is a file with columns:

@verbatim
  cat addressbook.tsv | \
    parallel --colsep '\t' --header : echo {Name} {E-mail address}
@end verbatim

@node EXAMPLE: All combinations in a list
@section EXAMPLE: All combinations in a list

GNU @strong{parallel} makes all combinations when given two lists.

To make all combinations in a single list with unique values, you
repeat the list and use replacement string @strong{@{choose_k@}}:

@verbatim
  parallel --plus echo {choose_k} ::: A B C D ::: A B C D

  parallel --plus echo 2{2choose_k} 1{1choose_k} ::: A B C D ::: A B C D
@end verbatim

@strong{@{choose_k@}} works for any number of input sources:

@verbatim
  parallel --plus echo {choose_k} ::: A B C D ::: A B C D ::: A B C D
@end verbatim

Where @strong{@{choose_k@}} does not care about order, @strong{@{uniq@}} cares about
order. It simply skips jobs where values from different input sources
are the same:

@verbatim
  parallel --plus echo {uniq} ::: A B C  ::: A B C  ::: A B C
  parallel --plus echo {1uniq}+{2uniq}+{3uniq} \
    ::: A B C  ::: A B C  ::: A B C
@end verbatim

The behaviour of @strong{@{choose_k@}} is undefined, if the input values of each
source are different.

@node EXAMPLE: From a to b and b to c
@section EXAMPLE: From a to b and b to c

Assume you have input like:

@verbatim
  aardvark
  babble
  cab
  dab
  each
@end verbatim

and want to run combinations like:

@verbatim
  aardvark babble
  babble cab
  cab dab
  dab each
@end verbatim

If the input is in the file in.txt:

@verbatim
  parallel echo {1} - {2} ::::+ <(head -n -1 in.txt) <(tail -n +2 in.txt)
@end verbatim

If the input is in the array $a here are two solutions:

@verbatim
  seq $((${#a[@]}-1)) | \
    env_parallel --env a echo '${a[{=$_--=}]} - ${a[{}]}'
  parallel echo {1} - {2} ::: "${a[@]::${#a[@]}-1}" :::+ "${a[@]:1}"
@end verbatim

@node EXAMPLE: Count the differences between all files in a dir
@section EXAMPLE: Count the differences between all files in a dir

Using @strong{--results} the results are saved in /tmp/diffcount*.

@verbatim
  parallel --results /tmp/diffcount "diff -U 0 {1} {2} | \
    tail -n +3 |grep -v '^@'|wc -l" ::: * ::: *
@end verbatim

To see the difference between file A and file B look at the file
'/tmp/diffcount/1/A/2/B'.

@node EXAMPLE: Speeding up fast jobs
@section EXAMPLE: Speeding up fast jobs

Starting a job on the local machine takes around 3-10 ms. This can be
a big overhead if the job takes very few ms to run. Often you can
group small jobs together using @strong{-X} which will make the overhead
less significant. Compare the speed of these:

@verbatim
  seq -w 0 9999 | parallel touch pict{}.jpg
  seq -w 0 9999 | parallel -X touch pict{}.jpg
@end verbatim

If your program cannot take multiple arguments, then you can use GNU
@strong{parallel} to spawn multiple GNU @strong{parallel}s:

@verbatim
  seq -w 0 9999999 | \
    parallel -j10 -q -I,, --pipe parallel -j0 touch pict{}.jpg
@end verbatim

If @strong{-j0} normally spawns 252 jobs, then the above will try to spawn
2520 jobs. On a normal GNU/Linux system you can spawn 32000 jobs using
this technique with no problems. To raise the 32000 jobs limit raise
/proc/sys/kernel/pid_max to 4194303.

If you do not need GNU @strong{parallel} to have control over each job (so
no need for @strong{--retries} or @strong{--joblog} or similar), then it can be
even faster if you can generate the command lines and pipe those to a
shell. So if you can do this:

@verbatim
  mygenerator | sh
@end verbatim

Then that can be parallelized like this:

@verbatim
  mygenerator | parallel --pipe --block 10M sh
@end verbatim

E.g.

@verbatim
  mygenerator() {
    seq 10000000 | perl -pe 'print "echo This is fast job number "';
  }
  mygenerator | parallel --pipe --block 10M sh
@end verbatim

The overhead is 100000 times smaller namely around 100 nanoseconds per
job.

@node EXAMPLE: Using shell variables
@section EXAMPLE: Using shell variables

When using shell variables you need to quote them correctly as they
may otherwise be interpreted by the shell.

Notice the difference between:

@verbatim
  ARR=("My brother's 12\" records are worth <\$\$\$>"'!' Foo Bar)
  parallel echo ::: ${ARR[@]} # This is probably not what you want
@end verbatim

and:

@verbatim
  ARR=("My brother's 12\" records are worth <\$\$\$>"'!' Foo Bar)
  parallel echo ::: "${ARR[@]}"
@end verbatim

When using variables in the actual command that contains special
characters (e.g. space) you can quote them using @strong{'"$VAR"'} or using
"'s and @strong{-q}:

@verbatim
  VAR="My brother's 12\" records are worth <\$\$\$>"
  parallel -q echo "$VAR" ::: '!'
  export VAR
  parallel echo '"$VAR"' ::: '!'
@end verbatim

If @strong{$VAR} does not contain ' then @strong{"'$VAR'"} will also work
(and does not need @strong{export}):

@verbatim
  VAR="My 12\" records are worth <\$\$\$>"
  parallel echo "'$VAR'" ::: '!'
@end verbatim

If you use them in a function you just quote as you normally would do:

@verbatim
  VAR="My brother's 12\" records are worth <\$\$\$>"
  export VAR
  myfunc() { echo "$VAR" "$1"; }
  export -f myfunc
  parallel myfunc ::: '!'
@end verbatim

@node EXAMPLE: Group output lines
@section EXAMPLE: Group output lines

When running jobs that output data, you often do not want the output
of multiple jobs to run together. GNU @strong{parallel} defaults to grouping
the output of each job, so the output is printed when the job
finishes. If you want full lines to be printed while the job is
running you can use @strong{--line-buffer}. If you want output to be
printed as soon as possible you can use @strong{-u}.

Compare the output of:

@verbatim
  parallel wget --progress=dot --limit-rate=100k \
    https://ftpmirror.gnu.org/parallel/parallel-20{}0822.tar.bz2 \
    ::: {12..16}
  parallel --line-buffer wget --progress=dot --limit-rate=100k \
    https://ftpmirror.gnu.org/parallel/parallel-20{}0822.tar.bz2 \
    ::: {12..16}
  parallel --latest-line wget --progress=dot --limit-rate=100k \
    https://ftpmirror.gnu.org/parallel/parallel-20{}0822.tar.bz2 \
    ::: {12..16}
  parallel -u wget --progress=dot --limit-rate=100k \
    https://ftpmirror.gnu.org/parallel/parallel-20{}0822.tar.bz2 \
    ::: {12..16}
@end verbatim

@node EXAMPLE: Tag output lines
@section EXAMPLE: Tag output lines

GNU @strong{parallel} groups the output lines, but it can be hard to see
where the different jobs begin. @strong{--tag} prepends the argument to make
that more visible:

@verbatim
  parallel --tag wget --limit-rate=100k \
    https://ftpmirror.gnu.org/parallel/parallel-20{}0822.tar.bz2 \
    ::: {12..16}
@end verbatim

@strong{--tag} works with @strong{--line-buffer} but not with @strong{-u}:

@verbatim
  parallel --tag --line-buffer wget --limit-rate=100k \
    https://ftpmirror.gnu.org/parallel/parallel-20{}0822.tar.bz2 \
    ::: {12..16}
@end verbatim

Check the uptime of the servers in @emph{~/.parallel/sshloginfile}:

@verbatim
  parallel --tag -S .. --nonall uptime
@end verbatim

@node EXAMPLE: Colorize output
@section EXAMPLE: Colorize output

Give each job a new color. Most terminals support ANSI colors with the
escape code "\033[30;3Xm" where 0 <= X <= 7:

@verbatim
    seq 10 | \
      parallel --tagstring '\033[30;3{=$_=++$::color%8=}m' seq {}
    parallel --rpl '{color} $_="\033[30;3".(++$::color%8)."m"' \
      --tagstring {color} seq {} ::: {1..10}
@end verbatim

To get rid of the initial \t (which comes from @strong{--tagstring}):

@verbatim
    ... | perl -pe 's/\t//'
@end verbatim

@node EXAMPLE: Keep order of output same as order of input
@section EXAMPLE: Keep order of output same as order of input

Normally the output of a job will be printed as soon as it
completes. Sometimes you want the order of the output to remain the
same as the order of the input. This is often important, if the output
is used as input for another system. @strong{-k} will make sure the order of
output will be in the same order as input even if later jobs end
before earlier jobs.

Append a string to every line in a text file:

@verbatim
  cat textfile | parallel -k echo {} append_string
@end verbatim

If you remove @strong{-k} some of the lines may come out in the wrong order.

Another example is @strong{traceroute}:

@verbatim
  parallel traceroute ::: qubes-os.org debian.org freenetproject.org
@end verbatim

will give traceroute of qubes-os.org, debian.org and
freenetproject.org, but it will be sorted according to which job
completed first.

To keep the order the same as input run:

@verbatim
  parallel -k traceroute ::: qubes-os.org debian.org freenetproject.org
@end verbatim

This will make sure the traceroute to qubes-os.org will be printed
first.

A bit more complex example is downloading a huge file in chunks in
parallel: Some internet connections will deliver more data if you
download files in parallel. For downloading files in parallel see:
"EXAMPLE: Download 10 images for each of the past 30 days". But if you
are downloading a big file you can download the file in chunks in
parallel.

To download byte 10000000-19999999 you can use @strong{curl}:

@verbatim
  curl -r 10000000-19999999 https://example.com/the/big/file >file.part
@end verbatim

To download a 1 GB file we need 100 10MB chunks downloaded and
combined in the correct order.

@verbatim
  seq 0 99 | parallel -k curl -r \
    {}0000000-{}9999999 https://example.com/the/big/file > file
@end verbatim

@node EXAMPLE: Parallel grep
@section EXAMPLE: Parallel grep

@strong{grep -r} greps recursively through directories. GNU @strong{parallel} can
often speed this up.

@verbatim
  find . -type f | parallel -k -j150% -n 1000 -m grep -H -n STRING {}
@end verbatim

This will run 1.5 job per CPU, and give 1000 arguments to @strong{grep}.

There are situations where the above will be slower than @strong{grep -r}:

@itemize
@item If data is already in RAM. The overhead of starting jobs and buffering
output may outweigh the benefit of running in parallel.

@item If the files are big. If a file cannot be read in a single seek, the
disk may start thrashing.

@end itemize

The speedup is caused by two factors:

@itemize
@item On rotating harddisks small files often require a seek for each
file. By searching for more files in parallel, the arm may pass
another wanted file on its way.

@item NVMe drives often perform better by having multiple command running in
parallel.

@end itemize

@node EXAMPLE: Grepping n lines for m regular expressions.
@section EXAMPLE: Grepping n lines for m regular expressions.

The simplest solution to grep a big file for a lot of regexps is:

@verbatim
  grep -f regexps.txt bigfile
@end verbatim

Or if the regexps are fixed strings:

@verbatim
  grep -F -f regexps.txt bigfile
@end verbatim

There are 3 limiting factors: CPU, RAM, and disk I/O.

RAM is easy to measure: If the @strong{grep} process takes up most of your
free memory (e.g. when running @strong{top}), then RAM is a limiting factor.

CPU is also easy to measure: If the @strong{grep} takes >90% CPU in @strong{top},
then the CPU is a limiting factor, and parallelization will speed this
up.

It is harder to see if disk I/O is the limiting factor, and depending
on the disk system it may be faster or slower to parallelize. The only
way to know for certain is to test and measure.

@menu
* Limiting factor@asis{:} RAM::
* Limiting factor@asis{:} CPU::
* Bigger problem::
@end menu

@node Limiting factor: RAM
@subsection Limiting factor: RAM

The normal @strong{grep -f regexps.txt bigfile} works no matter the size of
bigfile, but if regexps.txt is so big it cannot fit into memory, then
you need to split this.

@strong{grep -F} takes around 100 bytes of RAM and @strong{grep} takes about 500
bytes of RAM per 1 byte of regexp. So if regexps.txt is 1% of your
RAM, then it may be too big.

If you can convert your regexps into fixed strings do that. E.g. if
the lines you are looking for in bigfile all looks like:

@verbatim
  ID1 foo bar baz Identifier1 quux
  fubar ID2 foo bar baz Identifier2
@end verbatim

then your regexps.txt can be converted from:

@verbatim
  ID1.*Identifier1
  ID2.*Identifier2
@end verbatim

into:

@verbatim
  ID1 foo bar baz Identifier1
  ID2 foo bar baz Identifier2
@end verbatim

This way you can use @strong{grep -F} which takes around 80% less memory and
is much faster.

If it still does not fit in memory you can do this:

@verbatim
  parallel --pipe-part -a regexps.txt --block 1M grep -F -f - -n bigfile | \
    sort -un | perl -pe 's/^\d+://'
@end verbatim

The 1M should be your free memory divided by the number of CPU threads and
divided by 200 for @strong{grep -F} and by 1000 for normal @strong{grep}. On
GNU/Linux you can do:

@verbatim
  free=$(awk '/^((Swap)?Cached|MemFree|Buffers):/ { sum += $2 }
              END { print sum }' /proc/meminfo)
  percpu=$((free / 200 / $(parallel --number-of-threads)))k

  parallel --pipe-part -a regexps.txt --block $percpu --compress \
    grep -F -f - -n bigfile | \
    sort -un | perl -pe 's/^\d+://'
@end verbatim

If you can live with duplicated lines and wrong order, it is faster to do:

@verbatim
  parallel --pipe-part -a regexps.txt --block $percpu --compress \
    grep -F -f - bigfile
@end verbatim

@node Limiting factor: CPU
@subsection Limiting factor: CPU

If the CPU is the limiting factor parallelization should be done on
the regexps:

@verbatim
  cat regexps.txt | parallel --pipe -L1000 --round-robin --compress \
    grep -f - -n bigfile | \
    sort -un | perl -pe 's/^\d+://'
@end verbatim

The command will start one @strong{grep} per CPU and read @emph{bigfile} one
time per CPU, but as that is done in parallel, all reads except the
first will be cached in RAM. Depending on the size of @emph{regexps.txt} it
may be faster to use @strong{--block 10m} instead of @strong{-L1000}.

Some storage systems perform better when reading multiple chunks in
parallel. This is true for some RAID systems and for some network file
systems. To parallelize the reading of @emph{bigfile}:

@verbatim
  parallel --pipe-part --block 100M -a bigfile -k --compress \
    grep -f regexps.txt
@end verbatim

This will split @emph{bigfile} into 100MB chunks and run @strong{grep} on each of
these chunks. To parallelize both reading of @emph{bigfile} and @emph{regexps.txt}
combine the two using @strong{--cat}:

@verbatim
  parallel --pipe-part --block 100M -a bigfile --cat cat regexps.txt \
    \| parallel --pipe -L1000 --round-robin grep -f - {}
@end verbatim

If a line matches multiple regexps, the line may be duplicated.

@node Bigger problem
@subsection Bigger problem

If the problem is too big to be solved by this, you are probably ready
for Lucene.

@node EXAMPLE: Using remote computers
@section EXAMPLE: Using remote computers

To run commands on a remote computer SSH needs to be set up and you
must be able to login without entering a password (The commands
@strong{ssh-copy-id}, @strong{ssh-agent}, and @strong{sshpass} may help you do that).

If you need to login to a whole cluster, you typically do not want to
accept the host key for every host. You want to accept them the first
time and be warned if they are ever changed. To do that:

@verbatim
  # Add the servers to the sshloginfile
  (echo servera; echo serverb) > .parallel/my_cluster
  # Make sure .ssh/config exist
  touch .ssh/config
  cp .ssh/config .ssh/config.backup
  # Disable StrictHostKeyChecking temporarily
  (echo 'Host *'; echo StrictHostKeyChecking no) >> .ssh/config
  parallel --slf my_cluster --nonall true
  # Remove the disabling of StrictHostKeyChecking
  mv .ssh/config.backup .ssh/config
@end verbatim

The servers in @strong{.parallel/my_cluster} are now added in @strong{.ssh/known_hosts}.

To run @strong{echo} on @strong{server.example.com}:

@verbatim
  seq 10 | parallel --sshlogin server.example.com echo
@end verbatim

To run commands on more than one remote computer run:

@verbatim
  seq 10 | parallel --sshlogin s1.example.com,s2.example.net echo
@end verbatim

Or:

@verbatim
  seq 10 | parallel --sshlogin server.example.com \
    --sshlogin server2.example.net echo
@end verbatim

If the login username is @emph{foo} on @emph{server2.example.net} use:

@verbatim
  seq 10 | parallel --sshlogin server.example.com \
    --sshlogin foo@server2.example.net echo
@end verbatim

If your list of hosts is @emph{server1-88.example.net} with login @emph{foo}:

@verbatim
  seq 10 | parallel -Sfoo@server{1..88}.example.net echo
@end verbatim

To distribute the commands to a list of computers, make a file
@emph{mycomputers} with all the computers:

@verbatim
  server.example.com
  foo@server2.example.com
  server3.example.com
@end verbatim

Then run:

@verbatim
  seq 10 | parallel --sshloginfile mycomputers echo
@end verbatim

To include the local computer add the special sshlogin ':' to the list:

@verbatim
  server.example.com
  foo@server2.example.com
  server3.example.com
  :
@end verbatim

GNU @strong{parallel} will try to determine the number of CPUs on each of
the remote computers, and run one job per CPU - even if the remote
computers do not have the same number of CPUs.

If the number of CPUs on the remote computers is not identified
correctly the number of CPUs can be added in front. Here the computer
has 8 CPUs.

@verbatim
  seq 10 | parallel --sshlogin 8/server.example.com echo
@end verbatim

@node EXAMPLE: Transferring of files
@section EXAMPLE: Transferring of files

To recompress gzipped files with @strong{bzip2} using a remote computer run:

@verbatim
  find logs/ -name '*.gz' | \
    parallel --sshlogin server.example.com \
    --transfer "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

This will list the .gz-files in the @emph{logs} directory and all
directories below. Then it will transfer the files to
@emph{server.example.com} to the corresponding directory in
@emph{$HOME/logs}. On @emph{server.example.com} the file will be recompressed
using @strong{zcat} and @strong{bzip2} resulting in the corresponding file with
@emph{.gz} replaced with @emph{.bz2}.

If you want the resulting bz2-file to be transferred back to the local
computer add @emph{--return @{.@}.bz2}:

@verbatim
  find logs/ -name '*.gz' | \
    parallel --sshlogin server.example.com \
    --transfer --return {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

After the recompressing is done the @emph{.bz2}-file is transferred back to
the local computer and put next to the original @emph{.gz}-file.

If you want to delete the transferred files on the remote computer add
@emph{--cleanup}. This will remove both the file transferred to the remote
computer and the files transferred from the remote computer:

@verbatim
  find logs/ -name '*.gz' | \
    parallel --sshlogin server.example.com \
    --transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

If you want run on several computers add the computers to @emph{--sshlogin}
either using ',' or multiple @emph{--sshlogin}:

@verbatim
  find logs/ -name '*.gz' | \
    parallel --sshlogin server.example.com,server2.example.com \
    --sshlogin server3.example.com \
    --transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

You can add the local computer using @emph{--sshlogin :}. This will disable the
removing and transferring for the local computer only:

@verbatim
  find logs/ -name '*.gz' | \
    parallel --sshlogin server.example.com,server2.example.com \
    --sshlogin server3.example.com \
    --sshlogin : \
    --transfer --return {.}.bz2 --cleanup "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

Often @emph{--transfer}, @emph{--return} and @emph{--cleanup} are used together. They can be
shortened to @emph{--trc}:

@verbatim
  find logs/ -name '*.gz' | \
    parallel --sshlogin server.example.com,server2.example.com \
    --sshlogin server3.example.com \
    --sshlogin : \
    --trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

With the file @emph{mycomputers} containing the list of computers it becomes:

@verbatim
  find logs/ -name '*.gz' | parallel --sshloginfile mycomputers \
    --trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

If the file @emph{~/.parallel/sshloginfile} contains the list of computers
the special short hand @emph{-S ..} can be used:

@verbatim
  find logs/ -name '*.gz' | parallel -S .. \
    --trc {.}.bz2 "zcat {} | bzip2 -9 >{.}.bz2"
@end verbatim

@node EXAMPLE: Advanced file transfer
@section EXAMPLE: Advanced file transfer

Assume you have files in in/*, want them processed on server,
and transferred back into /other/dir:

@verbatim
  parallel -S server --trc /other/dir/./{/}.out \
    cp {/} {/}.out ::: in/./*
@end verbatim

@node EXAMPLE: Distributing work to local and remote computers
@section EXAMPLE: Distributing work to local and remote computers

Convert *.mp3 to *.ogg running one process per CPU on local computer
and server2:

@verbatim
  parallel --trc {.}.ogg -S server2,: \
    'mpg321 -w - {} | oggenc -q0 - -o {.}.ogg' ::: *.mp3
@end verbatim

@node EXAMPLE: Running the same command on remote computers
@section EXAMPLE: Running the same command on remote computers

To run the command @strong{uptime} on remote computers you can do:

@verbatim
  parallel --tag --nonall -S server1,server2 uptime
@end verbatim

@strong{--nonall} reads no arguments. If you have a list of jobs you want
to run on each computer you can do:

@verbatim
  parallel --tag --onall -S server1,server2 echo ::: 1 2 3
@end verbatim

Remove @strong{--tag} if you do not want the sshlogin added before the
output.

If you have a lot of hosts use '-j0' to access more hosts in parallel.

@node EXAMPLE: Running 'sudo' on remote computers
@section EXAMPLE: Running 'sudo' on remote computers

Put the password into passwordfile then run:

@verbatim
  parallel --ssh 'cat passwordfile | ssh' --nonall \
    -S user@server1,user@server2 sudo -S ls -l /root
@end verbatim

@node EXAMPLE: Using remote computers behind NAT wall
@section EXAMPLE: Using remote computers behind NAT wall

If the workers are behind a NAT wall, you need some trickery to get to
them.

If you can @strong{ssh} to a jumphost, and reach the workers from there,
then the obvious solution would be this, but it @strong{does not work}:

@verbatim
  parallel --ssh 'ssh jumphost ssh' -S host1 echo ::: DOES NOT WORK
@end verbatim

It does not work because the command is dequoted by @strong{ssh} twice where
as GNU @strong{parallel} only expects it to be dequoted once.

You can use a bash function and have GNU @strong{parallel} quote the command:

@verbatim
  jumpssh() { ssh -A jumphost ssh $(parallel --shellquote ::: "$@"); }
  export -f jumpssh
  parallel --ssh jumpssh -S host1 echo ::: this works
@end verbatim

Or you can instead put this in @strong{~/.ssh/config}:

@verbatim
  Host host1 host2 host3
    ProxyCommand ssh jumphost.domain nc -w 1 %h 22
@end verbatim

It requires @strong{nc(netcat)} to be installed on jumphost. With this you
can simply:

@verbatim
  parallel -S host1,host2,host3 echo ::: This does work
@end verbatim

@menu
* No jumphost@comma{} but port forwards::
* No jumphost@comma{} no port forwards::
@end menu

@node No jumphost@comma{} but port forwards
@subsection No jumphost, but port forwards

If there is no jumphost but each server has port 22 forwarded from the
firewall (e.g. the firewall's port 22001 = port 22 on host1, 22002 = host2,
22003 = host3) then you can use @strong{~/.ssh/config}:

@verbatim
  Host host1.v
    Port 22001
  Host host2.v
    Port 22002
  Host host3.v
    Port 22003
  Host *.v
    Hostname firewall
@end verbatim

And then use host@{1..3@}.v as normal hosts:

@verbatim
  parallel -S host1.v,host2.v,host3.v echo ::: a b c
@end verbatim

@node No jumphost@comma{} no port forwards
@subsection No jumphost, no port forwards

If ports cannot be forwarded, you need some sort of VPN to traverse
the NAT-wall. TOR is one options for that, as it is very easy to get
working.

You need to install TOR and setup a hidden service. In @strong{torrc} put:

@verbatim
  HiddenServiceDir /var/lib/tor/hidden_service/
  HiddenServicePort 22 127.0.0.1:22
@end verbatim

Then start TOR: @strong{/etc/init.d/tor restart}

The TOR hostname is now in @strong{/var/lib/tor/hidden_service/hostname} and
is something similar to @strong{izjafdceobowklhz.onion}. Now you simply
prepend @strong{torsocks} to @strong{ssh}:

@verbatim
  parallel --ssh 'torsocks ssh' -S izjafdceobowklhz.onion \
    -S zfcdaeiojoklbwhz.onion,auclucjzobowklhi.onion echo ::: a b c
@end verbatim

If not all hosts are accessible through TOR:

@verbatim
  parallel -S 'torsocks ssh izjafdceobowklhz.onion,host2,host3' \
    echo ::: a b c
@end verbatim

See more @strong{ssh} tricks on https://en.wikibooks.org/wiki/OpenSSH/Cookbook/Proxies_and_Jump_Hosts

@node EXAMPLE: Use sshpass with ssh
@section EXAMPLE: Use sshpass with ssh

If you cannot use passwordless login, you may be able to use @strong{sshpass}:

@verbatim
  seq 10 | parallel -S user-with-password:MyPassword@server echo
@end verbatim

or:

@verbatim
  export SSHPASS='MyPa$$w0rd'
  seq 10 | parallel -S user-with-password:@server echo
@end verbatim

@node EXAMPLE: Use outrun instead of ssh
@section EXAMPLE: Use outrun instead of ssh

@strong{outrun} lets you run a command on a remote server. @strong{outrun} sets up
a connection to access files at the source server, and automatically
transfers files. @strong{outrun} must be installed on the remote system.

You can use @strong{outrun} in an sshlogin this way:

@verbatim
  parallel -S 'outrun user@server' command
@end verbatim

or:

@verbatim
  parallel --ssh outrun -S server command
@end verbatim

@node EXAMPLE: Slurm cluster
@section EXAMPLE: Slurm cluster

The Slurm Workload Manager is used in many clusters.

Here is a simple example of using GNU @strong{parallel} to call @strong{srun}:

@verbatim
  #!/bin/bash
  
  #SBATCH --time 00:02:00
  #SBATCH --ntasks=4
  #SBATCH --job-name GnuParallelDemo
  #SBATCH --output gnuparallel.out
  
  module purge
  module load gnu_parallel
  
  my_parallel="parallel --delay .2 -j $SLURM_NTASKS"
  my_srun="srun --export=all --exclusive -n1"
  my_srun="$my_srun --cpus-per-task=1 --cpu-bind=cores"
  $my_parallel "$my_srun" echo This is job {} ::: {1..20}
@end verbatim

@node EXAMPLE: Parallelizing rsync
@section EXAMPLE: Parallelizing rsync

@strong{rsync} is a great tool, but sometimes it will not fill up the
available bandwidth. Running multiple @strong{rsync} in parallel can fix
this.

@verbatim
  cd src-dir
  find . -type f |
    parallel -j10 -X rsync -zR -Ha ./{} fooserver:/dest-dir/
@end verbatim

Adjust @strong{-j10} until you find the optimal number.

@strong{rsync -R} will create the needed subdirectories, so all files are
not put into a single dir. The @strong{./} is needed so the resulting command
looks similar to:

@verbatim
  rsync -zR ././sub/dir/file fooserver:/dest-dir/
@end verbatim

The @strong{/./} is what @strong{rsync -R} works on.

If you are unable to push data, but need to pull them and the files
are called digits.png (e.g. 000000.png) you might be able to do:

@verbatim
  seq -w 0 99 | parallel rsync -Havessh fooserver:src/*{}.png destdir/
@end verbatim

@node EXAMPLE: Use multiple inputs in one command
@section EXAMPLE: Use multiple inputs in one command

Copy files like foo.es.ext to foo.ext:

@verbatim
  ls *.es.* | perl -pe 'print; s/\.es//' | parallel -N2 cp {1} {2}
@end verbatim

The perl command spits out 2 lines for each input. GNU @strong{parallel}
takes 2 inputs (using @strong{-N2}) and replaces @{1@} and @{2@} with the inputs.

Count in binary:

@verbatim
  parallel -k echo ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1 ::: 0 1
@end verbatim

Print the number on the opposing sides of a six sided die:

@verbatim
  parallel --link -a <(seq 6) -a <(seq 6 -1 1) echo
  parallel --link echo :::: <(seq 6) <(seq 6 -1 1)
@end verbatim

Convert files from all subdirs to PNG-files with consecutive numbers
(useful for making input PNG's for @strong{ffmpeg}):

@verbatim
  parallel --link -a <(find . -type f | sort) \
    -a <(seq $(find . -type f|wc -l)) convert {1} {2}.png
@end verbatim

Alternative version:

@verbatim
  find . -type f | sort | parallel convert {} {#}.png
@end verbatim

@node EXAMPLE: Use a table as input
@section EXAMPLE: Use a table as input

Content of table_file.tsv:

@verbatim
  foo<TAB>bar
  baz <TAB> quux
@end verbatim

To run:

@verbatim
  cmd -o bar -i foo
  cmd -o quux -i baz
@end verbatim

you can run:

@verbatim
  parallel -a table_file.tsv --colsep '\t' cmd -o {2} -i {1}
@end verbatim

Note: The default for GNU @strong{parallel} is to remove the spaces around
the columns. To keep the spaces:

@verbatim
  parallel -a table_file.tsv --trim n --colsep '\t' cmd -o {2} -i {1}
@end verbatim

@node EXAMPLE: Output to database
@section EXAMPLE: Output to database

GNU @strong{parallel} can output to a database table and a CSV-file:

@verbatim
  dburl=csv:///%2Ftmp%2Fmydir
  dbtableurl=$dburl/mytable.csv
  parallel --sqlandworker $dbtableurl seq ::: {1..10}
@end verbatim

It is rather slow and takes up a lot of CPU time because GNU
@strong{parallel} parses the whole CSV file for each update.

A better approach is to use an SQLite-base and then convert that to CSV:

@verbatim
  dburl=sqlite3:///%2Ftmp%2Fmy.sqlite
  dbtableurl=$dburl/mytable
  parallel --sqlandworker $dbtableurl seq ::: {1..10}
  sql $dburl '.headers on' '.mode csv' 'SELECT * FROM mytable;'
@end verbatim

This takes around a second per job.

If you have access to a real database system, such as PostgreSQL, it
is even faster:

@verbatim
  dburl=pg://user:pass@host/mydb
  dbtableurl=$dburl/mytable
  parallel --sqlandworker $dbtableurl seq ::: {1..10}
  sql $dburl \
    "COPY (SELECT * FROM mytable) TO stdout DELIMITER ',' CSV HEADER;"
@end verbatim

Or MySQL:

@verbatim
  dburl=mysql://user:pass@host/mydb
  dbtableurl=$dburl/mytable
  parallel --sqlandworker $dbtableurl seq ::: {1..10}
  sql -p -B $dburl "SELECT * FROM mytable;" > mytable.tsv
  perl -pe 's/"/""/g; s/\t/","/g; s/^/"/; s/$/"/;
    %s=("\\" => "\\", "t" => "\t", "n" => "\n");
    s/\\([\\tn])/$s{$1}/g;' mytable.tsv
@end verbatim

@node EXAMPLE: Output to CSV-file for R
@section EXAMPLE: Output to CSV-file for R

If you have no need for the advanced job distribution control that a
database provides, but you simply want output into a CSV file that you
can read into R or LibreCalc, then you can use @strong{--results}:

@verbatim
  parallel --results my.csv seq ::: 10 20 30
  R
  > mydf <- read.csv("my.csv");
  > print(mydf[2,])
  > write(as.character(mydf[2,c("Stdout")]),'')
@end verbatim

@node EXAMPLE: Use XML as input
@section EXAMPLE: Use XML as input

The show Aflyttet on Radio 24syv publishes an RSS feed with their audio
podcasts on: http://arkiv.radio24syv.dk/audiopodcast/channel/4466232

Using @strong{xpath} you can extract the URLs for 2019 and download them
using GNU @strong{parallel}:

@verbatim
  wget -O - http://arkiv.radio24syv.dk/audiopodcast/channel/4466232 | \
    xpath -e "//pubDate[contains(text(),'2019')]/../enclosure/@url" | \
    parallel -u wget '{= s/ url="//; s/"//; =}'
@end verbatim

@node EXAMPLE: Run the same command 10 times
@section EXAMPLE: Run the same command 10 times

If you want to run the same command with the same arguments 10 times
in parallel you can do:

@verbatim
  seq 10 | parallel -n0 my_command my_args
@end verbatim

@node EXAMPLE: Working as cat | sh. Resource inexpensive jobs and evaluation
@section EXAMPLE: Working as cat | sh. Resource inexpensive jobs and evaluation

GNU @strong{parallel} can work similar to @strong{cat | sh}.

A resource inexpensive job is a job that takes very little CPU, disk
I/O and network I/O. Ping is an example of a resource inexpensive
job. wget is too - if the webpages are small.

The content of the file jobs_to_run:

@verbatim
  ping -c 1 10.0.0.1
  wget http://example.com/status.cgi?ip=10.0.0.1
  ping -c 1 10.0.0.2
  wget http://example.com/status.cgi?ip=10.0.0.2
  ...
  ping -c 1 10.0.0.255
  wget http://example.com/status.cgi?ip=10.0.0.255
@end verbatim

To run 100 processes simultaneously do:

@verbatim
  parallel -j 100 < jobs_to_run
@end verbatim

As there is not a @emph{command} the jobs will be evaluated by the shell.

@node EXAMPLE: Call program with FASTA sequence
@section EXAMPLE: Call program with FASTA sequence

FASTA files have the format:

@verbatim
  >Sequence name1
  sequence
  sequence continued
  >Sequence name2
  sequence
  sequence continued
  more sequence
@end verbatim

To call @strong{myprog} with the sequence as argument run:

@verbatim
  cat file.fasta |
    parallel --pipe -N1 --recstart '>' --rrs \
      'read a; echo Name: "$a"; myprog $(tr -d "\n")'
@end verbatim

@node EXAMPLE: Call program with interleaved FASTQ records
@section EXAMPLE: Call program with interleaved FASTQ records

FASTQ files have the format:

@verbatim
  @M10991:61:000000000-A7EML:1:1101:14011:1001 1:N:0:28
  CTCCTAGGTCGGCATGATGGGGGAAGGAGAGCATGGGAAGAAATGAGAGAGTAGCAAGG
  +
  #8BCCGGGGGFEFECFGGGGGGGGG@;FFGGGEG@FF<EE<@FFC,CEGCCGGFF<FGF
@end verbatim

Interleaved FASTQ starts with a line like these:

@verbatim
  @HWUSI-EAS100R:6:73:941:1973#0/1
  @EAS139:136:FC706VJ:2:2104:15343:197393 1:Y:18:ATCACG
  @EAS139:136:FC706VJ:2:2104:15343:197393 1:N:18:1
@end verbatim

where '/1' and ' 1:' determines this is read 1.

This will cut big.fq into one chunk per CPU thread and pass it on
stdin (standard input) to the program fastq-reader:

@verbatim
  parallel --pipe-part -a big.fq --block -1 --regexp \
    --recend '\n' --recstart '@.*(/1| 1:.*)\n[A-Za-z\n\.~]' \
    fastq-reader
@end verbatim

@node EXAMPLE: Processing a big file using more CPUs
@section EXAMPLE: Processing a big file using more CPUs

To process a big file or some output you can use @strong{--pipe} to split up
the data into blocks and pipe the blocks into the processing program.

If the program is @strong{gzip -9} you can do:

@verbatim
  cat bigfile | parallel --pipe --recend '' -k gzip -9 > bigfile.gz
@end verbatim

This will split @strong{bigfile} into blocks of 1 MB and pass that to @strong{gzip
-9} in parallel. One @strong{gzip} will be run per CPU. The output of @strong{gzip
-9} will be kept in order and saved to @strong{bigfile.gz}

@strong{gzip} works fine if the output is appended, but some processing does
not work like that - for example sorting. For this GNU @strong{parallel} can
put the output of each command into a file. This will sort a big file
in parallel:

@verbatim
  cat bigfile | parallel --pipe --files sort |\
    parallel -Xj1 sort -m {} ';' rm {} >bigfile.sort
@end verbatim

Here @strong{bigfile} is split into blocks of around 1MB, each block ending
in '\n' (which is the default for @strong{--recend}). Each block is passed
to @strong{sort} and the output from @strong{sort} is saved into files. These
files are passed to the second @strong{parallel} that runs @strong{sort -m} on the
files before it removes the files. The output is saved to
@strong{bigfile.sort}.

GNU @strong{parallel}'s @strong{--pipe} maxes out at around 100 MB/s because every
byte has to be copied through GNU @strong{parallel}. But if @strong{bigfile} is a
real (seekable) file GNU @strong{parallel} can by-pass the copying and send
the parts directly to the program:

@verbatim
  parallel --pipe-part --block 100m -a bigfile --files sort |\
    parallel -Xj1 sort -m {} ';' rm {} >bigfile.sort
@end verbatim

@node EXAMPLE: Grouping input lines
@section EXAMPLE: Grouping input lines

When processing with @strong{--pipe} you may have lines grouped by a
value. Here is @emph{my.csv}:

@verbatim
   Transaction Customer Item
        1       a       53
        2       b       65
        3       b       82
        4       c       96
        5       c       67
        6       c       13
        7       d       90
        8       d       43
        9       d       91
        10      d       84
        11      e       72
        12      e       102
        13      e       63
        14      e       56
        15      e       74
@end verbatim

Let us assume you want GNU @strong{parallel} to process each customer. In
other words: You want all the transactions for a single customer to be
treated as a single record.

To do this we preprocess the data with a program that inserts a record
separator before each customer (column 2 = $F[1]). Here we first make
a 50 character random string, which we then use as the separator:

@verbatim
  sep=`perl -e 'print map { ("a".."z","A".."Z")[rand(52)] } (1..50);'`
  cat my.csv | \
     perl -ape '$F[1] ne $l and print "'$sep'"; $l = $F[1]' | \
     parallel --recend $sep --rrs --pipe -N1 wc
@end verbatim

If your program can process multiple customers replace @strong{-N1} with a
reasonable @strong{--blocksize}.

@node EXAMPLE: Running more than 250 jobs workaround
@section EXAMPLE: Running more than 250 jobs workaround

If you need to run a massive amount of jobs in parallel, then you will
likely hit the filehandle limit which is often around 250 jobs. If you
are super user you can raise the limit in /etc/security/limits.conf
but you can also use this workaround. The filehandle limit is per
process. That means that if you just spawn more GNU @strong{parallel}s then
each of them can run 250 jobs. This will spawn up to 2500 jobs:

@verbatim
  cat myinput |\
    parallel --pipe -N 50 --round-robin -j50 parallel -j50 your_prg
@end verbatim

This will spawn up to 62500 jobs (use with caution - you need 64 GB
RAM to do this, and you may need to increase /proc/sys/kernel/pid_max):

@verbatim
  cat myinput |\
    parallel --pipe -N 250 --round-robin -j250 parallel -j250 your_prg
@end verbatim

@node EXAMPLE: Working as mutex and counting semaphore
@section EXAMPLE: Working as mutex and counting semaphore

The command @strong{sem} is an alias for @strong{parallel --semaphore}.

A counting semaphore will allow a given number of jobs to be started
in the background.  When the number of jobs are running in the
background, GNU @strong{sem} will wait for one of these to complete before
starting another command. @strong{sem --wait} will wait for all jobs to
complete.

Run 10 jobs concurrently in the background:

@verbatim
  for i in *.log ; do
    echo $i
    sem -j10 gzip $i ";" echo done
  done
  sem --wait
@end verbatim

A mutex is a counting semaphore allowing only one job to run. This
will edit the file @emph{myfile} and prepends the file with lines with the
numbers 1 to 3.

@verbatim
  seq 3 | parallel sem sed -i -e '1i{}' myfile
@end verbatim

As @emph{myfile} can be very big it is important only one process edits
the file at the same time.

Name the semaphore to have multiple different semaphores active at the
same time:

@verbatim
  seq 3 | parallel sem --id mymutex sed -i -e '1i{}' myfile
@end verbatim

@node EXAMPLE: Mutex for a script
@section EXAMPLE: Mutex for a script

Assume a script is called from cron or from a web service, but only
one instance can be run at a time. With @strong{sem} and @strong{--shebang-wrap}
the script can be made to wait for other instances to finish. Here in
@strong{bash}:

@verbatim
  #!/usr/bin/sem --shebang-wrap -u --id $0 --fg /bin/bash
  
  echo This will run
  sleep 5
  echo exclusively
@end verbatim

Here @strong{perl}:

@verbatim
  #!/usr/bin/sem --shebang-wrap -u --id $0 --fg /usr/bin/perl
  
  print "This will run ";
  sleep 5;
  print "exclusively\n";
@end verbatim

Here @strong{python}:

@verbatim
  #!/usr/local/bin/sem --shebang-wrap -u --id $0 --fg /usr/bin/python
  
  import time
  print "This will run ";
  time.sleep(5)
  print "exclusively";
@end verbatim

@node EXAMPLE: Start editor with filenames from stdin (standard input)
@section EXAMPLE: Start editor with filenames from stdin (standard input)

You can use GNU @strong{parallel} to start interactive programs like emacs or vi:

@verbatim
  cat filelist | parallel --tty -X emacs
  cat filelist | parallel --tty -X vi
@end verbatim

If there are more files than will fit on a single command line, the
editor will be started again with the remaining files.

@node EXAMPLE: Running sudo
@section EXAMPLE: Running sudo

@strong{sudo} requires a password to run a command as root. It caches the
access, so you only need to enter the password again if you have not
used @strong{sudo} for a while.

The command:

@verbatim
  parallel sudo echo ::: This is a bad idea
@end verbatim

is no good, as you would be prompted for the sudo password for each of
the jobs. Instead do:

@verbatim
  sudo parallel echo ::: This is a good idea
@end verbatim

This way you only have to enter the sudo password once.

@node EXAMPLE: Run ping in parallel
@section EXAMPLE: Run ping in parallel

@strong{ping} prints out statistics when killed with CTRL-C.

Unfortunately, CTRL-C will also normally kill GNU @strong{parallel}.

But by using @strong{--open-tty} and ignoring SIGINT you can get the wanted effect:

@verbatim
  parallel -j0 --open-tty --lb --tag ping '{= $SIG{INT}=sub {} =}' \
    ::: 1.1.1.1 8.8.8.8 9.9.9.9 21.21.21.21 80.80.80.80 88.88.88.88
@end verbatim

@strong{--open-tty} will make the @strong{ping}s receive SIGINT (from CTRL-C).
CTRL-C will not kill GNU @strong{parallel}, so that will only exit after
@strong{ping} is done.

@node EXAMPLE: GNU Parallel as queue system/batch manager
@section EXAMPLE: GNU Parallel as queue system/batch manager

GNU @strong{parallel} can work as a simple job queue system or batch manager.
The idea is to put the jobs into a file and have GNU @strong{parallel} read
from that continuously. As GNU @strong{parallel} will stop at end of file we
use @strong{tail} to continue reading:

@verbatim
  true >jobqueue; tail -n+0 -f jobqueue | parallel
@end verbatim

To submit your jobs to the queue:

@verbatim
  echo my_command my_arg >> jobqueue
@end verbatim

You can of course use @strong{-S} to distribute the jobs to remote
computers:

@verbatim
  true >jobqueue; tail -n+0 -f jobqueue | parallel -S ..
@end verbatim

Output only will be printed when reading the next input after a job
has finished: So you need to submit a job after the first has finished
to see the output from the first job.

If you keep this running for a long time, jobqueue will grow. A way of
removing the jobs already run is by making GNU @strong{parallel} stop when
it hits a special value and then restart. To use @strong{--eof} to make GNU
@strong{parallel} exit, @strong{tail} also needs to be forced to exit:

@verbatim
  true >jobqueue;
  while true; do
    tail -n+0 -f jobqueue |
      (parallel -E StOpHeRe -S ..; echo GNU Parallel is now done;
       perl -e 'while(<>){/StOpHeRe/ and last};print <>' jobqueue > j2;
       (seq 1000 >> jobqueue &);
       echo Done appending dummy data forcing tail to exit)
    echo tail exited;
    mv j2 jobqueue
  done
@end verbatim

In some cases you can run on more CPUs and computers during the night:

@verbatim
  # Day time
  echo 50% > jobfile
  cp day_server_list ~/.parallel/sshloginfile
  # Night time
  echo 100% > jobfile
  cp night_server_list ~/.parallel/sshloginfile
  tail -n+0 -f jobqueue | parallel --jobs jobfile -S ..
@end verbatim

GNU @strong{parallel} discovers if @strong{jobfile} or @strong{~/.parallel/sshloginfile}
changes.

@node EXAMPLE: GNU Parallel as dir processor
@section EXAMPLE: GNU Parallel as dir processor

If you have a dir in which users drop files that needs to be processed
you can do this on GNU/Linux (If you know what @strong{inotifywait} is
called on other platforms file a bug report):

@verbatim
  inotifywait -qmre MOVED_TO -e CLOSE_WRITE --format %w%f my_dir |\
    parallel -u echo
@end verbatim

This will run the command @strong{echo} on each file put into @strong{my_dir} or
subdirs of @strong{my_dir}.

You can of course use @strong{-S} to distribute the jobs to remote
computers:

@verbatim
  inotifywait -qmre MOVED_TO -e CLOSE_WRITE --format %w%f my_dir |\
    parallel -S ..  -u echo
@end verbatim

If the files to be processed are in a tar file then unpacking one file
and processing it immediately may be faster than first unpacking all
files. Set up the dir processor as above and unpack into the dir.

Using GNU @strong{parallel} as dir processor has the same limitations as
using GNU @strong{parallel} as queue system/batch manager.

@node EXAMPLE: Locate the missing package
@section EXAMPLE: Locate the missing package

If you have downloaded source and tried compiling it, you may have seen:

@verbatim
  $ ./configure
  [...]
  checking for something.h... no
  configure: error: "libsomething not found"
@end verbatim

Often it is not obvious which package you should install to get that
file. Debian has `apt-file` to search for a file. `tracefile` from
https://gitlab.com/ole.tange/tangetools can tell which files a program
tried to access. In this case we are interested in one of the last
files:

@verbatim
  $ tracefile -un ./configure | tail | parallel -j0 apt-file search
@end verbatim

@node AUTHOR
@chapter AUTHOR

When using GNU @strong{parallel} for a publication please cite:

O. Tange (2011): GNU Parallel - The Command-Line Power Tool, ;login:
The USENIX Magazine, February 2011:42-47.

This helps funding further development; and it won't cost you a cent.
If you pay 10000 EUR you should feel free to use GNU Parallel without citing.

Copyright (C) 2007-10-18 Ole Tange, http://ole.tange.dk

Copyright (C) 2008-2010 Ole Tange, http://ole.tange.dk

Copyright (C) 2010-2023 Ole Tange, http://ole.tange.dk and Free
Software Foundation, Inc.

Parts of the manual concerning @strong{xargs} compatibility is inspired by
the manual of @strong{xargs} from GNU findutils 4.4.2.

@node LICENSE
@chapter LICENSE

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
at your option any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.

@menu
* Documentation license I::
* Documentation license II::
@end menu

@node Documentation license I
@section Documentation license I

Permission is granted to copy, distribute and/or modify this
documentation under the terms of the GNU Free Documentation License,
Version 1.3 or any later version published by the Free Software
Foundation; with no Invariant Sections, with no Front-Cover Texts, and
with no Back-Cover Texts.  A copy of the license is included in the
file LICENSES/GFDL-1.3-or-later.txt.

@node Documentation license II
@section Documentation license II

You are free:

@table @asis
@item @strong{to Share}
@anchor{@strong{to Share}}

to copy, distribute and transmit the work

@item @strong{to Remix}
@anchor{@strong{to Remix}}

to adapt the work

@end table

Under the following conditions:

@table @asis
@item @strong{Attribution}
@anchor{@strong{Attribution}}

You must attribute the work in the manner specified by the author or
licensor (but not in any way that suggests that they endorse you or
your use of the work).

@item @strong{Share Alike}
@anchor{@strong{Share Alike}}

If you alter, transform, or build upon this work, you may distribute
the resulting work only under the same, similar or a compatible
license.

@end table

With the understanding that:

@table @asis
@item @strong{Waiver}
@anchor{@strong{Waiver}}

Any of the above conditions can be waived if you get permission from
the copyright holder.

@item @strong{Public Domain}
@anchor{@strong{Public Domain}}

Where the work or any of its elements is in the public domain under
applicable law, that status is in no way affected by the license.

@item @strong{Other Rights}
@anchor{@strong{Other Rights}}

In no way are any of the following rights affected by the license:

@itemize
@item Your fair dealing or fair use rights, or other applicable
copyright exceptions and limitations;

@item The author's moral rights;

@item Rights other persons may have either in the work itself or in
how the work is used, such as publicity or privacy rights.

@end itemize

@end table

@table @asis
@item @strong{Notice}
@anchor{@strong{Notice}}

For any reuse or distribution, you must make clear to others the
license terms of this work.

@end table

A copy of the full license is included in the file as
LICENCES/CC-BY-SA-4.0.txt

@node SEE ALSO
@chapter SEE ALSO

@strong{parallel}(1), @strong{parallel_tutorial}(7), @strong{env_parallel}(1),
@strong{parset}(1), @strong{parsort}(1), @strong{parallel_alternatives}(7),
@strong{parallel_design}(7), @strong{niceload}(1), @strong{sql}(1), @strong{ssh}(1),
@strong{ssh-agent}(1), @strong{sshpass}(1), @strong{ssh-copy-id}(1), @strong{rsync}(1)

@bye
