1zstd(1) -- zstd, zstdmt, unzstd, zstdcat - Compress or decompress .zst files 2============================================================================ 3 4SYNOPSIS 5-------- 6 7`zstd` [*OPTIONS*] [-|_INPUT-FILE_] [-o _OUTPUT-FILE_] 8 9`zstdmt` is equivalent to `zstd -T0` 10 11`unzstd` is equivalent to `zstd -d` 12 13`zstdcat` is equivalent to `zstd -dcf` 14 15 16DESCRIPTION 17----------- 18`zstd` is a fast lossless compression algorithm and data compression tool, 19with command line syntax similar to `gzip (1)` and `xz (1)`. 20It is based on the **LZ77** family, with further FSE & huff0 entropy stages. 21`zstd` offers highly configurable compression speed, 22with fast modes at > 200 MB/s per core, 23and strong modes nearing lzma compression ratios. 24It also features a very fast decoder, with speeds > 500 MB/s per core. 25 26`zstd` command line syntax is generally similar to gzip, 27but features the following differences : 28 29 - Source files are preserved by default. 30 It's possible to remove them automatically by using the `--rm` command. 31 - When compressing a single file, `zstd` displays progress notifications 32 and result summary by default. 33 Use `-q` to turn them off. 34 - `zstd` does not accept input from console, 35 but it properly accepts `stdin` when it's not the console. 36 - `zstd` displays a short help page when command line is an error. 37 Use `-q` to turn it off. 38 39`zstd` compresses or decompresses each _file_ according to the selected 40operation mode. 41If no _files_ are given or _file_ is `-`, `zstd` reads from standard input 42and writes the processed data to standard output. 43`zstd` will refuse to write compressed data to standard output 44if it is a terminal : it will display an error message and skip the _file_. 45Similarly, `zstd` will refuse to read compressed data from standard input 46if it is a terminal. 47 48Unless `--stdout` or `-o` is specified, _files_ are written to a new file 49whose name is derived from the source _file_ name: 50 51* When compressing, the suffix `.zst` is appended to the source filename to 52 get the target filename. 53* When decompressing, the `.zst` suffix is removed from the source filename to 54 get the target filename 55 56### Concatenation with .zst files 57It is possible to concatenate `.zst` files as is. 58`zstd` will decompress such files as if they were a single `.zst` file. 59 60OPTIONS 61------- 62 63### Integer suffixes and special values 64In most places where an integer argument is expected, 65an optional suffix is supported to easily indicate large integers. 66There must be no space between the integer and the suffix. 67 68* `KiB`: 69 Multiply the integer by 1,024 (2\^10). 70 `Ki`, `K`, and `KB` are accepted as synonyms for `KiB`. 71* `MiB`: 72 Multiply the integer by 1,048,576 (2\^20). 73 `Mi`, `M`, and `MB` are accepted as synonyms for `MiB`. 74 75### Operation mode 76If multiple operation mode options are given, 77the last one takes effect. 78 79* `-z`, `--compress`: 80 Compress. 81 This is the default operation mode when no operation mode option is specified 82 and no other operation mode is implied from the command name 83 (for example, `unzstd` implies `--decompress`). 84* `-d`, `--decompress`, `--uncompress`: 85 Decompress. 86* `-t`, `--test`: 87 Test the integrity of compressed _files_. 88 This option is equivalent to `--decompress --stdout` except that the 89 decompressed data is discarded instead of being written to standard output. 90 No files are created or removed. 91* `-b#`: 92 Benchmark file(s) using compression level # 93* `--train FILEs`: 94 Use FILEs as a training set to create a dictionary. 95 The training set should contain a lot of small files (> 100). 96* `-l`, `--list`: 97 Display information related to a zstd compressed file, such as size, ratio, and checksum. 98 Some of these fields may not be available. 99 This command can be augmented with the `-v` modifier. 100 101### Operation modifiers 102 103* `-#`: 104 `#` compression level \[1-19] (default: 3) 105* `--ultra`: 106 unlocks high compression levels 20+ (maximum 22), using a lot more memory. 107 Note that decompression will also require more memory when using these levels. 108* `--fast[=#]`: 109 switch to ultra-fast compression levels. 110 If `=#` is not present, it defaults to `1`. 111 The higher the value, the faster the compression speed, 112 at the cost of some compression ratio. 113 This setting overwrites compression level if one was set previously. 114 Similarly, if a compression level is set after `--fast`, it overrides it. 115* `-T#`, `--threads=#`: 116 Compress using `#` working threads (default: 1). 117 If `#` is 0, attempt to detect and use the number of physical CPU cores. 118 In all cases, the nb of threads is capped to `ZSTDMT_NBWORKERS_MAX`, 119 which is either 64 in 32-bit mode, or 256 for 64-bit environments. 120 This modifier does nothing if `zstd` is compiled without multithread support. 121* `--single-thread`: 122 Does not spawn a thread for compression, use a single thread for both I/O and compression. 123 In this mode, compression is serialized with I/O, which is slightly slower. 124 (This is different from `-T1`, which spawns 1 compression thread in parallel of I/O). 125 This mode is the only one available when multithread support is disabled. 126 Single-thread mode features lower memory usage. 127 Final compressed result is slightly different from `-T1`. 128* `--adapt[=min=#,max=#]` : 129 `zstd` will dynamically adapt compression level to perceived I/O conditions. 130 Compression level adaptation can be observed live by using command `-v`. 131 Adaptation can be constrained between supplied `min` and `max` levels. 132 The feature works when combined with multi-threading and `--long` mode. 133 It does not work with `--single-thread`. 134 It sets window size to 8 MB by default (can be changed manually, see `wlog`). 135 Due to the chaotic nature of dynamic adaptation, compressed result is not reproducible. 136 _note_ : at the time of this writing, `--adapt` can remain stuck at low speed 137 when combined with multiple worker threads (>=2). 138* `--long[=#]`: 139 enables long distance matching with `#` `windowLog`, if not `#` is not 140 present it defaults to `27`. 141 This increases the window size (`windowLog`) and memory usage for both the 142 compressor and decompressor. 143 This setting is designed to improve the compression ratio for files with 144 long matches at a large distance. 145 146 Note: If `windowLog` is set to larger than 27, `--long=windowLog` or 147 `--memory=windowSize` needs to be passed to the decompressor. 148* `-D DICT`: 149 use `DICT` as Dictionary to compress or decompress FILE(s) 150* `--patch-from FILE`: 151 Specify the file to be used as a reference point for zstd's diff engine. 152 This is effectively dictionary compression with some convenient parameter 153 selection, namely that windowSize > srcSize. 154 155 Note: cannot use both this and -D together 156 Note: `--long` mode will be automatically activated if chainLog < fileLog 157 (fileLog being the windowLog required to cover the whole file). You 158 can also manually force it. 159 Node: for all levels, you can use --patch-from in --single-thread mode 160 to improve compression ratio at the cost of speed 161 Note: for level 19, you can get increased compression ratio at the cost 162 of speed by specifying `--zstd=targetLength=` to be something large 163 (i.e 4096), and by setting a large `--zstd=chainLog=` 164* `--rsyncable` : 165 `zstd` will periodically synchronize the compression state to make the 166 compressed file more rsync-friendly. There is a negligible impact to 167 compression ratio, and the faster compression levels will see a small 168 compression speed hit. 169 This feature does not work with `--single-thread`. You probably don't want 170 to use it with long range mode, since it will decrease the effectiveness of 171 the synchronization points, but your milage may vary. 172* `-C`, `--[no-]check`: 173 add integrity check computed from uncompressed data (default: enabled) 174* `--[no-]content-size`: 175 enable / disable whether or not the original size of the file is placed in 176 the header of the compressed file. The default option is 177 --content-size (meaning that the original size will be placed in the header). 178* `--no-dictID`: 179 do not store dictionary ID within frame header (dictionary compression). 180 The decoder will have to rely on implicit knowledge about which dictionary to use, 181 it won't be able to check if it's correct. 182* `-M#`, `--memory=#`: 183 Set a memory usage limit. By default, Zstandard uses 128 MB for decompression 184 as the maximum amount of memory the decompressor is allowed to use, but you can 185 override this manually if need be in either direction (ie. you can increase or 186 decrease it). 187 188 This is also used during compression when using with --patch-from=. In this case, 189 this parameter overrides that maximum size allowed for a dictionary. (128 MB). 190* `--stream-size=#` : 191 Sets the pledged source size of input coming from a stream. This value must be exact, as it 192 will be included in the produced frame header. Incorrect stream sizes will cause an error. 193 This information will be used to better optimize compression parameters, resulting in 194 better and potentially faster compression, especially for smaller source sizes. 195* `--size-hint=#`: 196 When handling input from a stream, `zstd` must guess how large the source size 197 will be when optimizing compression parameters. If the stream size is relatively 198 small, this guess may be a poor one, resulting in a higher compression ratio than 199 expected. This feature allows for controlling the guess when needed. 200 Exact guesses result in better compression ratios. Overestimates result in slightly 201 degraded compression ratios, while underestimates may result in significant degradation. 202* `-o FILE`: 203 save result into `FILE` 204* `-f`, `--force`: 205 disable input and output checks. Allows overwriting existing files, input 206 from console, output to stdout, operating on links, block devices, etc. 207* `-c`, `--stdout`: 208 force write to standard output, even if it is the console 209* `--[no-]sparse`: 210 enable / disable sparse FS support, 211 to make files with many zeroes smaller on disk. 212 Creating sparse files may save disk space and speed up decompression by 213 reducing the amount of disk I/O. 214 default: enabled when output is into a file, 215 and disabled when output is stdout. 216 This setting overrides default and can force sparse mode over stdout. 217* `--rm`: 218 remove source file(s) after successful compression or decompression. If used in combination with 219 -o, will trigger a confirmation prompt (which can be silenced with -f), as this is a destructive operation. 220* `-k`, `--keep`: 221 keep source file(s) after successful compression or decompression. 222 This is the default behavior. 223* `-r`: 224 operate recursively on directories 225* `--filelist FILE` 226 read a list of files to process as content from `FILE`. 227 Format is compatible with `ls` output, with one file per line. 228* `--output-dir-flat DIR`: 229 resulting files are stored into target `DIR` directory, 230 instead of same directory as origin file. 231 Be aware that this command can introduce name collision issues, 232 if multiple files, from different directories, end up having the same name. 233 Collision resolution ensures first file with a given name will be present in `DIR`, 234 while in combination with `-f`, the last file will be present instead. 235* `--output-dir-mirror DIR`: 236 similar to `--output-dir-flat`, 237 the output files are stored underneath target `DIR` directory, 238 but this option will replicate input directory hierarchy into output `DIR`. 239 240 If input directory contains "..", the files in this directory will be ignored. 241 If input directory is an absolute directory (i.e. "/var/tmp/abc"), 242 it will be stored into the "output-dir/var/tmp/abc". 243 If there are multiple input files or directories, 244 name collision resolution will follow the same rules as `--output-dir-flat`. 245* `--format=FORMAT`: 246 compress and decompress in other formats. If compiled with 247 support, zstd can compress to or decompress from other compression algorithm 248 formats. Possibly available options are `zstd`, `gzip`, `xz`, `lzma`, and `lz4`. 249 If no such format is provided, `zstd` is the default. 250* `-h`/`-H`, `--help`: 251 display help/long help and exit 252* `-V`, `--version`: 253 display version number and exit. 254 Advanced : `-vV` also displays supported formats. 255 `-vvV` also displays POSIX support. 256 `-q` will only display the version number, suitable for machine reading. 257* `-v`, `--verbose`: 258 verbose mode, display more information 259* `-q`, `--quiet`: 260 suppress warnings, interactivity, and notifications. 261 specify twice to suppress errors too. 262* `--no-progress`: 263 do not display the progress bar, but keep all other messages. 264* `--show-default-cparams`: 265 Shows the default compression parameters that will be used for a 266 particular src file. If the provided src file is not a regular file 267 (eg. named pipe), the cli will just output the default parameters. 268 That is, the parameters that are used when the src size is unknown. 269* `--`: 270 All arguments after `--` are treated as files 271 272### Restricted usage of Environment Variables 273 274Using environment variables to set parameters has security implications. 275Therefore, this avenue is intentionally restricted. 276Only `ZSTD_CLEVEL` and `ZSTD_NBTHREADS` are currently supported. 277They set the compression level and number of threads to use during compression, respectively. 278 279`ZSTD_CLEVEL` can be used to set the level between 1 and 19 (the "normal" range). 280If the value of `ZSTD_CLEVEL` is not a valid integer, it will be ignored with a warning message. 281`ZSTD_CLEVEL` just replaces the default compression level (`3`). 282 283`ZSTD_NBTHREADS` can be used to set the number of threads `zstd` will attempt to use during compression. 284If the value of `ZSTD_NBTHREADS` is not a valid unsigned integer, it will be ignored with a warning message. 285`ZSTD_NBTHREADS` has a default value of (`1`), and is capped at ZSTDMT_NBWORKERS_MAX==200. `zstd` must be 286compiled with multithread support for this to have any effect. 287 288They can both be overridden by corresponding command line arguments: 289`-#` for compression level and `-T#` for number of compression threads. 290 291 292DICTIONARY BUILDER 293------------------ 294`zstd` offers _dictionary_ compression, 295which greatly improves efficiency on small files and messages. 296It's possible to train `zstd` with a set of samples, 297the result of which is saved into a file called a `dictionary`. 298Then during compression and decompression, reference the same dictionary, 299using command `-D dictionaryFileName`. 300Compression of small files similar to the sample set will be greatly improved. 301 302* `--train FILEs`: 303 Use FILEs as training set to create a dictionary. 304 The training set should contain a lot of small files (> 100), 305 and weight typically 100x the target dictionary size 306 (for example, 10 MB for a 100 KB dictionary). 307 308 Supports multithreading if `zstd` is compiled with threading support. 309 Additional parameters can be specified with `--train-fastcover`. 310 The legacy dictionary builder can be accessed with `--train-legacy`. 311 The cover dictionary builder can be accessed with `--train-cover`. 312 Equivalent to `--train-fastcover=d=8,steps=4`. 313* `-o file`: 314 Dictionary saved into `file` (default name: dictionary). 315* `--maxdict=#`: 316 Limit dictionary to specified size (default: 112640). 317* `-#`: 318 Use `#` compression level during training (optional). 319 Will generate statistics more tuned for selected compression level, 320 resulting in a _small_ compression ratio improvement for this level. 321* `-B#`: 322 Split input files in blocks of size # (default: no split) 323* `--dictID=#`: 324 A dictionary ID is a locally unique ID that a decoder can use to verify it is 325 using the right dictionary. 326 By default, zstd will create a 4-bytes random number ID. 327 It's possible to give a precise number instead. 328 Short numbers have an advantage : an ID < 256 will only need 1 byte in the 329 compressed frame header, and an ID < 65536 will only need 2 bytes. 330 This compares favorably to 4 bytes default. 331 However, it's up to the dictionary manager to not assign twice the same ID to 332 2 different dictionaries. 333* `--train-cover[=k#,d=#,steps=#,split=#,shrink[=#]]`: 334 Select parameters for the default dictionary builder algorithm named cover. 335 If _d_ is not specified, then it tries _d_ = 6 and _d_ = 8. 336 If _k_ is not specified, then it tries _steps_ values in the range [50, 2000]. 337 If _steps_ is not specified, then the default value of 40 is used. 338 If _split_ is not specified or split <= 0, then the default value of 100 is used. 339 Requires that _d_ <= _k_. 340 If _shrink_ flag is not used, then the default value for _shrinkDict_ of 0 is used. 341 If _shrink_ is not specified, then the default value for _shrinkDictMaxRegression_ of 1 is used. 342 343 Selects segments of size _k_ with highest score to put in the dictionary. 344 The score of a segment is computed by the sum of the frequencies of all the 345 subsegments of size _d_. 346 Generally _d_ should be in the range [6, 8], occasionally up to 16, but the 347 algorithm will run faster with d <= _8_. 348 Good values for _k_ vary widely based on the input data, but a safe range is 349 [2 * _d_, 2000]. 350 If _split_ is 100, all input samples are used for both training and testing 351 to find optimal _d_ and _k_ to build dictionary. 352 Supports multithreading if `zstd` is compiled with threading support. 353 Having _shrink_ enabled takes a truncated dictionary of minimum size and doubles 354 in size until compression ratio of the truncated dictionary is at most 355 _shrinkDictMaxRegression%_ worse than the compression ratio of the largest dictionary. 356 357 Examples: 358 359 `zstd --train-cover FILEs` 360 361 `zstd --train-cover=k=50,d=8 FILEs` 362 363 `zstd --train-cover=d=8,steps=500 FILEs` 364 365 `zstd --train-cover=k=50 FILEs` 366 367 `zstd --train-cover=k=50,split=60 FILEs` 368 369 `zstd --train-cover=shrink FILEs` 370 371 `zstd --train-cover=shrink=2 FILEs` 372 373* `--train-fastcover[=k#,d=#,f=#,steps=#,split=#,accel=#]`: 374 Same as cover but with extra parameters _f_ and _accel_ and different default value of split 375 If _split_ is not specified, then it tries _split_ = 75. 376 If _f_ is not specified, then it tries _f_ = 20. 377 Requires that 0 < _f_ < 32. 378 If _accel_ is not specified, then it tries _accel_ = 1. 379 Requires that 0 < _accel_ <= 10. 380 Requires that _d_ = 6 or _d_ = 8. 381 382 _f_ is log of size of array that keeps track of frequency of subsegments of size _d_. 383 The subsegment is hashed to an index in the range [0,2^_f_ - 1]. 384 It is possible that 2 different subsegments are hashed to the same index, and they are considered as the same subsegment when computing frequency. 385 Using a higher _f_ reduces collision but takes longer. 386 387 Examples: 388 389 `zstd --train-fastcover FILEs` 390 391 `zstd --train-fastcover=d=8,f=15,accel=2 FILEs` 392 393* `--train-legacy[=selectivity=#]`: 394 Use legacy dictionary builder algorithm with the given dictionary 395 _selectivity_ (default: 9). 396 The smaller the _selectivity_ value, the denser the dictionary, 397 improving its efficiency but reducing its possible maximum size. 398 `--train-legacy=s=#` is also accepted. 399 400 Examples: 401 402 `zstd --train-legacy FILEs` 403 404 `zstd --train-legacy=selectivity=8 FILEs` 405 406 407BENCHMARK 408--------- 409 410* `-b#`: 411 benchmark file(s) using compression level # 412* `-e#`: 413 benchmark file(s) using multiple compression levels, from `-b#` to `-e#` (inclusive) 414* `-i#`: 415 minimum evaluation time, in seconds (default: 3s), benchmark mode only 416* `-B#`, `--block-size=#`: 417 cut file(s) into independent blocks of size # (default: no block) 418* `--priority=rt`: 419 set process priority to real-time 420 421**Output Format:** CompressionLevel#Filename : IntputSize -> OutputSize (CompressionRatio), CompressionSpeed, DecompressionSpeed 422 423**Methodology:** For both compression and decompression speed, the entire input is compressed/decompressed in-memory to measure speed. A run lasts at least 1 sec, so when files are small, they are compressed/decompressed several times per run, in order to improve measurement accuracy. 424 425ADVANCED COMPRESSION OPTIONS 426---------------------------- 427### -B#: 428Select the size of each compression job. 429This parameter is only available when multi-threading is enabled. 430Each compression job is run in parallel, so this value indirectly impacts the nb of active threads. 431Default job size varies depending on compression level (generally `4 * windowSize`). 432`-B#` makes it possible to manually select a custom size. 433Note that job size must respect a minimum value which is enforced transparently. 434This minimum is either 512 KB, or `overlapSize`, whichever is largest. 435Different job sizes will lead to (slightly) different compressed frames. 436 437### --zstd[=options]: 438`zstd` provides 22 predefined compression levels. 439The selected or default predefined compression level can be changed with 440advanced compression options. 441The _options_ are provided as a comma-separated list. 442You may specify only the options you want to change and the rest will be 443taken from the selected or default compression level. 444The list of available _options_: 445 446- `strategy`=_strat_, `strat`=_strat_: 447 Specify a strategy used by a match finder. 448 449 There are 9 strategies numbered from 1 to 9, from faster to stronger: 450 1=ZSTD\_fast, 2=ZSTD\_dfast, 3=ZSTD\_greedy, 451 4=ZSTD\_lazy, 5=ZSTD\_lazy2, 6=ZSTD\_btlazy2, 452 7=ZSTD\_btopt, 8=ZSTD\_btultra, 9=ZSTD\_btultra2. 453 454- `windowLog`=_wlog_, `wlog`=_wlog_: 455 Specify the maximum number of bits for a match distance. 456 457 The higher number of increases the chance to find a match which usually 458 improves compression ratio. 459 It also increases memory requirements for the compressor and decompressor. 460 The minimum _wlog_ is 10 (1 KiB) and the maximum is 30 (1 GiB) on 32-bit 461 platforms and 31 (2 GiB) on 64-bit platforms. 462 463 Note: If `windowLog` is set to larger than 27, `--long=windowLog` or 464 `--memory=windowSize` needs to be passed to the decompressor. 465 466- `hashLog`=_hlog_, `hlog`=_hlog_: 467 Specify the maximum number of bits for a hash table. 468 469 Bigger hash tables cause less collisions which usually makes compression 470 faster, but requires more memory during compression. 471 472 The minimum _hlog_ is 6 (64 B) and the maximum is 30 (1 GiB). 473 474- `chainLog`=_clog_, `clog`=_clog_: 475 Specify the maximum number of bits for a hash chain or a binary tree. 476 477 Higher numbers of bits increases the chance to find a match which usually 478 improves compression ratio. 479 It also slows down compression speed and increases memory requirements for 480 compression. 481 This option is ignored for the ZSTD_fast strategy. 482 483 The minimum _clog_ is 6 (64 B) and the maximum is 29 (524 Mib) on 32-bit platforms 484 and 30 (1 Gib) on 64-bit platforms. 485 486- `searchLog`=_slog_, `slog`=_slog_: 487 Specify the maximum number of searches in a hash chain or a binary tree 488 using logarithmic scale. 489 490 More searches increases the chance to find a match which usually increases 491 compression ratio but decreases compression speed. 492 493 The minimum _slog_ is 1 and the maximum is 'windowLog' - 1. 494 495- `minMatch`=_mml_, `mml`=_mml_: 496 Specify the minimum searched length of a match in a hash table. 497 498 Larger search lengths usually decrease compression ratio but improve 499 decompression speed. 500 501 The minimum _mml_ is 3 and the maximum is 7. 502 503- `targetLength`=_tlen_, `tlen`=_tlen_: 504 The impact of this field vary depending on selected strategy. 505 506 For ZSTD\_btopt, ZSTD\_btultra and ZSTD\_btultra2, it specifies 507 the minimum match length that causes match finder to stop searching. 508 A larger `targetLength` usually improves compression ratio 509 but decreases compression speed. 510t 511 For ZSTD\_fast, it triggers ultra-fast mode when > 0. 512 The value represents the amount of data skipped between match sampling. 513 Impact is reversed : a larger `targetLength` increases compression speed 514 but decreases compression ratio. 515 516 For all other strategies, this field has no impact. 517 518 The minimum _tlen_ is 0 and the maximum is 128 Kib. 519 520- `overlapLog`=_ovlog_, `ovlog`=_ovlog_: 521 Determine `overlapSize`, amount of data reloaded from previous job. 522 This parameter is only available when multithreading is enabled. 523 Reloading more data improves compression ratio, but decreases speed. 524 525 The minimum _ovlog_ is 0, and the maximum is 9. 526 1 means "no overlap", hence completely independent jobs. 527 9 means "full overlap", meaning up to `windowSize` is reloaded from previous job. 528 Reducing _ovlog_ by 1 reduces the reloaded amount by a factor 2. 529 For example, 8 means "windowSize/2", and 6 means "windowSize/8". 530 Value 0 is special and means "default" : _ovlog_ is automatically determined by `zstd`. 531 In which case, _ovlog_ will range from 6 to 9, depending on selected _strat_. 532 533- `ldmHashLog`=_lhlog_, `lhlog`=_lhlog_: 534 Specify the maximum size for a hash table used for long distance matching. 535 536 This option is ignored unless long distance matching is enabled. 537 538 Bigger hash tables usually improve compression ratio at the expense of more 539 memory during compression and a decrease in compression speed. 540 541 The minimum _lhlog_ is 6 and the maximum is 30 (default: 20). 542 543- `ldmMinMatch`=_lmml_, `lmml`=_lmml_: 544 Specify the minimum searched length of a match for long distance matching. 545 546 This option is ignored unless long distance matching is enabled. 547 548 Larger/very small values usually decrease compression ratio. 549 550 The minimum _lmml_ is 4 and the maximum is 4096 (default: 64). 551 552- `ldmBucketSizeLog`=_lblog_, `lblog`=_lblog_: 553 Specify the size of each bucket for the hash table used for long distance 554 matching. 555 556 This option is ignored unless long distance matching is enabled. 557 558 Larger bucket sizes improve collision resolution but decrease compression 559 speed. 560 561 The minimum _lblog_ is 1 and the maximum is 8 (default: 3). 562 563- `ldmHashRateLog`=_lhrlog_, `lhrlog`=_lhrlog_: 564 Specify the frequency of inserting entries into the long distance matching 565 hash table. 566 567 This option is ignored unless long distance matching is enabled. 568 569 Larger values will improve compression speed. Deviating far from the 570 default value will likely result in a decrease in compression ratio. 571 572 The default value is `wlog - lhlog`. 573 574### Example 575The following parameters sets advanced compression options to something 576similar to predefined level 19 for files bigger than 256 KB: 577 578`--zstd`=wlog=23,clog=23,hlog=22,slog=6,mml=3,tlen=48,strat=6 579 580 581BUGS 582---- 583Report bugs at: https://github.com/facebook/zstd/issues 584 585AUTHOR 586------ 587Yann Collet 588