1*a28cd43dSSascha Wildner /*
2*a28cd43dSSascha Wildner * Copyright (c) 2016-2020, Yann Collet, Facebook, Inc.
3*a28cd43dSSascha Wildner * All rights reserved.
4*a28cd43dSSascha Wildner *
5*a28cd43dSSascha Wildner * This source code is licensed under both the BSD-style license (found in the
6*a28cd43dSSascha Wildner * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7*a28cd43dSSascha Wildner * in the COPYING file in the root directory of this source tree).
8*a28cd43dSSascha Wildner * You may select, at your option, one of the above-listed licenses.
9*a28cd43dSSascha Wildner */
10*a28cd43dSSascha Wildner
11*a28cd43dSSascha Wildner
12*a28cd43dSSascha Wildner
13*a28cd43dSSascha Wildner /* **************************************
14*a28cd43dSSascha Wildner * Compiler Warnings
15*a28cd43dSSascha Wildner ****************************************/
16*a28cd43dSSascha Wildner #ifdef _MSC_VER
17*a28cd43dSSascha Wildner # pragma warning(disable : 4127) /* disable: C4127: conditional expression is constant */
18*a28cd43dSSascha Wildner #endif
19*a28cd43dSSascha Wildner
20*a28cd43dSSascha Wildner
21*a28cd43dSSascha Wildner /*-*************************************
22*a28cd43dSSascha Wildner * Includes
23*a28cd43dSSascha Wildner ***************************************/
24*a28cd43dSSascha Wildner #include "platform.h" /* Large Files support */
25*a28cd43dSSascha Wildner #include "util.h" /* UTIL_getFileSize, UTIL_getTotalFileSize */
26*a28cd43dSSascha Wildner #include <stdlib.h> /* malloc, free */
27*a28cd43dSSascha Wildner #include <string.h> /* memset */
28*a28cd43dSSascha Wildner #include <stdio.h> /* fprintf, fopen, ftello64 */
29*a28cd43dSSascha Wildner #include <errno.h> /* errno */
30*a28cd43dSSascha Wildner #include <assert.h>
31*a28cd43dSSascha Wildner
32*a28cd43dSSascha Wildner #include "timefn.h" /* UTIL_time_t, UTIL_clockSpanMicro, UTIL_getTime */
33*a28cd43dSSascha Wildner #include "../lib/common/mem.h" /* read */
34*a28cd43dSSascha Wildner #include "../lib/common/error_private.h"
35*a28cd43dSSascha Wildner #include "dibio.h"
36*a28cd43dSSascha Wildner
37*a28cd43dSSascha Wildner
38*a28cd43dSSascha Wildner /*-*************************************
39*a28cd43dSSascha Wildner * Constants
40*a28cd43dSSascha Wildner ***************************************/
41*a28cd43dSSascha Wildner #define KB *(1 <<10)
42*a28cd43dSSascha Wildner #define MB *(1 <<20)
43*a28cd43dSSascha Wildner #define GB *(1U<<30)
44*a28cd43dSSascha Wildner
45*a28cd43dSSascha Wildner #define SAMPLESIZE_MAX (128 KB)
46*a28cd43dSSascha Wildner #define MEMMULT 11 /* rough estimation : memory cost to analyze 1 byte of sample */
47*a28cd43dSSascha Wildner #define COVER_MEMMULT 9 /* rough estimation : memory cost to analyze 1 byte of sample */
48*a28cd43dSSascha Wildner #define FASTCOVER_MEMMULT 1 /* rough estimation : memory cost to analyze 1 byte of sample */
49*a28cd43dSSascha Wildner static const size_t g_maxMemory = (sizeof(size_t) == 4) ? (2 GB - 64 MB) : ((size_t)(512 MB) << sizeof(size_t));
50*a28cd43dSSascha Wildner
51*a28cd43dSSascha Wildner #define NOISELENGTH 32
52*a28cd43dSSascha Wildner
53*a28cd43dSSascha Wildner
54*a28cd43dSSascha Wildner /*-*************************************
55*a28cd43dSSascha Wildner * Console display
56*a28cd43dSSascha Wildner ***************************************/
57*a28cd43dSSascha Wildner #define DISPLAY(...) fprintf(stderr, __VA_ARGS__)
58*a28cd43dSSascha Wildner #define DISPLAYLEVEL(l, ...) if (displayLevel>=l) { DISPLAY(__VA_ARGS__); }
59*a28cd43dSSascha Wildner
60*a28cd43dSSascha Wildner static const U64 g_refreshRate = SEC_TO_MICRO / 6;
61*a28cd43dSSascha Wildner static UTIL_time_t g_displayClock = UTIL_TIME_INITIALIZER;
62*a28cd43dSSascha Wildner
63*a28cd43dSSascha Wildner #define DISPLAYUPDATE(l, ...) { if (displayLevel>=l) { \
64*a28cd43dSSascha Wildner if ((UTIL_clockSpanMicro(g_displayClock) > g_refreshRate) || (displayLevel>=4)) \
65*a28cd43dSSascha Wildner { g_displayClock = UTIL_getTime(); DISPLAY(__VA_ARGS__); \
66*a28cd43dSSascha Wildner if (displayLevel>=4) fflush(stderr); } } }
67*a28cd43dSSascha Wildner
68*a28cd43dSSascha Wildner /*-*************************************
69*a28cd43dSSascha Wildner * Exceptions
70*a28cd43dSSascha Wildner ***************************************/
71*a28cd43dSSascha Wildner #ifndef DEBUG
72*a28cd43dSSascha Wildner # define DEBUG 0
73*a28cd43dSSascha Wildner #endif
74*a28cd43dSSascha Wildner #define DEBUGOUTPUT(...) if (DEBUG) DISPLAY(__VA_ARGS__);
75*a28cd43dSSascha Wildner #define EXM_THROW(error, ...) \
76*a28cd43dSSascha Wildner { \
77*a28cd43dSSascha Wildner DEBUGOUTPUT("Error defined at %s, line %i : \n", __FILE__, __LINE__); \
78*a28cd43dSSascha Wildner DISPLAY("Error %i : ", error); \
79*a28cd43dSSascha Wildner DISPLAY(__VA_ARGS__); \
80*a28cd43dSSascha Wildner DISPLAY("\n"); \
81*a28cd43dSSascha Wildner exit(error); \
82*a28cd43dSSascha Wildner }
83*a28cd43dSSascha Wildner
84*a28cd43dSSascha Wildner
85*a28cd43dSSascha Wildner /* ********************************************************
86*a28cd43dSSascha Wildner * Helper functions
87*a28cd43dSSascha Wildner **********************************************************/
88*a28cd43dSSascha Wildner #undef MIN
89*a28cd43dSSascha Wildner #define MIN(a,b) ((a) < (b) ? (a) : (b))
90*a28cd43dSSascha Wildner
91*a28cd43dSSascha Wildner
92*a28cd43dSSascha Wildner /* ********************************************************
93*a28cd43dSSascha Wildner * File related operations
94*a28cd43dSSascha Wildner **********************************************************/
95*a28cd43dSSascha Wildner /** DiB_loadFiles() :
96*a28cd43dSSascha Wildner * load samples from files listed in fileNamesTable into buffer.
97*a28cd43dSSascha Wildner * works even if buffer is too small to load all samples.
98*a28cd43dSSascha Wildner * Also provides the size of each sample into sampleSizes table
99*a28cd43dSSascha Wildner * which must be sized correctly, using DiB_fileStats().
100*a28cd43dSSascha Wildner * @return : nb of samples effectively loaded into `buffer`
101*a28cd43dSSascha Wildner * *bufferSizePtr is modified, it provides the amount data loaded within buffer.
102*a28cd43dSSascha Wildner * sampleSizes is filled with the size of each sample.
103*a28cd43dSSascha Wildner */
DiB_loadFiles(void * buffer,size_t * bufferSizePtr,size_t * sampleSizes,unsigned sstSize,const char ** fileNamesTable,unsigned nbFiles,size_t targetChunkSize,unsigned displayLevel)104*a28cd43dSSascha Wildner static unsigned DiB_loadFiles(void* buffer, size_t* bufferSizePtr,
105*a28cd43dSSascha Wildner size_t* sampleSizes, unsigned sstSize,
106*a28cd43dSSascha Wildner const char** fileNamesTable, unsigned nbFiles, size_t targetChunkSize,
107*a28cd43dSSascha Wildner unsigned displayLevel)
108*a28cd43dSSascha Wildner {
109*a28cd43dSSascha Wildner char* const buff = (char*)buffer;
110*a28cd43dSSascha Wildner size_t pos = 0;
111*a28cd43dSSascha Wildner unsigned nbLoadedChunks = 0, fileIndex;
112*a28cd43dSSascha Wildner
113*a28cd43dSSascha Wildner for (fileIndex=0; fileIndex<nbFiles; fileIndex++) {
114*a28cd43dSSascha Wildner const char* const fileName = fileNamesTable[fileIndex];
115*a28cd43dSSascha Wildner unsigned long long const fs64 = UTIL_getFileSize(fileName);
116*a28cd43dSSascha Wildner unsigned long long remainingToLoad = (fs64 == UTIL_FILESIZE_UNKNOWN) ? 0 : fs64;
117*a28cd43dSSascha Wildner U32 const nbChunks = targetChunkSize ? (U32)((fs64 + (targetChunkSize-1)) / targetChunkSize) : 1;
118*a28cd43dSSascha Wildner U64 const chunkSize = targetChunkSize ? MIN(targetChunkSize, fs64) : fs64;
119*a28cd43dSSascha Wildner size_t const maxChunkSize = (size_t)MIN(chunkSize, SAMPLESIZE_MAX);
120*a28cd43dSSascha Wildner U32 cnb;
121*a28cd43dSSascha Wildner FILE* const f = fopen(fileName, "rb");
122*a28cd43dSSascha Wildner if (f==NULL) EXM_THROW(10, "zstd: dictBuilder: %s %s ", fileName, strerror(errno));
123*a28cd43dSSascha Wildner DISPLAYUPDATE(2, "Loading %s... \r", fileName);
124*a28cd43dSSascha Wildner for (cnb=0; cnb<nbChunks; cnb++) {
125*a28cd43dSSascha Wildner size_t const toLoad = (size_t)MIN(maxChunkSize, remainingToLoad);
126*a28cd43dSSascha Wildner if (toLoad > *bufferSizePtr-pos) break;
127*a28cd43dSSascha Wildner { size_t const readSize = fread(buff+pos, 1, toLoad, f);
128*a28cd43dSSascha Wildner if (readSize != toLoad) EXM_THROW(11, "Pb reading %s", fileName);
129*a28cd43dSSascha Wildner pos += readSize;
130*a28cd43dSSascha Wildner sampleSizes[nbLoadedChunks++] = toLoad;
131*a28cd43dSSascha Wildner remainingToLoad -= targetChunkSize;
132*a28cd43dSSascha Wildner if (nbLoadedChunks == sstSize) { /* no more space left in sampleSizes table */
133*a28cd43dSSascha Wildner fileIndex = nbFiles; /* stop there */
134*a28cd43dSSascha Wildner break;
135*a28cd43dSSascha Wildner }
136*a28cd43dSSascha Wildner if (toLoad < targetChunkSize) {
137*a28cd43dSSascha Wildner fseek(f, (long)(targetChunkSize - toLoad), SEEK_CUR);
138*a28cd43dSSascha Wildner } } }
139*a28cd43dSSascha Wildner fclose(f);
140*a28cd43dSSascha Wildner }
141*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "\r%79s\r", "");
142*a28cd43dSSascha Wildner *bufferSizePtr = pos;
143*a28cd43dSSascha Wildner DISPLAYLEVEL(4, "loaded : %u KB \n", (unsigned)(pos >> 10))
144*a28cd43dSSascha Wildner return nbLoadedChunks;
145*a28cd43dSSascha Wildner }
146*a28cd43dSSascha Wildner
147*a28cd43dSSascha Wildner #define DiB_rotl32(x,r) ((x << r) | (x >> (32 - r)))
DiB_rand(U32 * src)148*a28cd43dSSascha Wildner static U32 DiB_rand(U32* src)
149*a28cd43dSSascha Wildner {
150*a28cd43dSSascha Wildner static const U32 prime1 = 2654435761U;
151*a28cd43dSSascha Wildner static const U32 prime2 = 2246822519U;
152*a28cd43dSSascha Wildner U32 rand32 = *src;
153*a28cd43dSSascha Wildner rand32 *= prime1;
154*a28cd43dSSascha Wildner rand32 ^= prime2;
155*a28cd43dSSascha Wildner rand32 = DiB_rotl32(rand32, 13);
156*a28cd43dSSascha Wildner *src = rand32;
157*a28cd43dSSascha Wildner return rand32 >> 5;
158*a28cd43dSSascha Wildner }
159*a28cd43dSSascha Wildner
160*a28cd43dSSascha Wildner /* DiB_shuffle() :
161*a28cd43dSSascha Wildner * shuffle a table of file names in a semi-random way
162*a28cd43dSSascha Wildner * It improves dictionary quality by reducing "locality" impact, so if sample set is very large,
163*a28cd43dSSascha Wildner * it will load random elements from it, instead of just the first ones. */
DiB_shuffle(const char ** fileNamesTable,unsigned nbFiles)164*a28cd43dSSascha Wildner static void DiB_shuffle(const char** fileNamesTable, unsigned nbFiles) {
165*a28cd43dSSascha Wildner U32 seed = 0xFD2FB528;
166*a28cd43dSSascha Wildner unsigned i;
167*a28cd43dSSascha Wildner assert(nbFiles >= 1);
168*a28cd43dSSascha Wildner for (i = nbFiles - 1; i > 0; --i) {
169*a28cd43dSSascha Wildner unsigned const j = DiB_rand(&seed) % (i + 1);
170*a28cd43dSSascha Wildner const char* const tmp = fileNamesTable[j];
171*a28cd43dSSascha Wildner fileNamesTable[j] = fileNamesTable[i];
172*a28cd43dSSascha Wildner fileNamesTable[i] = tmp;
173*a28cd43dSSascha Wildner }
174*a28cd43dSSascha Wildner }
175*a28cd43dSSascha Wildner
176*a28cd43dSSascha Wildner
177*a28cd43dSSascha Wildner /*-********************************************************
178*a28cd43dSSascha Wildner * Dictionary training functions
179*a28cd43dSSascha Wildner **********************************************************/
DiB_findMaxMem(unsigned long long requiredMem)180*a28cd43dSSascha Wildner static size_t DiB_findMaxMem(unsigned long long requiredMem)
181*a28cd43dSSascha Wildner {
182*a28cd43dSSascha Wildner size_t const step = 8 MB;
183*a28cd43dSSascha Wildner void* testmem = NULL;
184*a28cd43dSSascha Wildner
185*a28cd43dSSascha Wildner requiredMem = (((requiredMem >> 23) + 1) << 23);
186*a28cd43dSSascha Wildner requiredMem += step;
187*a28cd43dSSascha Wildner if (requiredMem > g_maxMemory) requiredMem = g_maxMemory;
188*a28cd43dSSascha Wildner
189*a28cd43dSSascha Wildner while (!testmem) {
190*a28cd43dSSascha Wildner testmem = malloc((size_t)requiredMem);
191*a28cd43dSSascha Wildner requiredMem -= step;
192*a28cd43dSSascha Wildner }
193*a28cd43dSSascha Wildner
194*a28cd43dSSascha Wildner free(testmem);
195*a28cd43dSSascha Wildner return (size_t)requiredMem;
196*a28cd43dSSascha Wildner }
197*a28cd43dSSascha Wildner
198*a28cd43dSSascha Wildner
DiB_fillNoise(void * buffer,size_t length)199*a28cd43dSSascha Wildner static void DiB_fillNoise(void* buffer, size_t length)
200*a28cd43dSSascha Wildner {
201*a28cd43dSSascha Wildner unsigned const prime1 = 2654435761U;
202*a28cd43dSSascha Wildner unsigned const prime2 = 2246822519U;
203*a28cd43dSSascha Wildner unsigned acc = prime1;
204*a28cd43dSSascha Wildner size_t p=0;
205*a28cd43dSSascha Wildner
206*a28cd43dSSascha Wildner for (p=0; p<length; p++) {
207*a28cd43dSSascha Wildner acc *= prime2;
208*a28cd43dSSascha Wildner ((unsigned char*)buffer)[p] = (unsigned char)(acc >> 21);
209*a28cd43dSSascha Wildner }
210*a28cd43dSSascha Wildner }
211*a28cd43dSSascha Wildner
212*a28cd43dSSascha Wildner
DiB_saveDict(const char * dictFileName,const void * buff,size_t buffSize)213*a28cd43dSSascha Wildner static void DiB_saveDict(const char* dictFileName,
214*a28cd43dSSascha Wildner const void* buff, size_t buffSize)
215*a28cd43dSSascha Wildner {
216*a28cd43dSSascha Wildner FILE* const f = fopen(dictFileName, "wb");
217*a28cd43dSSascha Wildner if (f==NULL) EXM_THROW(3, "cannot open %s ", dictFileName);
218*a28cd43dSSascha Wildner
219*a28cd43dSSascha Wildner { size_t const n = fwrite(buff, 1, buffSize, f);
220*a28cd43dSSascha Wildner if (n!=buffSize) EXM_THROW(4, "%s : write error", dictFileName) }
221*a28cd43dSSascha Wildner
222*a28cd43dSSascha Wildner { size_t const n = (size_t)fclose(f);
223*a28cd43dSSascha Wildner if (n!=0) EXM_THROW(5, "%s : flush error", dictFileName) }
224*a28cd43dSSascha Wildner }
225*a28cd43dSSascha Wildner
226*a28cd43dSSascha Wildner
227*a28cd43dSSascha Wildner typedef struct {
228*a28cd43dSSascha Wildner U64 totalSizeToLoad;
229*a28cd43dSSascha Wildner unsigned oneSampleTooLarge;
230*a28cd43dSSascha Wildner unsigned nbSamples;
231*a28cd43dSSascha Wildner } fileStats;
232*a28cd43dSSascha Wildner
233*a28cd43dSSascha Wildner /*! DiB_fileStats() :
234*a28cd43dSSascha Wildner * Given a list of files, and a chunkSize (0 == no chunk, whole files)
235*a28cd43dSSascha Wildner * provides the amount of data to be loaded and the resulting nb of samples.
236*a28cd43dSSascha Wildner * This is useful primarily for allocation purpose => sample buffer, and sample sizes table.
237*a28cd43dSSascha Wildner */
DiB_fileStats(const char ** fileNamesTable,unsigned nbFiles,size_t chunkSize,unsigned displayLevel)238*a28cd43dSSascha Wildner static fileStats DiB_fileStats(const char** fileNamesTable, unsigned nbFiles, size_t chunkSize, unsigned displayLevel)
239*a28cd43dSSascha Wildner {
240*a28cd43dSSascha Wildner fileStats fs;
241*a28cd43dSSascha Wildner unsigned n;
242*a28cd43dSSascha Wildner memset(&fs, 0, sizeof(fs));
243*a28cd43dSSascha Wildner for (n=0; n<nbFiles; n++) {
244*a28cd43dSSascha Wildner U64 const fileSize = UTIL_getFileSize(fileNamesTable[n]);
245*a28cd43dSSascha Wildner U64 const srcSize = (fileSize == UTIL_FILESIZE_UNKNOWN) ? 0 : fileSize;
246*a28cd43dSSascha Wildner U32 const nbSamples = (U32)(chunkSize ? (srcSize + (chunkSize-1)) / chunkSize : 1);
247*a28cd43dSSascha Wildner U64 const chunkToLoad = chunkSize ? MIN(chunkSize, srcSize) : srcSize;
248*a28cd43dSSascha Wildner size_t const cappedChunkSize = (size_t)MIN(chunkToLoad, SAMPLESIZE_MAX);
249*a28cd43dSSascha Wildner fs.totalSizeToLoad += cappedChunkSize * nbSamples;
250*a28cd43dSSascha Wildner fs.oneSampleTooLarge |= (chunkSize > 2*SAMPLESIZE_MAX);
251*a28cd43dSSascha Wildner fs.nbSamples += nbSamples;
252*a28cd43dSSascha Wildner }
253*a28cd43dSSascha Wildner DISPLAYLEVEL(4, "Preparing to load : %u KB \n", (unsigned)(fs.totalSizeToLoad >> 10));
254*a28cd43dSSascha Wildner return fs;
255*a28cd43dSSascha Wildner }
256*a28cd43dSSascha Wildner
257*a28cd43dSSascha Wildner
258*a28cd43dSSascha Wildner /*! ZDICT_trainFromBuffer_unsafe_legacy() :
259*a28cd43dSSascha Wildner Strictly Internal use only !!
260*a28cd43dSSascha Wildner Same as ZDICT_trainFromBuffer_legacy(), but does not control `samplesBuffer`.
261*a28cd43dSSascha Wildner `samplesBuffer` must be followed by noisy guard band to avoid out-of-buffer reads.
262*a28cd43dSSascha Wildner @return : size of dictionary stored into `dictBuffer` (<= `dictBufferCapacity`)
263*a28cd43dSSascha Wildner or an error code.
264*a28cd43dSSascha Wildner */
265*a28cd43dSSascha Wildner size_t ZDICT_trainFromBuffer_unsafe_legacy(void* dictBuffer, size_t dictBufferCapacity,
266*a28cd43dSSascha Wildner const void* samplesBuffer, const size_t* samplesSizes, unsigned nbSamples,
267*a28cd43dSSascha Wildner ZDICT_legacy_params_t parameters);
268*a28cd43dSSascha Wildner
269*a28cd43dSSascha Wildner
DiB_trainFromFiles(const char * dictFileName,unsigned maxDictSize,const char ** fileNamesTable,unsigned nbFiles,size_t chunkSize,ZDICT_legacy_params_t * params,ZDICT_cover_params_t * coverParams,ZDICT_fastCover_params_t * fastCoverParams,int optimize)270*a28cd43dSSascha Wildner int DiB_trainFromFiles(const char* dictFileName, unsigned maxDictSize,
271*a28cd43dSSascha Wildner const char** fileNamesTable, unsigned nbFiles, size_t chunkSize,
272*a28cd43dSSascha Wildner ZDICT_legacy_params_t* params, ZDICT_cover_params_t* coverParams,
273*a28cd43dSSascha Wildner ZDICT_fastCover_params_t* fastCoverParams, int optimize)
274*a28cd43dSSascha Wildner {
275*a28cd43dSSascha Wildner unsigned const displayLevel = params ? params->zParams.notificationLevel :
276*a28cd43dSSascha Wildner coverParams ? coverParams->zParams.notificationLevel :
277*a28cd43dSSascha Wildner fastCoverParams ? fastCoverParams->zParams.notificationLevel :
278*a28cd43dSSascha Wildner 0; /* should never happen */
279*a28cd43dSSascha Wildner void* const dictBuffer = malloc(maxDictSize);
280*a28cd43dSSascha Wildner fileStats const fs = DiB_fileStats(fileNamesTable, nbFiles, chunkSize, displayLevel);
281*a28cd43dSSascha Wildner size_t* const sampleSizes = (size_t*)malloc(fs.nbSamples * sizeof(size_t));
282*a28cd43dSSascha Wildner size_t const memMult = params ? MEMMULT :
283*a28cd43dSSascha Wildner coverParams ? COVER_MEMMULT:
284*a28cd43dSSascha Wildner FASTCOVER_MEMMULT;
285*a28cd43dSSascha Wildner size_t const maxMem = DiB_findMaxMem(fs.totalSizeToLoad * memMult) / memMult;
286*a28cd43dSSascha Wildner size_t loadedSize = (size_t) MIN ((unsigned long long)maxMem, fs.totalSizeToLoad);
287*a28cd43dSSascha Wildner void* const srcBuffer = malloc(loadedSize+NOISELENGTH);
288*a28cd43dSSascha Wildner int result = 0;
289*a28cd43dSSascha Wildner
290*a28cd43dSSascha Wildner /* Checks */
291*a28cd43dSSascha Wildner if ((!sampleSizes) || (!srcBuffer) || (!dictBuffer))
292*a28cd43dSSascha Wildner EXM_THROW(12, "not enough memory for DiB_trainFiles"); /* should not happen */
293*a28cd43dSSascha Wildner if (fs.oneSampleTooLarge) {
294*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! Warning : some sample(s) are very large \n");
295*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! Note that dictionary is only useful for small samples. \n");
296*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! As a consequence, only the first %u bytes of each sample are loaded \n", SAMPLESIZE_MAX);
297*a28cd43dSSascha Wildner }
298*a28cd43dSSascha Wildner if (fs.nbSamples < 5) {
299*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! Warning : nb of samples too low for proper processing ! \n");
300*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! Please provide _one file per sample_. \n");
301*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! Alternatively, split files into fixed-size blocks representative of samples, with -B# \n");
302*a28cd43dSSascha Wildner EXM_THROW(14, "nb of samples too low"); /* we now clearly forbid this case */
303*a28cd43dSSascha Wildner }
304*a28cd43dSSascha Wildner if (fs.totalSizeToLoad < (unsigned long long)maxDictSize * 8) {
305*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! Warning : data size of samples too small for target dictionary size \n");
306*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "! Samples should be about 100x larger than target dictionary size \n");
307*a28cd43dSSascha Wildner }
308*a28cd43dSSascha Wildner
309*a28cd43dSSascha Wildner /* init */
310*a28cd43dSSascha Wildner if (loadedSize < fs.totalSizeToLoad)
311*a28cd43dSSascha Wildner DISPLAYLEVEL(1, "Not enough memory; training on %u MB only...\n", (unsigned)(loadedSize >> 20));
312*a28cd43dSSascha Wildner
313*a28cd43dSSascha Wildner /* Load input buffer */
314*a28cd43dSSascha Wildner DISPLAYLEVEL(3, "Shuffling input files\n");
315*a28cd43dSSascha Wildner DiB_shuffle(fileNamesTable, nbFiles);
316*a28cd43dSSascha Wildner
317*a28cd43dSSascha Wildner DiB_loadFiles(srcBuffer, &loadedSize, sampleSizes, fs.nbSamples, fileNamesTable, nbFiles, chunkSize, displayLevel);
318*a28cd43dSSascha Wildner
319*a28cd43dSSascha Wildner { size_t dictSize;
320*a28cd43dSSascha Wildner if (params) {
321*a28cd43dSSascha Wildner DiB_fillNoise((char*)srcBuffer + loadedSize, NOISELENGTH); /* guard band, for end of buffer condition */
322*a28cd43dSSascha Wildner dictSize = ZDICT_trainFromBuffer_unsafe_legacy(dictBuffer, maxDictSize,
323*a28cd43dSSascha Wildner srcBuffer, sampleSizes, fs.nbSamples,
324*a28cd43dSSascha Wildner *params);
325*a28cd43dSSascha Wildner } else if (coverParams) {
326*a28cd43dSSascha Wildner if (optimize) {
327*a28cd43dSSascha Wildner dictSize = ZDICT_optimizeTrainFromBuffer_cover(dictBuffer, maxDictSize,
328*a28cd43dSSascha Wildner srcBuffer, sampleSizes, fs.nbSamples,
329*a28cd43dSSascha Wildner coverParams);
330*a28cd43dSSascha Wildner if (!ZDICT_isError(dictSize)) {
331*a28cd43dSSascha Wildner unsigned splitPercentage = (unsigned)(coverParams->splitPoint * 100);
332*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "k=%u\nd=%u\nsteps=%u\nsplit=%u\n", coverParams->k, coverParams->d,
333*a28cd43dSSascha Wildner coverParams->steps, splitPercentage);
334*a28cd43dSSascha Wildner }
335*a28cd43dSSascha Wildner } else {
336*a28cd43dSSascha Wildner dictSize = ZDICT_trainFromBuffer_cover(dictBuffer, maxDictSize, srcBuffer,
337*a28cd43dSSascha Wildner sampleSizes, fs.nbSamples, *coverParams);
338*a28cd43dSSascha Wildner }
339*a28cd43dSSascha Wildner } else {
340*a28cd43dSSascha Wildner assert(fastCoverParams != NULL);
341*a28cd43dSSascha Wildner if (optimize) {
342*a28cd43dSSascha Wildner dictSize = ZDICT_optimizeTrainFromBuffer_fastCover(dictBuffer, maxDictSize,
343*a28cd43dSSascha Wildner srcBuffer, sampleSizes, fs.nbSamples,
344*a28cd43dSSascha Wildner fastCoverParams);
345*a28cd43dSSascha Wildner if (!ZDICT_isError(dictSize)) {
346*a28cd43dSSascha Wildner unsigned splitPercentage = (unsigned)(fastCoverParams->splitPoint * 100);
347*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "k=%u\nd=%u\nf=%u\nsteps=%u\nsplit=%u\naccel=%u\n", fastCoverParams->k,
348*a28cd43dSSascha Wildner fastCoverParams->d, fastCoverParams->f, fastCoverParams->steps, splitPercentage,
349*a28cd43dSSascha Wildner fastCoverParams->accel);
350*a28cd43dSSascha Wildner }
351*a28cd43dSSascha Wildner } else {
352*a28cd43dSSascha Wildner dictSize = ZDICT_trainFromBuffer_fastCover(dictBuffer, maxDictSize, srcBuffer,
353*a28cd43dSSascha Wildner sampleSizes, fs.nbSamples, *fastCoverParams);
354*a28cd43dSSascha Wildner }
355*a28cd43dSSascha Wildner }
356*a28cd43dSSascha Wildner if (ZDICT_isError(dictSize)) {
357*a28cd43dSSascha Wildner DISPLAYLEVEL(1, "dictionary training failed : %s \n", ZDICT_getErrorName(dictSize)); /* should not happen */
358*a28cd43dSSascha Wildner result = 1;
359*a28cd43dSSascha Wildner goto _cleanup;
360*a28cd43dSSascha Wildner }
361*a28cd43dSSascha Wildner /* save dict */
362*a28cd43dSSascha Wildner DISPLAYLEVEL(2, "Save dictionary of size %u into file %s \n", (unsigned)dictSize, dictFileName);
363*a28cd43dSSascha Wildner DiB_saveDict(dictFileName, dictBuffer, dictSize);
364*a28cd43dSSascha Wildner }
365*a28cd43dSSascha Wildner
366*a28cd43dSSascha Wildner /* clean up */
367*a28cd43dSSascha Wildner _cleanup:
368*a28cd43dSSascha Wildner free(srcBuffer);
369*a28cd43dSSascha Wildner free(sampleSizes);
370*a28cd43dSSascha Wildner free(dictBuffer);
371*a28cd43dSSascha Wildner return result;
372*a28cd43dSSascha Wildner }
373