<?xml version="1.0" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>GNU Parallel alternatives</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<link rev="made" href="mailto:root@localhost" />
</head>
<body>
<ul id="index">
<li><a href="#NAME">NAME</a></li>
<li><a href="#DIFFERENCES-BETWEEN-GNU-Parallel-AND-ALTERNATIVES">DIFFERENCES BETWEEN GNU Parallel AND ALTERNATIVES</a>
<ul>
<li><a href="#SUMMARY-TABLE">SUMMARY TABLE</a></li>
<li><a href="#DIFFERENCES-BETWEEN-xargs-AND-GNU-Parallel">DIFFERENCES BETWEEN xargs AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-find--exec-AND-GNU-Parallel">DIFFERENCES BETWEEN find -exec AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-make--j-AND-GNU-Parallel">DIFFERENCES BETWEEN make -j AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-ppss-AND-GNU-Parallel">DIFFERENCES BETWEEN ppss AND GNU Parallel</a>
<ul>
<li><a href="#EXAMPLES-FROM-ppss-MANUAL">EXAMPLES FROM ppss MANUAL</a></li>
</ul>
</li>
<li><a href="#DIFFERENCES-BETWEEN-pexec-AND-GNU-Parallel">DIFFERENCES BETWEEN pexec AND GNU Parallel</a>
<ul>
<li><a href="#EXAMPLES-FROM-pexec-MANUAL">EXAMPLES FROM pexec MANUAL</a></li>
</ul>
</li>
<li><a href="#DIFFERENCES-BETWEEN-xjobs-AND-GNU-Parallel">DIFFERENCES BETWEEN xjobs AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-prll-AND-GNU-Parallel">DIFFERENCES BETWEEN prll AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-dxargs-AND-GNU-Parallel">DIFFERENCES BETWEEN dxargs AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-mdm-middleman-AND-GNU-Parallel">DIFFERENCES BETWEEN mdm/middleman AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-xapply-AND-GNU-Parallel">DIFFERENCES BETWEEN xapply AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-AIX-apply-AND-GNU-Parallel">DIFFERENCES BETWEEN AIX apply AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-paexec-AND-GNU-Parallel">DIFFERENCES BETWEEN paexec AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-map-AND-GNU-Parallel">DIFFERENCES BETWEEN map AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-ladon-AND-GNU-Parallel">DIFFERENCES BETWEEN ladon AND GNU Parallel</a>
<ul>
<li><a href="#EXAMPLES-FROM-ladon-MANUAL">EXAMPLES FROM ladon MANUAL</a></li>
</ul>
</li>
<li><a href="#DIFFERENCES-BETWEEN-jobflow-AND-GNU-Parallel">DIFFERENCES BETWEEN jobflow AND GNU Parallel</a>
<ul>
<li><a href="#EXAMPLES-FROM-jobflow-README">EXAMPLES FROM jobflow README</a></li>
</ul>
</li>
<li><a href="#DIFFERENCES-BETWEEN-gargs-AND-GNU-Parallel">DIFFERENCES BETWEEN gargs AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-orgalorg-AND-GNU-Parallel">DIFFERENCES BETWEEN orgalorg AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-Rust-parallel-AND-GNU-Parallel">DIFFERENCES BETWEEN Rust parallel AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-Rush-AND-GNU-Parallel">DIFFERENCES BETWEEN Rush AND GNU Parallel</a></li>
<li><a href="#DIFFERENCES-BETWEEN-ClusterSSH-AND-GNU-Parallel">DIFFERENCES BETWEEN ClusterSSH AND GNU Parallel</a></li>
</ul>
</li>
<li><a href="#AUTHOR">AUTHOR</a></li>
<li><a href="#LICENSE">LICENSE</a>
<ul>
<li><a href="#Documentation-license-I">Documentation license I</a></li>
<li><a href="#Documentation-license-II">Documentation license II</a></li>
</ul>
</li>
<li><a href="#DEPENDENCIES">DEPENDENCIES</a></li>
<li><a href="#SEE-ALSO">SEE ALSO</a></li>
</ul>
<h1 id="NAME">NAME</h1>
<p>parallel_alternatives - Alternatives to GNU <b>parallel</b></p>
<h1 id="DIFFERENCES-BETWEEN-GNU-Parallel-AND-ALTERNATIVES">DIFFERENCES BETWEEN GNU Parallel AND ALTERNATIVES</h1>
<p>There are a lot programs with some of the functionality of GNU <b>parallel</b>. GNU <b>parallel</b> strives to include the best of the functionality without sacrificing ease of use.</p>
<h2 id="SUMMARY-TABLE">SUMMARY TABLE</h2>
<p>The following features are in some of the comparable tools:</p>
<p>Inputs I1. Arguments can be read from stdin I2. Arguments can be read from a file I3. Arguments can be read from multiple files I4. Arguments can be read from command line I5. Arguments can be read from a table I6. Arguments can be read from the same file using #! (shebang) I7. Line oriented input as default (Quoting of special chars not needed)</p>
<p>Manipulation of input M1. Composed command M2. Multiple arguments can fill up an execution line M3. Arguments can be put anywhere in the execution line M4. Multiple arguments can be put anywhere in the execution line M5. Arguments can be replaced with context M6. Input can be treated as the complete command line</p>
<p>Outputs O1. Grouping output so output from different jobs do not mix O2. Send stderr (standard error) to stderr (standard error) O3. Send stdout (standard output) to stdout (standard output) O4. Order of output can be same as order of input O5. Stdout only contains stdout (standard output) from the command O6. Stderr only contains stderr (standard error) from the command</p>
<p>Execution E1. Running jobs in parallel E2. List running jobs E3. Finish running jobs, but do not start new jobs E4. Number of running jobs can depend on number of cpus E5. Finish running jobs, but do not start new jobs after first failure E6. Number of running jobs can be adjusted while running</p>
<p>Remote execution R1. Jobs can be run on remote computers R2. Basefiles can be transferred R3. Argument files can be transferred R4. Result files can be transferred R5. Cleanup of transferred files R6. No config files needed R7. Do not run more than SSHD's MaxStartups can handle R8. Configurable SSH command R9. Retry if connection breaks occasionally</p>
<p>Semaphore S1. Possibility to work as a mutex S2. Possibility to work as a counting semaphore</p>
<p>Legend - = no x = not applicable ID = yes</p>
<p>As every new version of the programs are not tested the table may be outdated. Please file a bug-report if you find errors (See REPORTING BUGS).</p>
<p>parallel: I1 I2 I3 I4 I5 I6 I7 M1 M2 M3 M4 M5 M6 O1 O2 O3 O4 O5 O6 E1 E2 E3 E4 E5 E6 R1 R2 R3 R4 R5 R6 R7 R8 R9 S1 S2</p>
<p>xargs: I1 I2 - - - - - - M2 M3 - - - - O2 O3 - O5 O6 E1 - - - - - - - - - - x - - - - -</p>
<p>find -exec: - - - x - x - - M2 M3 - - - - - O2 O3 O4 O5 O6 - - - - - - - - - - - - - - - - x x</p>
<p>make -j: - - - - - - - - - - - - - O1 O2 O3 - x O6 E1 - - - E5 - - - - - - - - - - - -</p>
<p>ppss: I1 I2 - - - - I7 M1 - M3 - - M6 O1 - - x - - E1 E2 ?E3 E4 - - R1 R2 R3 R4 - - ?R7 ? ? - -</p>
<p>pexec: I1 I2 - I4 I5 - - M1 - M3 - - M6 O1 O2 O3 - O5 O6 E1 - - E4 - E6 R1 - - - - R6 - - - S1 -</p>
<p>xjobs, prll, dxargs, mdm/middelman, xapply, paexec, ladon, jobflow, ClusterSSH: TODO - Please file a bug-report if you know what features they support (See REPORTING BUGS).</p>
<h2 id="DIFFERENCES-BETWEEN-xargs-AND-GNU-Parallel">DIFFERENCES BETWEEN xargs AND GNU Parallel</h2>
<p><b>xargs</b> offers some of the same possibilities as GNU <b>parallel</b>.</p>
<p><b>xargs</b> deals badly with special characters (such as space, \, ' and "). To see the problem try this:</p>
<pre><code> touch important_file
touch 'not important_file'
ls not* | xargs rm
mkdir -p "My brother's 12\" records"
ls | xargs rmdir
touch 'c:\windows\system32\clfs.sys'
echo 'c:\windows\system32\clfs.sys' | xargs ls -l</code></pre>
<p>You can specify <b>-0</b>, but many input generators are not optimized for using <b>NUL</b> as separator but are optimized for <b>newline</b> as separator. E.g <b>head</b>, <b>tail</b>, <b>awk</b>, <b>ls</b>, <b>echo</b>, <b>sed</b>, <b>tar -v</b>, <b>perl</b> (<b>-0</b> and \0 instead of \n), <b>locate</b> (requires using <b>-0</b>), <b>find</b> (requires using <b>-print0</b>), <b>grep</b> (requires user to use <b>-z</b> or <b>-Z</b>), <b>sort</b> (requires using <b>-z</b>).</p>
<p>GNU <b>parallel</b>'s newline separation can be emulated with:</p>
<p><b>cat | xargs -d "\n" -n1 <i>command</i></b></p>
<p><b>xargs</b> can run a given number of jobs in parallel, but has no support for running number-of-cpu-cores jobs in parallel.</p>
<p><b>xargs</b> has no support for grouping the output, therefore output may run together, e.g. the first half of a line is from one process and the last half of the line is from another process. The example <b>Parallel grep</b> cannot be done reliably with <b>xargs</b> because of this. To see this in action try:</p>
<pre><code> parallel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} \
::: a b c d e f
ls -l a b c d e f
parallel -kP4 -n1 grep 1 > out.par ::: a b c d e f
echo a b c d e f | xargs -P4 -n1 grep 1 > out.xargs-unbuf
echo a b c d e f | \
xargs -P4 -n1 grep --line-buffered 1 > out.xargs-linebuf
echo a b c d e f | xargs -n1 grep 1 > out.xargs-serial
ls -l out*
md5sum out*</code></pre>
<p><b>xargs</b> has no support for keeping the order of the output, therefore if running jobs in parallel using <b>xargs</b> the output of the second job cannot be postponed till the first job is done.</p>
<p><b>xargs</b> has no support for running jobs on remote computers.</p>
<p><b>xargs</b> has no support for context replace, so you will have to create the arguments.</p>
<p>If you use a replace string in <b>xargs</b> (<b>-I</b>) you can not force <b>xargs</b> to use more than one argument.</p>
<p>Quoting in <b>xargs</b> works like <b>-q</b> in GNU <b>parallel</b>. This means composed commands and redirection require using <b>bash -c</b>.</p>
<pre><code> ls | parallel "wc {} >{}.wc"
ls | parallel "echo {}; ls {}|wc"</code></pre>
<p>becomes (assuming you have 8 cores)</p>
<pre><code> ls | xargs -d "\n" -P8 -I {} bash -c "wc {} >{}.wc"
ls | xargs -d "\n" -P8 -I {} bash -c "echo {}; ls {}|wc"</code></pre>
<h2 id="DIFFERENCES-BETWEEN-find--exec-AND-GNU-Parallel">DIFFERENCES BETWEEN find -exec AND GNU Parallel</h2>
<p><b>find -exec</b> offer some of the same possibilities as GNU <b>parallel</b>.</p>
<p><b>find -exec</b> only works on files. So processing other input (such as hosts or URLs) will require creating these inputs as files. <b>find -exec</b> has no support for running commands in parallel.</p>
<h2 id="DIFFERENCES-BETWEEN-make--j-AND-GNU-Parallel">DIFFERENCES BETWEEN make -j AND GNU Parallel</h2>
<p><b>make -j</b> can run jobs in parallel, but requires a crafted Makefile to do this. That results in extra quoting to get filename containing newline to work correctly.</p>
<p><b>make -j</b> computes a dependency graph before running jobs. Jobs run by GNU <b>parallel</b> does not depend on eachother.</p>
<p>(Very early versions of GNU <b>parallel</b> were coincidently implemented using <b>make -j</b>).</p>
<h2 id="DIFFERENCES-BETWEEN-ppss-AND-GNU-Parallel">DIFFERENCES BETWEEN ppss AND GNU Parallel</h2>
<p><b>ppss</b> is also a tool for running jobs in parallel.</p>
<p>The output of <b>ppss</b> is status information and thus not useful for using as input for another command. The output from the jobs are put into files.</p>
<p>The argument replace string ($ITEM) cannot be changed. Arguments must be quoted - thus arguments containing special characters (space '"&!*) may cause problems. More than one argument is not supported. File names containing newlines are not processed correctly. When reading input from a file null cannot be used as a terminator. <b>ppss</b> needs to read the whole input file before starting any jobs.</p>
<p>Output and status information is stored in ppss_dir and thus requires cleanup when completed. If the dir is not removed before running <b>ppss</b> again it may cause nothing to happen as <b>ppss</b> thinks the task is already done. GNU <b>parallel</b> will normally not need cleaning up if running locally and will only need cleaning up if stopped abnormally and running remote (<b>--cleanup</b> may not complete if stopped abnormally). The example <b>Parallel grep</b> would require extra postprocessing if written using <b>ppss</b>.</p>
<p>For remote systems PPSS requires 3 steps: config, deploy, and start. GNU <b>parallel</b> only requires one step.</p>
<h3 id="EXAMPLES-FROM-ppss-MANUAL">EXAMPLES FROM ppss MANUAL</h3>
<p>Here are the examples from <b>ppss</b>'s manual page with the equivalent using GNU <b>parallel</b>:</p>
<p><b>1</b> ./ppss.sh standalone -d /path/to/files -c 'gzip '</p>
<p><b>1</b> find /path/to/files -type f | parallel gzip</p>
<p><b>2</b> ./ppss.sh standalone -d /path/to/files -c 'cp "$ITEM" /destination/dir '</p>
<p><b>2</b> find /path/to/files -type f | parallel cp {} /destination/dir</p>
<p><b>3</b> ./ppss.sh standalone -f list-of-urls.txt -c 'wget -q '</p>
<p><b>3</b> parallel -a list-of-urls.txt wget -q</p>
<p><b>4</b> ./ppss.sh standalone -f list-of-urls.txt -c 'wget -q "$ITEM"'</p>
<p><b>4</b> parallel -a list-of-urls.txt wget -q {}</p>
<p><b>5</b> ./ppss config -C config.cfg -c 'encode.sh ' -d /source/dir -m 192.168.1.100 -u ppss -k ppss-key.key -S ./encode.sh -n nodes.txt -o /some/output/dir --upload --download ; ./ppss deploy -C config.cfg ; ./ppss start -C config</p>
<p><b>5</b> # parallel does not use configs. If you want a different username put it in nodes.txt: user@hostname</p>
<p><b>5</b> find source/dir -type f | parallel --sshloginfile nodes.txt --trc {.}.mp3 lame -a {} -o {.}.mp3 --preset standard --quiet</p>
<p><b>6</b> ./ppss stop -C config.cfg</p>
<p><b>6</b> killall -TERM parallel</p>
<p><b>7</b> ./ppss pause -C config.cfg</p>
<p><b>7</b> Press: CTRL-Z or killall -SIGTSTP parallel</p>
<p><b>8</b> ./ppss continue -C config.cfg</p>
<p><b>8</b> Enter: fg or killall -SIGCONT parallel</p>
<p><b>9</b> ./ppss.sh status -C config.cfg</p>
<p><b>9</b> killall -SIGUSR2 parallel</p>
<h2 id="DIFFERENCES-BETWEEN-pexec-AND-GNU-Parallel">DIFFERENCES BETWEEN pexec AND GNU Parallel</h2>
<p><b>pexec</b> is also a tool for running jobs in parallel.</p>
<h3 id="EXAMPLES-FROM-pexec-MANUAL">EXAMPLES FROM pexec MANUAL</h3>
<p>Here are the examples from <b>pexec</b>'s info page with the equivalent using GNU <b>parallel</b>:</p>
<p><b>1</b> pexec -o sqrt-%s.dat -p "$(seq 10)" -e NUM -n 4 -c -- \ 'echo "scale=10000;sqrt($NUM)" | bc'</p>
<p><b>1</b> seq 10 | parallel -j4 'echo "scale=10000;sqrt({})" | bc > sqrt-{}.dat'</p>
<p><b>2</b> pexec -p "$(ls myfiles*.ext)" -i %s -o %s.sort -- sort</p>
<p><b>2</b> ls myfiles*.ext | parallel sort {} ">{}.sort"</p>
<p><b>3</b> pexec -f image.list -n auto -e B -u star.log -c -- \ 'fistar $B.fits -f 100 -F id,x,y,flux -o $B.star'</p>
<p><b>3</b> parallel -a image.list \ 'fistar {}.fits -f 100 -F id,x,y,flux -o {}.star' 2>star.log</p>
<p><b>4</b> pexec -r *.png -e IMG -c -o - -- \ 'convert $IMG ${IMG%.png}.jpeg ; "echo $IMG: done"'</p>
<p><b>4</b> ls *.png | parallel 'convert {} {.}.jpeg; echo {}: done'</p>
<p><b>5</b> pexec -r *.png -i %s -o %s.jpg -c 'pngtopnm | pnmtojpeg'</p>
<p><b>5</b> ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {}.jpg'</p>
<p><b>6</b> for p in *.png ; do echo ${p%.png} ; done | \ pexec -f - -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'</p>
<p><b>6</b> ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {.}.jpg'</p>
<p><b>7</b> LIST=$(for p in *.png ; do echo ${p%.png} ; done) pexec -r $LIST -i %s.png -o %s.jpg -c 'pngtopnm | pnmtojpeg'</p>
<p><b>7</b> ls *.png | parallel 'pngtopnm < {} | pnmtojpeg > {.}.jpg'</p>
<p><b>8</b> pexec -n 8 -r *.jpg -y unix -e IMG -c \ 'pexec -j -m blockread -d $IMG | \ jpegtopnm | pnmscale 0.5 | pnmtojpeg | \ pexec -j -m blockwrite -s th_$IMG'</p>
<p><b>8</b> Combining GNU <b>parallel</b> and GNU <b>sem</b>.</p>
<p><b>8</b> ls *jpg | parallel -j8 'sem --id blockread cat {} | jpegtopnm |' \ 'pnmscale 0.5 | pnmtojpeg | sem --id blockwrite cat > th_{}'</p>
<p><b>8</b> If reading and writing is done to the same disk, this may be faster as only one process will be either reading or writing:</p>
<p><b>8</b> ls *jpg | parallel -j8 'sem --id diskio cat {} | jpegtopnm |' \ 'pnmscale 0.5 | pnmtojpeg | sem --id diskio cat > th_{}'</p>
<h2 id="DIFFERENCES-BETWEEN-xjobs-AND-GNU-Parallel">DIFFERENCES BETWEEN xjobs AND GNU Parallel</h2>
<p><b>xjobs</b> is also a tool for running jobs in parallel. It only supports running jobs on your local computer.</p>
<p><b>xjobs</b> deals badly with special characters just like <b>xargs</b>. See the section <b>DIFFERENCES BETWEEN xargs AND GNU Parallel</b>.</p>
<p>Here are the examples from <b>xjobs</b>'s man page with the equivalent using GNU <b>parallel</b>:</p>
<p><b>1</b> ls -1 *.zip | xjobs unzip</p>
<p><b>1</b> ls *.zip | parallel unzip</p>
<p><b>2</b> ls -1 *.zip | xjobs -n unzip</p>
<p><b>2</b> ls *.zip | parallel unzip >/dev/null</p>
<p><b>3</b> find . -name '*.bak' | xjobs gzip</p>
<p><b>3</b> find . -name '*.bak' | parallel gzip</p>
<p><b>4</b> ls -1 *.jar | sed 's/\(.*\)/\1 > \1.idx/' | xjobs jar tf</p>
<p><b>4</b> ls *.jar | parallel jar tf {} '>' {}.idx</p>
<p><b>5</b> xjobs -s script</p>
<p><b>5</b> cat script | parallel</p>
<p><b>6</b> mkfifo /var/run/my_named_pipe; xjobs -s /var/run/my_named_pipe & echo unzip 1.zip >> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >> /var/run/my_named_pipe</p>
<p><b>6</b> mkfifo /var/run/my_named_pipe; cat /var/run/my_named_pipe | parallel & echo unzip 1.zip >> /var/run/my_named_pipe; echo tar cf /backup/myhome.tar /home/me >> /var/run/my_named_pipe</p>
<h2 id="DIFFERENCES-BETWEEN-prll-AND-GNU-Parallel">DIFFERENCES BETWEEN prll AND GNU Parallel</h2>
<p><b>prll</b> is also a tool for running jobs in parallel. It does not support running jobs on remote computers.</p>
<p><b>prll</b> encourages using BASH aliases and BASH functions instead of scripts. GNU <b>parallel</b> supports scripts directly, functions if they are exported using <b>export -f</b>, and aliases if using <b>env_parallel</b>.</p>
<p><b>prll</b> generates a lot of status information on stderr (standard error) which makes it harder to use the stderr (standard error) output of the job directly as input for another program.</p>
<p>Here is the example from <b>prll</b>'s man page with the equivalent using GNU <b>parallel</b>:</p>
<pre><code> prll -s 'mogrify -flip $1' *.jpg
parallel mogrify -flip ::: *.jpg</code></pre>
<h2 id="DIFFERENCES-BETWEEN-dxargs-AND-GNU-Parallel">DIFFERENCES BETWEEN dxargs AND GNU Parallel</h2>
<p><b>dxargs</b> is also a tool for running jobs in parallel.</p>
<p><b>dxargs</b> does not deal well with more simultaneous jobs than SSHD's MaxStartups. <b>dxargs</b> is only built for remote run jobs, but does not support transferring of files.</p>
<h2 id="DIFFERENCES-BETWEEN-mdm-middleman-AND-GNU-Parallel">DIFFERENCES BETWEEN mdm/middleman AND GNU Parallel</h2>
<p>middleman(mdm) is also a tool for running jobs in parallel.</p>
<p>Here are the shellscripts of http://mdm.berlios.de/usage.html ported to GNU <b>parallel</b>:</p>
<pre><code> seq 19 | parallel buffon -o - | sort -n > result
cat files | parallel cmd
find dir -execdir sem cmd {} \;</code></pre>
<h2 id="DIFFERENCES-BETWEEN-xapply-AND-GNU-Parallel">DIFFERENCES BETWEEN xapply AND GNU Parallel</h2>
<p><b>xapply</b> can run jobs in parallel on the local computer.</p>
<p>Here are the examples from <b>xapply</b>'s man page with the equivalent using GNU <b>parallel</b>:</p>
<p><b>1</b> xapply '(cd %1 && make all)' */</p>
<p><b>1</b> parallel 'cd {} && make all' ::: */</p>
<p><b>2</b> xapply -f 'diff %1 ../version5/%1' manifest | more</p>
<p><b>2</b> parallel diff {} ../version5/{} < manifest | more</p>
<p><b>3</b> xapply -p/dev/null -f 'diff %1 %2' manifest1 checklist1</p>
<p><b>3</b> parallel --link diff {1} {2} :::: manifest1 checklist1</p>
<p><b>4</b> xapply 'indent' *.c</p>
<p><b>4</b> parallel indent ::: *.c</p>
<p><b>5</b> find ~ksb/bin -type f ! -perm -111 -print | xapply -f -v 'chmod a+x' -</p>
<p><b>5</b> find ~ksb/bin -type f ! -perm -111 -print | parallel -v chmod a+x</p>
<p><b>6</b> find */ -... | fmt 960 1024 | xapply -f -i /dev/tty 'vi' -</p>
<p><b>6</b> sh <(find */ -... | parallel -s 1024 echo vi)</p>
<p><b>6</b> find */ -... | parallel -s 1024 -Xuj1 vi</p>
<p><b>7</b> find ... | xapply -f -5 -i /dev/tty 'vi' - - - - -</p>
<p><b>7</b> sh <(find ... |parallel -n5 echo vi)</p>
<p><b>7</b> find ... |parallel -n5 -uj1 vi</p>
<p><b>8</b> xapply -fn "" /etc/passwd</p>
<p><b>8</b> parallel -k echo < /etc/passwd</p>
<p><b>9</b> tr ':' '\012' < /etc/passwd | xapply -7 -nf 'chown %1 %6' - - - - - - -</p>
<p><b>9</b> tr ':' '\012' < /etc/passwd | parallel -N7 chown {1} {6}</p>
<p><b>10</b> xapply '[ -d %1/RCS ] || echo %1' */</p>
<p><b>10</b> parallel '[ -d {}/RCS ] || echo {}' ::: */</p>
<p><b>11</b> xapply -f '[ -f %1 ] && echo %1' List | ...</p>
<p><b>11</b> parallel '[ -f {} ] && echo {}' < List | ...</p>
<h2 id="DIFFERENCES-BETWEEN-AIX-apply-AND-GNU-Parallel">DIFFERENCES BETWEEN AIX apply AND GNU Parallel</h2>
<p><b>apply</b> can build command lines based on a template and arguments - very much like GNU <b>parallel</b>. <b>apply</b> does not run jobs in parallel. <b>apply</b> does not use an argument separator (like <b>:::</b>); instead the template must be the first argument.</p>
<p>Here are the examples from https://www-01.ibm.com/support/knowledgecenter/ssw_aix_71/com.ibm.aix.cmds1/apply.htm</p>
<p>1. To obtain results similar to those of the <b>ls</b> command, enter:</p>
<pre><code> apply echo *
parallel echo ::: *</code></pre>
<p>2. To compare the file named <b>a1</b> to the file named <b>b1</b>, and the file named <b>a2</b> to the file named <b>b2</b>, enter:</p>
<pre><code> apply -2 cmp a1 b1 a2 b2
parallel -N2 cmp ::: a1 b1 a2 b2</code></pre>
<p>3. To run the <b>who</b> command five times, enter:</p>
<pre><code> apply -0 who 1 2 3 4 5
parallel -N0 who ::: 1 2 3 4 5</code></pre>
<p>4. To link all files in the current directory to the directory <b>/usr/joe</b>, enter:</p>
<pre><code> apply 'ln %1 /usr/joe' *
parallel ln {} /usr/joe ::: *</code></pre>
<h2 id="DIFFERENCES-BETWEEN-paexec-AND-GNU-Parallel">DIFFERENCES BETWEEN paexec AND GNU Parallel</h2>
<p><b>paexec</b> can run jobs in parallel on both the local and remote computers.</p>
<p><b>paexec</b> requires commands to print a blank line as the last output. This means you will have to write a wrapper for most programs.</p>
<p><b>paexec</b> has a job dependency facility so a job can depend on another job to be executed successfully. Sort of a poor-man's <b>make</b>.</p>
<p>Here are the examples from <b>paexec</b>'s example catalog with the equivalent using GNU <b>parallel</b>:</p>
<dl>
<dt id="div_X_run">1_div_X_run:</dt>
<dd>
<pre><code> ../../paexec -s -l -c "`pwd`/1_div_X_cmd" -n +1 <<EOF [...]
parallel echo {} '|' `pwd`/1_div_X_cmd <<EOF [...]</code></pre>
</dd>
<dt id="all_substr_run">all_substr_run:</dt>
<dd>
<pre><code> ../../paexec -lp -c "`pwd`/all_substr_cmd" -n +3 <<EOF [...]
parallel echo {} '|' `pwd`/all_substr_cmd <<EOF [...]</code></pre>
</dd>
<dt id="cc_wrapper_run">cc_wrapper_run:</dt>
<dd>
<pre><code> ../../paexec -c "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-n 'host1 host2' \
-t '/usr/bin/ssh -x' <<EOF [...]
parallel echo {} '|' "env CC=gcc CFLAGS=-O2 `pwd`/cc_wrapper_cmd" \
-S host1,host2 <<EOF [...]
# This is not exactly the same, but avoids the wrapper
parallel gcc -O2 -c -o {.}.o {} \
-S host1,host2 <<EOF [...]</code></pre>
</dd>
<dt id="toupper_run">toupper_run:</dt>
<dd>
<pre><code> ../../paexec -lp -c "`pwd`/toupper_cmd" -n +10 <<EOF [...]
parallel echo {} '|' ./toupper_cmd <<EOF [...]
# Without the wrapper:
parallel echo {} '| awk {print\ toupper\(\$0\)}' <<EOF [...]</code></pre>
</dd>
</dl>
<h2 id="DIFFERENCES-BETWEEN-map-AND-GNU-Parallel">DIFFERENCES BETWEEN map AND GNU Parallel</h2>
<p><b>map</b> sees it as a feature to have less features and in doing so it also handles corner cases incorrectly. A lot of GNU <b>parallel</b>'s code is to handle corner cases correctly on every platform, so you will not get a nasty surprise if a user for example saves a file called: <i>My brother's 12" records.txt</i></p>
<p><b>map</b>'s example showing how to deal with special characters fails on special characters:</p>
<pre><code> echo "The Cure" > My\ brother\'s\ 12\"\ records
ls | \
map 'echo -n `gzip < "%" | wc -c`; echo -n '*100/'; wc -c < "%"' | bc</code></pre>
<p>It works with GNU <b>parallel</b>:</p>
<pre><code> ls | \
parallel 'echo -n `gzip < {} | wc -c`; echo -n '*100/'; wc -c < {}' | bc</code></pre>
<p>And you can even get the file name prepended:</p>
<pre><code> ls | \
parallel --tag '(echo -n `gzip < {} | wc -c`'*100/'; wc -c < {}) | bc'</code></pre>
<p><b>map</b> has no support for grouping. So this gives the wrong results without any warnings:</p>
<pre><code> parallel perl -e '\$a=\"1{}\"x10000000\;print\ \$a,\"\\n\"' '>' {} \
::: a b c d e f
ls -l a b c d e f
parallel -kP4 -n1 grep 1 > out.par ::: a b c d e f
map -p 4 'grep 1' a b c d e f > out.map-unbuf
map -p 4 'grep --line-buffered 1' a b c d e f > out.map-linebuf
map -p 1 'grep --line-buffered 1' a b c d e f > out.map-serial
ls -l out*
md5sum out*</code></pre>
<p>The documentation shows a workaround, but not only does that mix stdout (standard output) with stderr (standard error) it also fails completely for certain jobs (and may even be considered less readable):</p>
<pre><code> parallel echo -n {} ::: 1 2 3
map -p 4 'echo -n % 2>&1 | sed -e "s/^/$$:/"' 1 2 3 | sort | cut -f2- -d:</code></pre>
<p><b>map</b>s replacement strings (% %D %B %E) can be simulated in GNU <b>parallel</b> by putting this in <b>~/.parallel/config</b>:</p>
<pre><code> --rpl '%'
--rpl '%D $_=::shell_quote(::dirname($_));'
--rpl '%B s:.*/::;s:\.[^/.]+$::;'
--rpl '%E s:.*\.::'</code></pre>
<p><b>map</b> cannot handle bundled options: <b>map -vp 0 echo this fails</b></p>
<p><b>map</b> does not have an argument separator on the command line, but uses the first argument as command. This makes quoting harder which again may affect readability. Compare:</p>
<pre><code> map -p 2 perl\\\ -ne\\\ \\\'/^\\\\S+\\\\s+\\\\S+\\\$/\\\ and\\\ print\\\ \\\$ARGV,\\\"\\\\n\\\"\\\' *
parallel -q perl -ne '/^\S+\s+\S+$/ and print $ARGV,"\n"' ::: *</code></pre>
<p><b>map</b> can do multiple arguments with context replace, but not without context replace:</p>
<pre><code> parallel --xargs echo 'BEGIN{'{}'}END' ::: 1 2 3</code></pre>
<p><b>map</b> does not set exit value according to whether one of the jobs failed:</p>
<pre><code> parallel false ::: 1 || echo Job failed
map false 1 || echo Never run</code></pre>
<p><b>map</b> requires Perl v5.10.0 making it harder to use on old systems.</p>
<p><b>map</b> has no way of using % in the command (GNU Parallel has -I to specify another replacement string than <b>{}</b>).</p>
<p>By design <b>map</b> is option incompatible with <b>xargs</b>, it does not have remote job execution, a structured way of saving results, multiple input sources, progress indicator, configurable record delimiter (only field delimiter), logging of jobs run with possibility to resume, keeping the output in the same order as input, --pipe processing, and dynamically timeouts.</p>
<h2 id="DIFFERENCES-BETWEEN-ladon-AND-GNU-Parallel">DIFFERENCES BETWEEN ladon AND GNU Parallel</h2>
<p><b>ladon</b> can run multiple jobs on files in parallel.</p>
<p><b>ladon</b> only works on files and the only way to specify files is using a quoted glob string (such as \*.jpg). It is not possible to list the files manually.</p>
<p>As replacement strings it uses FULLPATH DIRNAME BASENAME EXT RELDIR RELPATH</p>
<p>These can be simulated using GNU <b>parallel</b> by putting this in <b>~/.parallel/config</b>:</p>
<pre><code> --rpl 'FULLPATH $_=::shell_quote($_);chomp($_=qx{readlink -f $_});'
--rpl 'DIRNAME $_=::shell_quote(::dirname($_));chomp($_=qx{readlink -f $_});'
--rpl 'BASENAME s:.*/::;s:\.[^/.]+$::;'
--rpl 'EXT s:.*\.::'
--rpl 'RELDIR $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::;$_=::dirname($_);'
--rpl 'RELPATH $_=::shell_quote($_);chomp(($_,$c)=qx{readlink -f $_;pwd});s:\Q$c/\E::;'</code></pre>
<p><b>ladon</b> deals badly with filenames containing " and newline, and it fails for output larger than 200k:</p>
<pre><code> ladon '*' -- seq 36000 | wc</code></pre>
<h3 id="EXAMPLES-FROM-ladon-MANUAL">EXAMPLES FROM ladon MANUAL</h3>
<p>It is assumed that the '--rpl's above are put in <b>~/.parallel/config</b> and that it is run under a shell that supports '**' globbing (such as <b>zsh</b>):</p>
<p><b>1</b> ladon "**/*.txt" -- echo RELPATH</p>
<p><b>1</b> parallel echo RELPATH ::: **/*.txt</p>
<p><b>2</b> ladon "~/Documents/**/*.pdf" -- shasum FULLPATH >hashes.txt</p>
<p><b>2</b> parallel shasum FULLPATH ::: ~/Documents/**/*.pdf >hashes.txt</p>
<p><b>3</b> ladon -m thumbs/RELDIR "**/*.jpg" -- convert FULLPATH -thumbnail 100x100^ -gravity center -extent 100x100 thumbs/RELPATH</p>
<p><b>3</b> parallel mkdir -p thumbs/RELDIR\; convert FULLPATH -thumbnail 100x100^ -gravity center -extent 100x100 thumbs/RELPATH ::: **/*.jpg</p>
<p><b>4</b> ladon "~/Music/*.wav" -- lame -V 2 FULLPATH DIRNAME/BASENAME.mp3</p>
<p><b>4</b> parallel lame -V 2 FULLPATH DIRNAME/BASENAME.mp3 ::: ~/Music/*.wav</p>
<h2 id="DIFFERENCES-BETWEEN-jobflow-AND-GNU-Parallel">DIFFERENCES BETWEEN jobflow AND GNU Parallel</h2>
<p><b>jobflow</b> can run multiple jobs in parallel.</p>
<p>Just like <b>xargs</b> output from <b>jobflow</b> jobs running in parallel mix together by default. <b>jobflow</b> can buffer into files (placed in /run/shm), but these are not cleaned up - not even if <b>jobflow</b> dies unexpectently. If the total output is big (in the order of RAM+swap) it can cause the system to run out of memory.</p>
<p><b>jobflow</b> gives no error if the command is unknown, and like <b>xargs</b> redirection requires wrapping with <b>bash -c</b>.</p>
<p><b>jobflow</b> makes it possible to set ressource limits on the running jobs. This can be emulated by GNU <b>parallel</b> using <b>bash</b>'s <b>ulimit</b>:</p>
<pre><code> jobflow -limits=mem=100M,cpu=3,fsize=20M,nofiles=300 myjob
parallel 'ulimit -v 102400 -t 3 -f 204800 -n 300 myjob'</code></pre>
<h3 id="EXAMPLES-FROM-jobflow-README">EXAMPLES FROM jobflow README</h3>
<p><b>1</b> cat things.list | jobflow -threads=8 -exec ./mytask {}</p>
<p><b>1</b> cat things.list | parallel -j8 ./mytask {}</p>
<p><b>2</b> seq 100 | jobflow -threads=100 -exec echo {}</p>
<p><b>2</b> seq 100 | parallel -j100 echo {}</p>
<p><b>3</b> cat urls.txt | jobflow -threads=32 -exec wget {}</p>
<p><b>3</b> cat urls.txt | parallel -j32 wget {}</p>
<p><b>4</b> find . -name '*.bmp' | jobflow -threads=8 -exec bmp2jpeg {.}.bmp {.}.jpg</p>
<p><b>4</b> find . -name '*.bmp' | parallel -j8 bmp2jpeg {.}.bmp {.}.jpg</p>
<h2 id="DIFFERENCES-BETWEEN-gargs-AND-GNU-Parallel">DIFFERENCES BETWEEN gargs AND GNU Parallel</h2>
<p><b>gargs</b> can run multiple jobs in parallel.</p>
<p>It caches output in memory. This causes it to be extremely slow when the output is larger than the physical RAM, and can cause the system to run out of memory.</p>
<p>See more details on this in <b>man parallel_design</b>.</p>
<p>Output to stderr (standard error) is changed if the command fails.</p>
<p>Here are the two examples from <b>gargs</b> website.</p>
<p><b>1</b> seq 12 -1 1 | gargs -p 4 -n 3 "sleep {0}; echo {1} {2}"</p>
<p><b>1</b> seq 12 -1 1 | parallel -P 4 -n 3 "sleep {1}; echo {2} {3}"</p>
<p><b>2</b> cat t.txt | gargs --sep "\s+" -p 2 "echo '{0}:{1}-{2}' full-line: \'{}\'"</p>
<p><b>2</b> cat t.txt | parallel --colsep "\\s+" -P 2 "echo '{1}:{2}-{3}' full-line: \'{}\'"</p>
<h2 id="DIFFERENCES-BETWEEN-orgalorg-AND-GNU-Parallel">DIFFERENCES BETWEEN orgalorg AND GNU Parallel</h2>
<p><b>orgalorg</b> can run the same job on multiple machines. This is related to <b>--onall</b> and <b>--nonall</b>.</p>
<p><b>orgalorg</b> supports entering the SSH password - provided it is the same for all servers. GNU <b>parallel</b> advocates using <b>ssh-agent</b> instead, but it is possible to emulate <b>orgalorg</b>'s behavior by setting SSHPASS and by using <b>--ssh "sshpass ssh"</b>.</p>
<p>To make the emulation easier, make a simple alias:</p>
<pre><code> alias par_emul="parallel -j0 --ssh 'sshpass ssh' --nonall --tag --linebuffer"</code></pre>
<p>If you want to supply a password run:</p>
<pre><code> SSHPASS=`ssh-askpass`</code></pre>
<p>or set the password directly:</p>
<pre><code> SSHPASS=P4$$w0rd!</code></pre>
<p>If the above is set up you can then do:</p>
<pre><code> orgalorg -o frontend1 -o frontend2 -p -C uptime
par_emul -S frontend1 -S frontend2 uptime
orgalorg -o frontend1 -o frontend2 -p -C top -bid 1
par_emul -S frontend1 -S frontend2 top -bid 1
orgalorg -o frontend1 -o frontend2 -p -er /tmp -n 'md5sum /tmp/bigfile' -S bigfile
par_emul -S frontend1 -S frontend2 --basefile bigfile --workdir /tmp md5sum /tmp/bigfile</code></pre>
<p><b>orgalorg</b> has a progress indicator for the transferring of a file. GNU <b>parallel</b> does not.</p>
<h2 id="DIFFERENCES-BETWEEN-Rust-parallel-AND-GNU-Parallel">DIFFERENCES BETWEEN Rust parallel AND GNU Parallel</h2>
<p>Rust parallel focuses on speed. It is almost as fast as <b>xargs</b>. It implements a few features from GNU <b>parallel</b>, but lacks many functions. All these fail:</p>
<pre><code> # Show what would be executed
parallel --dry-run echo ::: a
# Read arguments from file
parallel -a file echo
# Changing the delimiter
parallel -d _ echo ::: a_b_c_</code></pre>
<p>These do something different from GNU <b>parallel</b></p>
<pre><code> # Read more arguments at a time -n
parallel -n 2 echo ::: 1 a 2 b
# -q to protect quoted $ and space
parallel -q perl -e '$a=shift; print "$a"x10000000' ::: a b c
# Generation of combination of inputs
parallel echo {1} {2} ::: red green blue ::: S M L XL XXL
# {= perl expression =} replacement string
parallel echo '{= s/new/old/ =}' ::: my.new your.new
# --pipe
seq 100000 | parallel --pipe wc
# linked arguments
parallel echo ::: S M L :::+ small medium large ::: R G B :::+ red green blue
# Run different shell dialects
zsh -c 'parallel echo \={} ::: zsh && true'
csh -c 'parallel echo \$\{\} ::: shell && true'
bash -c 'parallel echo \$\({}\) ::: pwd && true'
# Rust parallel does not start before the last argument is read
(seq 10; sleep 5; echo 2) | time parallel -j2 'sleep 2; echo'
tail -f /var/log/syslog | parallel echo</code></pre>
<p>Rust parallel has no remote facilities.</p>
<p>It uses /tmp/parallel for tmp files and does not clean up if terminated abrubtly. If another user on the system uses Rust parallel, then /tmp/parallel will have the wrong permissions and Rust parallel will fail. A malicious user can setup the right permissions and symlink the output file to one of the user's files and next time the user uses Rust parallel it will overwrite this file.</p>
<p>If /tmp/parallel runs full during the run, Rust parallel does not report this, but finishes with success - thereby risking data loss.</p>
<h2 id="DIFFERENCES-BETWEEN-Rush-AND-GNU-Parallel">DIFFERENCES BETWEEN Rush AND GNU Parallel</h2>
<p>Rush (https://github.com/shenwei356/rush) is written in Go and based on gargs.</p>
<h2 id="DIFFERENCES-BETWEEN-ClusterSSH-AND-GNU-Parallel">DIFFERENCES BETWEEN ClusterSSH AND GNU Parallel</h2>
<p>ClusterSSH solves a different problem than GNU <b>parallel</b>.</p>
<p>ClusterSSH opens a terminal window for each computer and using a master window you can run the same command on all the computers. This is typically used for administrating several computers that are almost identical.</p>
<p>GNU <b>parallel</b> runs the same (or different) commands with different arguments in parallel possibly using remote computers to help computing. If more than one computer is listed in <b>-S</b> GNU <b>parallel</b> may only use one of these (e.g. if there are 8 jobs to be run and one computer has 8 cores).</p>
<p>GNU <b>parallel</b> can be used as a poor-man's version of ClusterSSH:</p>
<p><b>parallel --nonall -S server-a,server-b do_stuff foo bar</b></p>
<h1 id="AUTHOR">AUTHOR</h1>
<p>When using GNU <b>parallel</b> for a publication please cite:</p>
<p>O. Tange (2011): GNU Parallel - The Command-Line Power Tool, ;login: The USENIX Magazine, February 2011:42-47.</p>
<p>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.</p>
<p>Copyright (C) 2007-10-18 Ole Tange, http://ole.tange.dk</p>
<p>Copyright (C) 2008,2009,2010 Ole Tange, http://ole.tange.dk</p>
<p>Copyright (C) 2010,2011,2012,2013,2014,2015,2016,2017 Ole Tange, http://ole.tange.dk and Free Software Foundation, Inc.</p>
<p>Parts of the manual concerning <b>xargs</b> compatibility is inspired by the manual of <b>xargs</b> from GNU findutils 4.4.2.</p>
<h1 id="LICENSE">LICENSE</h1>
<p>Copyright (C) 2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017 Free Software Foundation, Inc.</p>
<p>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.</p>
<p>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.</p>
<p>You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>.</p>
<h2 id="Documentation-license-I">Documentation license I</h2>
<p>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 fdl.txt.</p>
<h2 id="Documentation-license-II">Documentation license II</h2>
<p>You are free:</p>
<dl>
<dt id="to-Share"><b>to Share</b></dt>
<dd>
<p>to copy, distribute and transmit the work</p>
</dd>
<dt id="to-Remix"><b>to Remix</b></dt>
<dd>
<p>to adapt the work</p>
</dd>
</dl>
<p>Under the following conditions:</p>
<dl>
<dt id="Attribution"><b>Attribution</b></dt>
<dd>
<p>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).</p>
</dd>
<dt id="Share-Alike"><b>Share Alike</b></dt>
<dd>
<p>If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license.</p>
</dd>
</dl>
<p>With the understanding that:</p>
<dl>
<dt id="Waiver"><b>Waiver</b></dt>
<dd>
<p>Any of the above conditions can be waived if you get permission from the copyright holder.</p>
</dd>
<dt id="Public-Domain"><b>Public Domain</b></dt>
<dd>
<p>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.</p>
</dd>
<dt id="Other-Rights"><b>Other Rights</b></dt>
<dd>
<p>In no way are any of the following rights affected by the license:</p>
<ul>
<li><p>Your fair dealing or fair use rights, or other applicable copyright exceptions and limitations;</p>
</li>
<li><p>The author's moral rights;</p>
</li>
<li><p>Rights other persons may have either in the work itself or in how the work is used, such as publicity or privacy rights.</p>
</li>
</ul>
</dd>
</dl>
<dl>
<dt id="Notice"><b>Notice</b></dt>
<dd>
<p>For any reuse or distribution, you must make clear to others the license terms of this work.</p>
</dd>
</dl>
<p>A copy of the full license is included in the file as cc-by-sa.txt.</p>
<h1 id="DEPENDENCIES">DEPENDENCIES</h1>
<p>GNU <b>parallel</b> uses Perl, and the Perl modules Getopt::Long, IPC::Open3, Symbol, IO::File, POSIX, and File::Temp. For remote usage it also uses rsync with ssh.</p>
<h1 id="SEE-ALSO">SEE ALSO</h1>
<p><b>find</b>(1), <b>xargs</b>(1), <b>make</b>(1), <b>pexec</b>(1), <b>ppss</b>(1), <b>xjobs</b>(1), <b>prll</b>(1), <b>dxargs</b>(1), <b>mdm</b>(1)</p>
</body>
</html>
distrib
>
Mageia
>
6
>
x86_64
>
media
>
core-release
>
by-pkgid
>
46d27e693eac6791157d41b702d7faa0
>
files
>
29
