Fix cmake build

Fix Visual Studios project

Fix pool.c threading.h import

Fix zstdmt_compress.h include

Merge pull request #519 from inikep/dev11

Dev11

Merge pull request #518 from facebook/zstdmt

zstd with multi-threading

fixed : ZSTD_setCCtxParameter() properly exposed in DLL

fixed clang documentation warning

CLI : automatically set overlap size to max (windowSize) for max compression level

added test of new parameter ZSTD_p_forceWindow

fixed zstdmt corruption issue when enabling overlapped sections

see Asana board for detailed explanation on why and how to fix it

fixed zstdmt cli freeze issue with large nb of threads

fileio.c was continually pushing more content without giving a chance to flush compressed one.
It would block the job queue when input data was accumulated too fast (requiring to define many threads).
Fixed : fileio flushes whatever it can after each input attempt.

improved #232 fix

Fixed https://github.com/facebook/zstd/issues/232

Merge remote-tracking branch 'refs/remotes/origin/master' into dev11

.travis.yml: different tests for "master" branch

.travis.yml: optimized order of short tests

overlapped section, for improved compression

Sections 2+ read a bit of data from previous section
in order to improve compression ratio.
This also costs some CPU, to reference read data.

Read data is currently fixed to window>>3 size

refactor job creation

code shared accross ZSTDMT_{compress,flush,end}Stream(),
for easier maintenance

zstdmt cli and API allow selection of section sizes

By default, section sizes are 4x window size.
This new setting allow manual selection of section sizes.
The larger they are, the (slightly) better the compression ratio,
but also the higher the memory allocation cost,
and eventually the lesser the nb of possible threads,
since each section is compressed by a single thread.

It also introduces a prototype to set generic parameters,
ZSTDMT_setMTCtxParameter()

The idea is that it's possible to add enums
to extend the list of parameters that can be set this way.
This is more long-term oriented than a fixed-size struct.
Consider it as a test.

ZSTDMT now supports frame checksum

.travis.yml: test jobs 12-15

JOB_NUMBER -eq 9

improved ZSTD_compressBlock_opt_extDict_generic

refactor ZSTDMT streaming flush code

now shared by both ZSTDMT_compressStream() and ZSTDMT_flushStream()

ZSTDMT streaming : fall back to (regular) single thread mode

when nbThreads==1

ZSTDMT_compressCCtx : fallback to single-thread mode when nbChunks==1

ZSTDMT_compressStream() becomes blocking when required to ensure forward progresses

In some (rare) cases, job list could be blocked by a first job still being processed,
while all following ones are completed, waiting to be flushed.
In such case, the current job-table implementation is unable to accept new job.
As a consequence, a call to ZSTDMT_compressStream() can be useless (nothing read, nothing flushed),
with the risk to trigger a busy-wait on the caller side
(needlessly loop over ZSTDMT_compressStream() ).

In such a case, ZSTDMT_compressStream() will block until the first job is completed and ready to flush.
It ensures some forward progress by guaranteeing it will flush at least a part of the completed job.
Energy-wasting busy-wait is avoided.

ZSTDMT_initCStream_usingDict() can outlive dict

Like ZSTD_initCStream_usingDict(),
ZSTDMT_initCStream_usingDict() now keep a copy of dict internally.
This way, dict can be released :
it does not longer have to outlive all future compression sessions.

playtest.sh : changed sdiff into $DIFF

protected (mutex) read to jobCompleted, as suggested by @terrelln

optimized pool allocation by 1 slot

minor : tab to spaces

convert tabs to space

joys of using multiple editors from multiple environments ...

fixed : compilation of zstreamtest in dll mode

Resolved merge conflict dev+zstdmt

skip zstdmt at root directory

fixed VS2008 project

fixed VS2010 project

fixed minor warnings (Visual, conversion, doxygen)

updated util's time for Windows compatibility

Correctly measures time on Posix systems when running with
Multi-threading

Todo : check Windows measurement under multi-threading

minor refactoring : cleaner MT integration within bench

renamed savedRep into repToConfirm

zstd cli can now compress using multi-threading

