! * @brief Calculates a 64->128-bit long multiply. * * Uses `__uint128_t` and `_umul128` if available, otherwise uses a scalar * version. * * @p

* Force direct memory access. Only works on CPU which support unaligned memory * access in hardware. */

Force direct memory access. Only works on CPU which support unaligned memory access in hardware */

Signals to the processor to give resources to threads that are waiting for them. ////////////////////////////////////////////////////////////////////

note : all CCtx borrowed from the pool must be reverted back to the pool _before_ freeing the pool */

ZSTD_adjustCParams_internal() : * optimize `cPar` for a specified input (`srcSize` and `dictSize`). * mostly downsize to reduce memory consumption

Builds entropy statistics and uses them for blocksize estimation. * * @return: estimated compressed size of the seqStore, or a zstd error. */

@return provides a minimum amount of data remaining to be flushed from internal buffers */

Need to use memmove here since the literal buffer can now be located within the dst buffer. In circumstances where the op "catches up" to where the

* The provided workspace takes ownership of the buffer [start, start+size). * Any existing values in the workspace are ignored (the previously manage

ZSTD_frameHeaderSize_internal() : * srcSize must be large enough to reach header size fields. * note : only works for formats ZSTD_f_zstd1 and ZST

ZSTD_getFrameHeader() : * decode Frame Header, or require larger `srcSize`. * note : this function does not consume input, it only reads it. * @r

Unrolled loop to read four size_ts of input at a time. Returns 1 if is RLE, 0 if not. */

ZSTD_ldm_insertEntry() : * Insert the entry with corresponding hash into the hash table */

! ZSTD_resetCCtx_internal() : * @param loadedDictSize The size of the dictionary to be loaded * into the context, if any. If no dictionary is used,

Returns true if the strategy supports using a row based matchfinder */

ZSTD_safecopyDstBeforeSrc(): * This version allows overlap with dst before src, or handles the non-overlap case with dst after src * Kept separate f

ZSTD_scaleStats() : * reduce all elt frequencies in table if sum too large * return the resulting sum of elements */

* ZSTD_window_hasExtDict(): * Returns non-zero if the window has a non-empty extDict. */

Helper function for ZSTD_fillHashTable and ZSTD_fillDoubleHashTable. * Unpacks hashAndTag into (hash, tag), then packs (index, tag) into hashTable[ha

FP32 Atomic functions performs Atomic operation treating the uav as float (fp32) values the passed sub-opcode 'op' should be an immediate constant byt

Compute the bitwise NOT of packed double-precision (64-bit) floating-point elements in a and then AND with b, and store the results in dst. https://so

Compare packed double-precision (64-bit) floating-point elements in a and b for equality, and store the results in dst. https://software.intel.com/sit

Compare packed double-precision (64-bit) floating-point elements in a and b for not-equal, and store the results in dst. https://software.intel.com/si

Divide packed double-precision (64-bit) floating-point elements in a by packed elements in b, and store the results in dst. https://software.intel.com

Loads two double-precision from unaligned memory, floating-point values. https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_loadu_

Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed maximum values in dst. https://software.intel.com/sites/

Compare packed double-precision (64-bit) floating-point elements in a and b, and store packed minimum values in dst. https://software.intel.com/sites/

Multiply packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. https://software.intel.com/sites/landingpa

Multiplies the 8 signed 16-bit integers from a by the 8 signed 16-bit integers from b. https://msdn.microsoft.com/en-us/library/vstudio/59hddw1d(v=vs.

Compute the bitwise OR of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. https://software.intel.co

Copy double-precision (64-bit) floating-point element a to the lower element of dst, and zero the upper element. https://software.intel.com/sites/land

Set packed double-precision (64-bit) floating-point elements in dst with the supplied values in reverse order. https://software.intel.com/sites/landin

Return vector of type __m128d with all elements set to zero. https://software.intel.com/sites/landingpage/IntrinsicsGuide/#text=_mm_setzero_pd

Negate packed 32-bit integers in a when the corresponding signed 32-bit integer in b is negative, and store the results in dst. Element in dst are zer

Compute the square root of packed double-precision (64-bit) floating-point elements in a, and store the results in dst. https://software.intel.com/sit

Stores four 32-bit integer values as (as a __m128i value) at the address p. https://msdn.microsoft.com/en-us/library/vstudio/edk11s13(v=vs.100).aspx

Subtract the lower single-precision (32-bit) floating-point element in b from the lower single-precision (32-bit) floating-point element in a, store t

Compute the bitwise XOR of packed double-precision (64-bit) floating-point elements in a and b, and store the results in dst. https://software.intel.c

Return a new staging buffer

** check whether current token is in the follow set of a block. ** 'until' closes syntactical blocks, but do not close scope, ** so it is handled in s

int bsplitcb (const bstring* str, unsigned char splitChar, int pos, * int (* cb) (void * parm, int ofs, int len), void * parm) * *