-
Notifications
You must be signed in to change notification settings - Fork 19
/
help.txt
278 lines (262 loc) · 17.8 KB
/
help.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
ParPar
High performance PAR2 creation tool
-----------------------------------
Usage: parpar -s <slice_size/count> -o <output> [options] [--] <input1> [<input2>...]
Unless otherwise specified, all options take one parameter.
PAR2 Options:
-s, --input-slices Slice/block size or number of input slices/blocks.
To specify exact slice size, append a size suffix
to the number. Examples:
`-s1000`: selects a slice size so that there
are 1000 input slices. Note that
ParPar will error if it cannot
select a slice size which satisfies
this condition exactly
`-s1M`: sets the slice size to 1 megabyte
`-s1024B`: set the slice size to 1 kilobyte
This option must be specified.
--min-input-slices Enables the number of slices to be automatically
scaled if it falls below this value. This can be
either a slice size, or number of slices, and
follows the same format as `--input-slices`
Default is `--input-slices` (disable auto-scaling)
--max-input-slices As with `--min-input-slices` but specifies an
upper limit.
--slice-size-multiple When selecting a slice size, ensure that it is a
multiple of this value.
Default is `--input-slices` if size specified and
`--min-input-slices` equals that size, otherwise
is 4B
-S, --auto-slice-size Automatically scale up input slice size if the
number of input slices would exceed the maximum
allowed. This option takes no parameters.
Alias for `--max-input-slices=32768`
-r, --recovery-slices Number of recovery slices to generate. You can
append a suffix to auto-calculate this, as in the
following examples:
`-r100`: generates 100 recovery slices
`-r15.7%`: generates 15.7% recovery
`-r2.5M`: generates 2.5MB of recovery
`-r2l`: recovery slices equals number of input
slices from 2 largest files
`-r1.5s`: recovery slices equals number of
input slices from smallest file,
plus half the number of input slices
for the second smallest file
`-r0.5w`: recovery slices equals the square
root of the total number of input
slices (or input_slices**0.5 where
** denotes power)
`-r1.5o`: recovery slices equals the logarithm
base 1.5 of the total number of input
slices
`-r1n`: computes r = s/max(1,log2(s)), where
'r' denotes number of recovery slices,
'log2' denotes logarithm base 2, and
's' denotes the number preceeding the
'n' suffix (1 in this case) multiplied
by the total number of input slices
This curve encourages a higher ratio
of recovery slices to be chosen for
smaller inputs
The 'l', 's', 'w', 'o' and 'n' suffixes can be
followed by a scale factor, e.g. `-r1l*1.5` takes
the number of slices in the largest file and
multiplies it by 1.5.
You can also specify multiple values by joining
them with `+` or `-`, e.g. `-r10%+2` will generate
10% recovery plus 2 extra slices.
Default is 0, which generates no recovery.
--min-recovery-slices Enables number of recovery slices to be
automatically scaled if it falls below this value.
This is specified in the same format as
`--recovery-slices`.
Default is `--recovery-slices` (no auto-scaling)
--max-recovery-slices Upper limit counterpart to `--min-recovery-slices`
Default is 65536. This default value has the
effect of making specified percentages or sizes
given to `--recovery-slices` a minimum amount. In
other words, `-r5%` effectively means 'at least
5%' with this default value, whilst `-r5%
--max-recovery-slices=5%` would effectively mean
'exactly 5%' and `-r5% --max-recovery-slices=5%
--min-recovery-slices=0` would mean 'at most 5%'.
This default also causes an error to be thrown if
the number exceeds the maximum of 65535.
-e, --recovery-offset Recovery slice start offset. Default 0.
-c, --comment Add PAR2 comment. Can be specified multiple times.
--packet-redundancy How critical packets are repeated, can be either:
none: only store a single copy of packets
pow2: repeat packets in a power-of-2 fashion
amongst recovery packets
Default is `pow2`.
-f, --filepath-format How to format input file paths, can be either:
basename: discard paths
keep: retain full paths as specified
common: discard common parts of paths; falls
back to basename if there is no common
path
outrel: path computed relative to output
path: path computed relative to that specified
in `--filepath-base`
Default is `common`, or `path` if `--filepath-base`
is specified.
-B, --filepath-base The base path to use when computing paths when
`--filepath-format=path` is used.
Default is `.` (i.e. current working directory)
--unicode Whether to force PAR2 unicode packets to be
generated. If set, unicode packets will always be
generated. If explicitly unset (`--no-unicode`),
will force unicode packets to never by generated.
Default is to auto detect (use if non 7-bit ASCII
characters present).
--ascii-charset Character set to use for "ASCII" packets. Default
is `utf-8`.
Output Options:
-o, --out Base PAR2 file name. A .par2 extension will be
appeneded if not supplied.
-O, --overwrite Overwrite existing files if they exist. This
option doesn't take any parameters.
Note that this will not delete existing PAR2
recovery files that match the base PAR2 name, but
wouldn't be written to.
-n, --std-naming Use standard naming scheme for recovery files,
instead of that popularized by par2cmdline. Output
names will look like xxx.vol12-22.par2 instead of
xxx.vol12+10.par2
This option doesn't take any parameters.
-d, --slice-dist Specify how recovery slices are distributed
amongst output files. Can be:
equal: each file contains `--slices-per-file`
slices
uniform: like `equal` but try to distribute
slices evenly distributed amongst
files
pow2: power-of-2 sizing scheme (default)
-p, --slices-per-file Specify the maximum number of slices each file
may contain. This option follows the same format
as `--recovery-slices` and supports the same
suffixes. By default, fractional slices are
rounded to the nearest whole slice, but rounding
can be controlled by prefixing this option with
'<' (round down) or '>' (round up) [also take care
that the shell may interpret these characters, so
escape them if appropriate]
Default 65535
--slices-first-file Number of slices in the first recovery file. If
`--slice-dist` is `pow2`, the subsequent file will
contain double this number of slices. Format of
this option is identical to `--slices-per-file`.
Default is 1 if `--slice-dist` is `pow2`, ignored
if `--slice-dist` is `uniform`, otherwise equals
`--slices-per-file`
-F, --recovery-files Number of recovery volume files to generate. If
specified, will override another option to ensure
the requested file count is met. The option
overridden depends on what `--slice-dist` is used:
equal: overrides `--slices-per-file`
uniform: overrides `--slices-per-file`
pow2: overrides `--slices-first-file`
If the requested file count cannot be met, an
error will be generated.
--noindex Don't output an index file (file with no recovery
blocks). This option takes no value.
Performance Options:
-m, --memory Maximum amount of memory to use for recovery
slices. If all recovery slices cannot be held in
memory, ParPar will run multiple passes on input
data to generate recovery, so increasing this
value can improve performance. Default is auto-
detected based on total/free RAM, typically 75% of
free RAM up to 8192MB.
Note that additional memory is used during
processing, particularly if large slice sizes are
being used.
-t, --threads Limit number of threads to use. Default equals
number of CPU cores.
--min-chunk-size Minimum chunking size. Set to 0 to disable
chunking. This is a tradeoff between sequential
and random I/O. It is preferrable to use larger
values (or 0) on hard disks, where random I/O is
slow, but smaller values on flash based storage,
where random I/O is faster, relative to bandwidth.
Default `128K`.
--seq-read-size Target read buffer size for sequential reading.
Actually buffer size will vary, and may be
significantly larger depending on memory limit
supplied. Default `4M`
--proc-batch-size Number of slices to submit as a job for GF
calculation.
--proc-buffer-size Number of additional slices to buffer. Set to 0
to disable bufferring. Default equals
`--proc-batch-size`
--method Algorithm for performing GF multiplies. Process
can crash if CPU does not support selected method.
Choices are (all platforms):
lookup: split 2x 8-bit scalar table lookup
3p_lookup: split biword 3x 11/10-bit scalar table lookup
x86/x64 only choices:
lookup-sse: SSE2 variant of lookup
xor-sse: vector XOR bit dependencies (SSE2)
xorjit-sse: JIT variant of above
xorjit-avx2: AVX2 x64 variant of above
xorjit-avx512: AVX512BW x64 variant of above
shuffle-sse: split 4x 4-bit vector table lookup (SSSE3)
shuffle-avx: AVX variant of above
shuffle-avx2: AVX2 variant of above
shuffle-avx512: AVX512BW variant of above
shuffle-vbmi: split 3x 6-bit vector table lookup (AVX512VBMI)
shuffle2x-avx2: half width variant of shuffle-avx2
shuffle2x-avx512: half width variant of shuffle-avx512
affine-sse: split 2x 8-bit vector XOR dependencies (GFNI)
affine-avx2: AVX2 + GFNI variant of above
affine-avx512: AVX512BW + GFNI variant of above
affine2x-sse: half width variant of affine-sse
affine2x-avx2: half width variant of affine-avx2
affine2x-avx512: half width variant of affine-avx512
ARMv7/AArch64 only choices:
shuffle-neon: NEON variant of shuffle-sse
shuffle128-sve: SVE variant of shuffle-neon
shuffle128-sve2: SVE2 variant of shuffle-neon
shuffle2x128-sve2: half width variant of shuffle-neon (requires SVE width >= 256 bits)
shuffle512-sve2: SVE2 variant of shuffle-vbmi (requires SVE width >= 512 bits)
clmul-neon: split 8-bit polynomial multiplication (NEON)
clmul-sve2: SVE2 variant of clmul-neon
Default is auto-detected.
UI Options:
All of the following options, except `--progress`, take no parameters.
--progress Progress indicator display, which can be either:
none: disable progress output
stderr: output a progress indicator to stderr
stdout: output a progress indicator to stdout
Default is `stderr`, or `none` if `--quiet` is
specified.
-q, --quiet Suppress information output, as well as progress
indicator (unless `--progress` specifies
otherwise). Errors will still be displayed
-?, --help Displays this list of options
--version Print application version number and exit
Input Files:
Additional arguments to ParPar are taken as files to be processed.
The following parameters affect file selection.
-R, --recurse If specified, recurse into subdirectories. If
`--no-recurse` is specified, do not traverse
subdirectories. The default is to traverse
directories given on the command line without
recursion.
This option takes no values.
-i, --input-file Supply a text file which lists files, separated by
newlines, to be included as input. Can be `-` to
read from stdin, or a command prefixed with
proc:// to read from the stdout of specified
process (example: `proc://cat somefile.txt`). Can
also be an fd prefixed with fd:// (requires NodeJS
>= 0.12), i.e. `fd://0` is an alias for stdin.
Can be specified multiple times.
-0, --input-file0 Same as the `--input-file` option, except files
are separated by null characters instead of
newlines.
------------------
Examples
parpar -s 1M -r 64 -o my_recovery.par2 file1 file2
Generate 64MB of PAR2 recovery files from file1 and file2, named "my_recovery"