added : command -T#
added : ZSTD_resetCStream() (zstdmt_compress)
added : FIO_setNbThreads()  (fileio)

Added ZSTDMT_initCStream_advanced() variant

Correctly compress with custom params and dictionary
Added relevant fuzzer test in zstreamtest

Also :
new macro ZSTDMT_SECTION_LOGSIZE_MIN, which sets a minimum size for a full job
(note : a flush() command can still generate a partial job anytime)

changed MT enabling macro to ZSTD_MULTITHREAD

fixed minor warning (unused variable) in fuzzer

added streaming fuzzer tests for MT API

Also : fixed corner case, where nb of jobs completed becomes > jobQueueSize
which is possible when many flushes are issued
while there is not enough dst buffer to flush completed ones.

fixed Multi-threaded compression

MT compression generates a single frame.
Multi-threading operates by breaking the frames into independent sections.
But from a decoder perspective, there is no difference :
it's just a suite of blocks.

Problem is, decoder preserves repCodes from previous block to start decoding next block.
This is also valid between sections, since they are no different than changing block.

Previous version would incorrectly initialize repcodes to their default value at the beginning of each section.
When using them, there was a mismatch between encoder (default values) and decoder (values from previous block).

This change ensures that repcodes won't be used at the beginning of a new section.
It works by setting them to 0.
This only works with regular (single segment) variants : extDict variants will fail !
Fortunately, sections beyond the 1st one belong to this category.

To be checked : btopt strategy.
This change was only validated from fast to btlazy2 strategies.

Simplified compressChunk job

minor refactoring : compression done in a single call on first chunk
Avoid a mutable hSize variable and eventual recombination to cSize at the end

Merge pull request #516 from inikep/dev11

fix for zlibWrapper

Merge pull request #515 from iburinoc/emptydict

Don't create dict in streaming apis if dictSize == 0

Merge remote-tracking branch 'refs/remotes/facebook/dev' into dev11

zlibWrapper: added the totalInBytes flag - we need it as strm->total_in can be reset by user

ZSTDMT_endStream : nullify input buffer after flush

There will be no more input after ZSTDMT_endStream invocation :
only flush/end is allowed (to fully collect compressed result).

Merge pull request #514 from inikep/dev11

fixed gz functions based on zlib 1.2.11

ZSTDMT_initCStream() supports restart from invalid state

ZSTDMT_initCStream() will correcly scrub for resources
when it detects that previous compression was not properly finished.

trap compression errors, collect back resources from workers

Prefix notes with /**<

CCtxPool starts empty, as suggested by @terrelln

Also : make zstdmt now a target from root

fixed cmaketest

(buffer_t){NULL,0} is not considered a constant.
{NULL,0} is.

updated link to copyright notice

fixed clang warnings in gzread.c and gzwrite.c

gzcompatibility.h updated to zlib 1.2.11

gzwrite.c updated to zlib 1.2.11

gzread.c updated to zlib 1.2.11

gzlib.c updated to zlib 1.2.11

gzguts.h updated to zlib 1.2.11

get_crc_table only with ZLIB_VERNUM >= 0x1270

ZSTDMT_free() scrubs potentially unfinished jobs to release their resources

In some complex scenarios (free() without finishing compression),
it is possible that some resources are still into jobs
and not collected back into pools.
In which case, previous version of free() would miss them.
This would be equivalent to a leak.

New version ensures that it even foes after such resource.
It requires job consumers to properly mark resources as released,
by replacing entries by NULL after releasing back to the pool.

Obviously, it's not recommended to free() zstdmt context mid-term,
still that's now a supported scenario.

The same methodology is also used to ensure proper resource collection
after an error is detected.

Still to do :
- detect compression errors (not just allocation ones)
- properly manage resource when init() is called without finishing previous compression.

ZSTDMT_{flush,end}Stream() now block on next job completion when nothing to flush

The main issue was to avoid a caller to continually loop on {flush,end}Stream()
when there was nothing ready to be flushed but still some compression work ongoing in a worker thread.
The continuous loop would have resulted in wasted energy.
The new version makes call to {flush,end}Stream blocking when there is nothing ready to be flushed.
Of course, if all worker threads have exhausted job, it will return zero (all flush completed).

Note : There are still some remaining issues to report error codes
and properly collect back resources into pools when an error is triggered.

completed ZSTDMT streaming compression

Provides the baseline compression API :
size_t ZSTDMT_initCStream(ZSTDMT_CCtx* zcs, int compressionLevel);
size_t ZSTDMT_compressStream(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
size_t ZSTDMT_flushStream(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output);
size_t ZSTDMT_endStream(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output);

Not tested yet

Don't create dict in streaming apis if dictSize == 0

updated NEWS

Merge remote-tracking branch 'refs/remotes/facebook/dev' into dev11

zlibWrapper: added get_crc_table

added "Makefile is validated"

Merge pull request #511 from indygreg/cdict-dictid

Set dictionary ID in ZSTD_initCStream_usingCDict()

added test checking dictID when using ZSTD_initCStream_usingCDict()

It shows that dictID is not properly added into frame header

Set dictionary ID in ZSTD_initCStream_usingCDict()

When porting python-zstandard to use ZSTD_initCStream_usingCDict()
so compression dictionaries could be reused, an automated test
failed due to compressed content changing.

I tracked this down to ZSTD_initCStream_usingCDict() not
setting the dictID field of the ZSTD_CCtx attached to the
ZSTD_CStream instance.

I'm not 100% convinced this is the correct or full solution,
as I'm still seeing one automated test failing with this change.

Merge pull request #510 from iburinoc/baddict

Fixed decompress_usingDict not propagating corrupted dictionary error

Fix missing 'OK' logging on fuzzer testcase

fix gcc-arm warning "suggest braces around empty body"

zstdmt : fix : resources properly collected even when early fail

In previous version, main function would return early when detecting a job error.
Late threads resources were therefore not collected back into pools.
New version just register the error, but continue the collecting process.
All buffers and context should be released back to pool before leaving main function.

Fixed decompress_usingDict not propagating corrupted dictionary error

zstdmt : correctly check for cctx and buffer allocation

Result from getBuffer and getCCtx could be NULL when allocation fails.
Now correctly checks : job creation stop and last job reports an allocation error.
releaseBuffer and releaseCCtx are now also compatible with NULL input.

Identified a new potential issue :
when early job fails, later jobs are not collected for resource retrieval.

zstdmt : changed internal naming from frame to chunk

Since the result of mt compression is a single frame,
changed naming, which implied the concatenation of multiple frames.

minor : ensures that content size is written in header

ZSTDMT_compress() creates a single frame

The new strategy involves cutting frame at block level.
The result is a single frame, preserving ZSTD_getDecompressedSize()

As a consequence, bench can now make a full round-trip,
since the result is compatible with ZSTD_decompress().

This strategy will not make it possible to decode the frame with multiple threads
since the exact cut between independent blocks is not known.
MT decoding needs further discussions.

minor refactor (release CCtx 1st) and comment clarification

fixed ZSTDMT_createCCtx() : checked inner objects are properly created

improved ZSTD_createCCtxPool() cancellation

use ZSTD_freeCCtxPool() to release the partially created pool.
avoids to duplicate logic.

Also : identified a new difficult corner case :
when freeing the Pool, all CCtx should be previously released back to the pool.
Otherwise, it means some CCtx are still in use.
There is currently no clear policy on what to do in such a case.
Note : it's supposed to never happen.
Since pool creation/usage is static, it has no external user,
which limits risks.

fixed ZSTDMT_createCCtxPool() when inner CCtx creation fails

Merge pull request #509 from terrelln/dict-builder-32

Handle cover dictionary builder maximum input size for 32-bit mode

Document memory requirements for COVER algorithm

Handle large input size in 32-bit mode correctly

Use COVER_MEMMULT when training with COVER.

minor man page update

Merge pull request #507 from terrelln/dict-builder-optimize

Add new dictionary builder

Add COVER dictionary builder to fuzzer unit tests

Simplify COVER parameters