zstd_cwksp.h File Reference

#include "zstd_internal.h"

Include dependency graph for zstd_cwksp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ZSTD_cwksp

Macros
#define	ZSTD_CWKSP_ASAN_REDZONE_SIZE   128

Enumerations
enum	ZSTD_cwksp_alloc_phase_e { ZSTD_cwksp_alloc_objects , ZSTD_cwksp_alloc_buffers , ZSTD_cwksp_alloc_aligned }

Functions
MEM_STATIC size_t	ZSTD_cwksp_available_space (ZSTD_cwksp *ws)
MEM_STATIC void	ZSTD_cwksp_assert_internal_consistency (ZSTD_cwksp *ws)
MEM_STATIC size_t	ZSTD_cwksp_align (size_t size, size_t const align)
MEM_STATIC size_t	ZSTD_cwksp_alloc_size (size_t size)
MEM_STATIC void	ZSTD_cwksp_internal_advance_phase (ZSTD_cwksp *ws, ZSTD_cwksp_alloc_phase_e phase)
MEM_STATIC int	ZSTD_cwksp_owns_buffer (const ZSTD_cwksp *ws, const void *ptr)
MEM_STATIC void *	ZSTD_cwksp_reserve_internal (ZSTD_cwksp *ws, size_t bytes, ZSTD_cwksp_alloc_phase_e phase)
MEM_STATIC BYTE *	ZSTD_cwksp_reserve_buffer (ZSTD_cwksp *ws, size_t bytes)
MEM_STATIC void *	ZSTD_cwksp_reserve_aligned (ZSTD_cwksp *ws, size_t bytes)
MEM_STATIC void *	ZSTD_cwksp_reserve_table (ZSTD_cwksp *ws, size_t bytes)
MEM_STATIC void *	ZSTD_cwksp_reserve_object (ZSTD_cwksp *ws, size_t bytes)
MEM_STATIC void	ZSTD_cwksp_mark_tables_dirty (ZSTD_cwksp *ws)
MEM_STATIC void	ZSTD_cwksp_mark_tables_clean (ZSTD_cwksp *ws)
MEM_STATIC void	ZSTD_cwksp_clean_tables (ZSTD_cwksp *ws)
MEM_STATIC void	ZSTD_cwksp_clear_tables (ZSTD_cwksp *ws)
MEM_STATIC void	ZSTD_cwksp_clear (ZSTD_cwksp *ws)
MEM_STATIC void	ZSTD_cwksp_init (ZSTD_cwksp *ws, void *start, size_t size)
MEM_STATIC size_t	ZSTD_cwksp_create (ZSTD_cwksp *ws, size_t size, ZSTD_customMem customMem)
MEM_STATIC void	ZSTD_cwksp_free (ZSTD_cwksp *ws, ZSTD_customMem customMem)
MEM_STATIC void	ZSTD_cwksp_move (ZSTD_cwksp *dst, ZSTD_cwksp *src)
MEM_STATIC size_t	ZSTD_cwksp_sizeof (const ZSTD_cwksp *ws)
MEM_STATIC int	ZSTD_cwksp_reserve_failed (const ZSTD_cwksp *ws)
MEM_STATIC int	ZSTD_cwksp_check_available (ZSTD_cwksp *ws, size_t additionalNeededSpace)
MEM_STATIC int	ZSTD_cwksp_check_too_large (ZSTD_cwksp *ws, size_t additionalNeededSpace)
MEM_STATIC int	ZSTD_cwksp_check_wasteful (ZSTD_cwksp *ws, size_t additionalNeededSpace)
MEM_STATIC void	ZSTD_cwksp_bump_oversized_duration (ZSTD_cwksp *ws, size_t additionalNeededSpace)

Macro Definition Documentation

ZSTD_CWKSP_ASAN_REDZONE_SIZE

#define ZSTD_CWKSP_ASAN_REDZONE_SIZE   128

Definition at line 35 of file zstd_cwksp.h.

Enumeration Type Documentation

ZSTD_cwksp_alloc_phase_e

enum ZSTD_cwksp_alloc_phase_e

Enumerator
ZSTD_cwksp_alloc_objects
ZSTD_cwksp_alloc_buffers
ZSTD_cwksp_alloc_aligned

Definition at line 41 of file zstd_cwksp.h.

             {
    ZSTD_cwksp_alloc_objects,
    ZSTD_cwksp_alloc_buffers,
    ZSTD_cwksp_alloc_aligned
} ZSTD_cwksp_alloc_phase_e;

Function Documentation

ZSTD_cwksp_align()

MEM_STATIC size_t ZSTD_cwksp_align	(	size_t	size,
		size_t const	align
	)

Align must be a power of 2.

Definition at line 164 of file zstd_cwksp.h.

                                                                    {
    size_t const mask = align - 1;
    assert((align & mask) == 0);
    return (size + mask) & ~mask;
}

Referenced by ZSTD_createCDict_advanced(), ZSTD_cwksp_reserve_aligned(), ZSTD_cwksp_reserve_object(), ZSTD_estimateCDictSize_advanced(), ZSTD_initCDict_internal(), and ZSTD_initStaticCDict().

ZSTD_cwksp_alloc_size()

MEM_STATIC size_t ZSTD_cwksp_alloc_size

(

size_t

size

)

Use this to determine how much space in the workspace we will consume to allocate this object. (Normally it should be exactly the size of the object, but under special conditions, like ASAN, where we pad each object, it might be larger.)

Since tables aren't currently redzoned, you don't need to call through this to figure out how much space you need for the matchState tables. Everything else is though.

Definition at line 180 of file zstd_cwksp.h.

                                                     {
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    return size + 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;
#else
    return size;
#endif
}

Referenced by ZSTD_createCDict_advanced(), ZSTD_estimateCCtxSize_usingCCtxParams(), ZSTD_estimateCDictSize_advanced(), ZSTD_estimateCStreamSize_usingCCtxParams(), ZSTD_initStaticCDict(), ZSTD_ldm_getTableSize(), ZSTD_resetCCtx_internal(), and ZSTD_sizeof_matchState().

ZSTD_cwksp_assert_internal_consistency()

MEM_STATIC void ZSTD_cwksp_assert_internal_consistency

(

ZSTD_cwksp *

ws

)

Definition at line 151 of file zstd_cwksp.h.

                                                                       {
    (void)ws;
    assert(ws->workspace <= ws->objectEnd);
    assert(ws->objectEnd <= ws->tableEnd);
    assert(ws->objectEnd <= ws->tableValidEnd);
    assert(ws->tableEnd <= ws->allocStart);
    assert(ws->tableValidEnd <= ws->allocStart);
    assert(ws->allocStart <= ws->workspaceEnd);
}

Referenced by ZSTD_cwksp_clear(), ZSTD_cwksp_clear_tables(), ZSTD_cwksp_init(), ZSTD_cwksp_mark_tables_clean(), ZSTD_cwksp_mark_tables_dirty(), ZSTD_cwksp_reserve_internal(), ZSTD_cwksp_reserve_object(), and ZSTD_cwksp_reserve_table().

ZSTD_cwksp_available_space()

MEM_STATIC size_t ZSTD_cwksp_available_space

(

ZSTD_cwksp *

ws

)

Definition at line 494 of file zstd_cwksp.h.

                                                             {
    return (size_t)((BYTE*)ws->allocStart - (BYTE*)ws->tableEnd);
}

Referenced by ZSTD_cwksp_check_available(), ZSTD_cwksp_reserve_internal(), ZSTD_cwksp_reserve_object(), ZSTD_cwksp_reserve_table(), and ZSTD_resetCCtx_internal().

ZSTD_cwksp_bump_oversized_duration()

MEM_STATIC void ZSTD_cwksp_bump_oversized_duration	(	ZSTD_cwksp *	ws,
		size_t	additionalNeededSpace
	)

Definition at line 512 of file zstd_cwksp.h.

                                                      {
    if (ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)) {
        ws->workspaceOversizedDuration++;
    } else {
        ws->workspaceOversizedDuration = 0;
    }
}

Referenced by ZSTD_resetCCtx_internal().

ZSTD_cwksp_check_available()

MEM_STATIC int ZSTD_cwksp_check_available	(	ZSTD_cwksp *	ws,
		size_t	additionalNeededSpace
	)

Definition at line 498 of file zstd_cwksp.h.

                                                                                        {
    return ZSTD_cwksp_available_space(ws) >= additionalNeededSpace;
}

Referenced by ZSTD_cwksp_check_too_large(), ZSTD_initStaticCCtx(), and ZSTD_resetCCtx_internal().

ZSTD_cwksp_check_too_large()

MEM_STATIC int ZSTD_cwksp_check_too_large	(	ZSTD_cwksp *	ws,
		size_t	additionalNeededSpace
	)

Definition at line 502 of file zstd_cwksp.h.

                                                                                        {
    return ZSTD_cwksp_check_available(
        ws, additionalNeededSpace * ZSTD_WORKSPACETOOLARGE_FACTOR);
}

Referenced by ZSTD_cwksp_bump_oversized_duration(), and ZSTD_cwksp_check_wasteful().

ZSTD_cwksp_check_wasteful()

MEM_STATIC int ZSTD_cwksp_check_wasteful	(	ZSTD_cwksp *	ws,
		size_t	additionalNeededSpace
	)

Definition at line 507 of file zstd_cwksp.h.

                                                                                       {
    return ZSTD_cwksp_check_too_large(ws, additionalNeededSpace)
        && ws->workspaceOversizedDuration > ZSTD_WORKSPACETOOLARGE_MAXDURATION;
}

Referenced by ZSTD_resetCCtx_internal().

ZSTD_cwksp_clean_tables()

MEM_STATIC void ZSTD_cwksp_clean_tables

(

ZSTD_cwksp *

ws

)

Zero the part of the allocated tables not already marked clean.

Definition at line 378 of file zstd_cwksp.h.

                                                        {
    DEBUGLOG(4, "cwksp: ZSTD_cwksp_clean_tables");
    assert(ws->tableValidEnd >= ws->objectEnd);
    assert(ws->tableValidEnd <= ws->allocStart);
    if (ws->tableValidEnd < ws->tableEnd) {
        memset(ws->tableValidEnd, 0, (BYTE*)ws->tableEnd - (BYTE*)ws->tableValidEnd);
    }
    ZSTD_cwksp_mark_tables_clean(ws);
}

Referenced by ZSTD_reset_matchState().

ZSTD_cwksp_clear()

MEM_STATIC void ZSTD_cwksp_clear

(

ZSTD_cwksp *

ws

)

Invalidates all buffer, aligned, and table allocations. Object allocations remain valid.

Definition at line 410 of file zstd_cwksp.h.

                                                 {
    DEBUGLOG(4, "cwksp: clearing!");
 
#if defined (MEMORY_SANITIZER) && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
    /* To validate that the context re-use logic is sound, and that we don't
     * access stuff that this compression hasn't initialized, we re-"poison"
     * the workspace (or at least the non-static, non-table parts of it)
     * every time we start a new compression. */
    {
        size_t size = (BYTE*)ws->workspaceEnd - (BYTE*)ws->tableValidEnd;
        __msan_poison(ws->tableValidEnd, size);
    }
#endif
 
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    {
        size_t size = (BYTE*)ws->workspaceEnd - (BYTE*)ws->objectEnd;
        __asan_poison_memory_region(ws->objectEnd, size);
    }
#endif
 
    ws->tableEnd = ws->objectEnd;
    ws->allocStart = ws->workspaceEnd;
    ws->allocFailed = 0;
    if (ws->phase > ZSTD_cwksp_alloc_buffers) {
        ws->phase = ZSTD_cwksp_alloc_buffers;
    }
    ZSTD_cwksp_assert_internal_consistency(ws);
}

Referenced by ZSTD_cwksp_init(), and ZSTD_resetCCtx_internal().

ZSTD_cwksp_clear_tables()

MEM_STATIC void ZSTD_cwksp_clear_tables

(

ZSTD_cwksp *

ws

)

Invalidates table allocations. All other allocations remain valid.

Definition at line 392 of file zstd_cwksp.h.

                                                        {
    DEBUGLOG(4, "cwksp: clearing tables!");
 
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    {
        size_t size = (BYTE*)ws->tableValidEnd - (BYTE*)ws->objectEnd;
        __asan_poison_memory_region(ws->objectEnd, size);
    }
#endif
 
    ws->tableEnd = ws->objectEnd;
    ZSTD_cwksp_assert_internal_consistency(ws);
}

Referenced by ZSTD_reset_matchState().

ZSTD_cwksp_create()

MEM_STATIC size_t ZSTD_cwksp_create	(	ZSTD_cwksp *	ws,
		size_t	size,
		ZSTD_customMem	customMem
	)

Definition at line 458 of file zstd_cwksp.h.

                                                                                           {
    void* workspace = ZSTD_malloc(size, customMem);
    DEBUGLOG(4, "cwksp: creating new workspace with %zd bytes", size);
    RETURN_ERROR_IF(workspace == NULL, memory_allocation, "NULL pointer!");
    ZSTD_cwksp_init(ws, workspace, size);
    return 0;
}

Referenced by ZSTD_resetCCtx_internal().

ZSTD_cwksp_free()

MEM_STATIC void ZSTD_cwksp_free	(	ZSTD_cwksp *	ws,
		ZSTD_customMem	customMem
	)

Definition at line 466 of file zstd_cwksp.h.

                                                                          {
    void *ptr = ws->workspace;
    DEBUGLOG(4, "cwksp: freeing workspace");
    memset(ws, 0, sizeof(ZSTD_cwksp));
    ZSTD_free(ptr, customMem);
}

Referenced by ZSTD_freeCCtxContent(), ZSTD_freeCDict(), and ZSTD_resetCCtx_internal().

ZSTD_cwksp_init()

MEM_STATIC void ZSTD_cwksp_init	(	ZSTD_cwksp *	ws,
		void *	start,
		size_t	size
	)

The provided workspace takes ownership of the buffer [start, start+size). Any existing values in the workspace are ignored (the previously managed buffer, if present, must be separately freed).

Definition at line 445 of file zstd_cwksp.h.

                                                                          {
    DEBUGLOG(4, "cwksp: init'ing workspace with %zd bytes", size);
    assert(((size_t)start & (sizeof(void*)-1)) == 0); /* ensure correct alignment */
    ws->workspace = start;
    ws->workspaceEnd = (BYTE*)start + size;
    ws->objectEnd = ws->workspace;
    ws->tableValidEnd = ws->objectEnd;
    ws->phase = ZSTD_cwksp_alloc_objects;
    ZSTD_cwksp_clear(ws);
    ws->workspaceOversizedDuration = 0;
    ZSTD_cwksp_assert_internal_consistency(ws);
}

Referenced by ZSTD_createCDict_advanced(), ZSTD_cwksp_create(), ZSTD_initStaticCCtx(), and ZSTD_initStaticCDict().

ZSTD_cwksp_internal_advance_phase()

MEM_STATIC void ZSTD_cwksp_internal_advance_phase	(	ZSTD_cwksp *	ws,
		ZSTD_cwksp_alloc_phase_e	phase
	)

Definition at line 188 of file zstd_cwksp.h.

                                                        {
    assert(phase >= ws->phase);
    if (phase > ws->phase) {
        if (ws->phase < ZSTD_cwksp_alloc_buffers &&
                phase >= ZSTD_cwksp_alloc_buffers) {
            ws->tableValidEnd = ws->objectEnd;
        }
        if (ws->phase < ZSTD_cwksp_alloc_aligned &&
                phase >= ZSTD_cwksp_alloc_aligned) {
            /* If unaligned allocations down from a too-large top have left us
             * unaligned, we need to realign our alloc ptr. Technically, this
             * can consume space that is unaccounted for in the neededSpace
             * calculation. However, I believe this can only happen when the
             * workspace is too large, and specifically when it is too large
             * by a larger margin than the space that will be consumed. */
            /* TODO: cleaner, compiler warning friendly way to do this??? */
            ws->allocStart = (BYTE*)ws->allocStart - ((size_t)ws->allocStart & (sizeof(U32)-1));
            if (ws->allocStart < ws->tableValidEnd) {
                ws->tableValidEnd = ws->allocStart;
            }
        }
        ws->phase = phase;
    }
}

Referenced by ZSTD_cwksp_reserve_internal(), and ZSTD_cwksp_reserve_table().

ZSTD_cwksp_mark_tables_clean()

MEM_STATIC void ZSTD_cwksp_mark_tables_clean

(

ZSTD_cwksp *

ws

)

Definition at line 365 of file zstd_cwksp.h.

                                                             {
    DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_clean");
    assert(ws->tableValidEnd >= ws->objectEnd);
    assert(ws->tableValidEnd <= ws->allocStart);
    if (ws->tableValidEnd < ws->tableEnd) {
        ws->tableValidEnd = ws->tableEnd;
    }
    ZSTD_cwksp_assert_internal_consistency(ws);
}

Referenced by ZSTD_copyCCtx_internal(), ZSTD_cwksp_clean_tables(), ZSTD_overflowCorrectIfNeeded(), and ZSTD_resetCCtx_byCopyingCDict().

ZSTD_cwksp_mark_tables_dirty()

MEM_STATIC void ZSTD_cwksp_mark_tables_dirty

(

ZSTD_cwksp *

ws

)

Definition at line 345 of file zstd_cwksp.h.

                                                             {
    DEBUGLOG(4, "cwksp: ZSTD_cwksp_mark_tables_dirty");
 
#if defined (MEMORY_SANITIZER) && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
    /* To validate that the table re-use logic is sound, and that we don't
     * access table space that we haven't cleaned, we re-"poison" the table
     * space every time we mark it dirty. */
    {
        size_t size = (BYTE*)ws->tableValidEnd - (BYTE*)ws->objectEnd;
        assert(__msan_test_shadow(ws->objectEnd, size) == -1);
        __msan_poison(ws->objectEnd, size);
    }
#endif
 
    assert(ws->tableValidEnd >= ws->objectEnd);
    assert(ws->tableValidEnd <= ws->allocStart);
    ws->tableValidEnd = ws->objectEnd;
    ZSTD_cwksp_assert_internal_consistency(ws);
}

Referenced by ZSTD_copyCCtx_internal(), ZSTD_overflowCorrectIfNeeded(), ZSTD_reset_matchState(), and ZSTD_resetCCtx_byCopyingCDict().

ZSTD_cwksp_move()

MEM_STATIC void ZSTD_cwksp_move	(	ZSTD_cwksp *	dst,
		ZSTD_cwksp *	src
	)

Moves the management of a workspace from one cwksp to another. The src cwksp is left in an invalid state (src must be re-init()'ed before its used again).

Definition at line 477 of file zstd_cwksp.h.

                                                                  {
    *dst = *src;
    memset(src, 0, sizeof(ZSTD_cwksp));
}

Referenced by ZSTD_createCDict_advanced(), ZSTD_initStaticCCtx(), and ZSTD_initStaticCDict().

ZSTD_cwksp_owns_buffer()

MEM_STATIC int ZSTD_cwksp_owns_buffer	(	const ZSTD_cwksp *	ws,
		const void *	ptr
	)

Returns whether this object/buffer/etc was allocated in this workspace.

Definition at line 217 of file zstd_cwksp.h.

                                                                             {
    return (ptr != NULL) && (ws->workspace <= ptr) && (ptr <= ws->workspaceEnd);
}

Referenced by ZSTD_freeCCtx(), and ZSTD_freeCDict().

ZSTD_cwksp_reserve_aligned()

MEM_STATIC void * ZSTD_cwksp_reserve_aligned	(	ZSTD_cwksp *	ws,
		size_t	bytes
	)

Reserves and returns memory sized on and aligned on sizeof(unsigned).

Definition at line 270 of file zstd_cwksp.h.

                                                                          {
    assert((bytes & (sizeof(U32)-1)) == 0);
    return ZSTD_cwksp_reserve_internal(ws, ZSTD_cwksp_align(bytes, sizeof(U32)), ZSTD_cwksp_alloc_aligned);
}

Referenced by ZSTD_reset_matchState(), and ZSTD_resetCCtx_internal().

ZSTD_cwksp_reserve_buffer()

MEM_STATIC BYTE * ZSTD_cwksp_reserve_buffer	(	ZSTD_cwksp *	ws,
		size_t	bytes
	)

Reserves and returns unaligned memory.

Definition at line 263 of file zstd_cwksp.h.

                                                                         {
    return (BYTE*)ZSTD_cwksp_reserve_internal(ws, bytes, ZSTD_cwksp_alloc_buffers);
}

Referenced by ZSTD_resetCCtx_internal().

ZSTD_cwksp_reserve_failed()

MEM_STATIC int ZSTD_cwksp_reserve_failed

(

const ZSTD_cwksp *

ws

)

Definition at line 486 of file zstd_cwksp.h.

                                                               {
    return ws->allocFailed;
}

Referenced by ZSTD_reset_matchState().

ZSTD_cwksp_reserve_internal()

MEM_STATIC void * ZSTD_cwksp_reserve_internal	(	ZSTD_cwksp *	ws,
		size_t	bytes,
		ZSTD_cwksp_alloc_phase_e	phase
	)

Internal function. Do not use directly.

Definition at line 224 of file zstd_cwksp.h.

                                                                      {
    void* alloc;
    void* bottom = ws->tableEnd;
    ZSTD_cwksp_internal_advance_phase(ws, phase);
    alloc = (BYTE *)ws->allocStart - bytes;
 
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    /* over-reserve space */
    alloc = (BYTE *)alloc - 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;
#endif
 
    DEBUGLOG(5, "cwksp: reserving %p %zd bytes, %zd bytes remaining",
        alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);
    ZSTD_cwksp_assert_internal_consistency(ws);
    assert(alloc >= bottom);
    if (alloc < bottom) {
        DEBUGLOG(4, "cwksp: alloc failed!");
        ws->allocFailed = 1;
        return NULL;
    }
    if (alloc < ws->tableValidEnd) {
        ws->tableValidEnd = alloc;
    }
    ws->allocStart = alloc;
 
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    /* Move alloc so there's ZSTD_CWKSP_ASAN_REDZONE_SIZE unused space on
     * either size. */
    alloc = (BYTE *)alloc + ZSTD_CWKSP_ASAN_REDZONE_SIZE;
    __asan_unpoison_memory_region(alloc, bytes);
#endif
 
    return alloc;
}

Referenced by ZSTD_cwksp_reserve_aligned(), and ZSTD_cwksp_reserve_buffer().

ZSTD_cwksp_reserve_object()

MEM_STATIC void * ZSTD_cwksp_reserve_object	(	ZSTD_cwksp *	ws,
		size_t	bytes
	)

Aligned on sizeof(void*).

Definition at line 309 of file zstd_cwksp.h.

                                                                         {
    size_t roundedBytes = ZSTD_cwksp_align(bytes, sizeof(void*));
    void* alloc = ws->objectEnd;
    void* end = (BYTE*)alloc + roundedBytes;
 
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    /* over-reserve space */
    end = (BYTE *)end + 2 * ZSTD_CWKSP_ASAN_REDZONE_SIZE;
#endif
 
    DEBUGLOG(5,
        "cwksp: reserving %p object %zd bytes (rounded to %zd), %zd bytes remaining",
        alloc, bytes, roundedBytes, ZSTD_cwksp_available_space(ws) - roundedBytes);
    assert(((size_t)alloc & (sizeof(void*)-1)) == 0);
    assert((bytes & (sizeof(void*)-1)) == 0);
    ZSTD_cwksp_assert_internal_consistency(ws);
    /* we must be in the first phase, no advance is possible */
    if (ws->phase != ZSTD_cwksp_alloc_objects || end > ws->workspaceEnd) {
        DEBUGLOG(4, "cwksp: object alloc failed!");
        ws->allocFailed = 1;
        return NULL;
    }
    ws->objectEnd = end;
    ws->tableEnd = end;
    ws->tableValidEnd = end;
 
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    /* Move alloc so there's ZSTD_CWKSP_ASAN_REDZONE_SIZE unused space on
     * either size. */
    alloc = (BYTE *)alloc + ZSTD_CWKSP_ASAN_REDZONE_SIZE;
    __asan_unpoison_memory_region(alloc, bytes);
#endif
 
    return alloc;
}

Referenced by ZSTD_createCDict_advanced(), ZSTD_initCDict_internal(), ZSTD_initStaticCCtx(), ZSTD_initStaticCDict(), and ZSTD_resetCCtx_internal().

ZSTD_cwksp_reserve_table()

MEM_STATIC void * ZSTD_cwksp_reserve_table	(	ZSTD_cwksp *	ws,
		size_t	bytes
	)

Aligned on sizeof(unsigned). These buffers have the special property that their values remain constrained, allowing us to re-use them without memset()-ing them.

Definition at line 280 of file zstd_cwksp.h.

                                                                        {
    const ZSTD_cwksp_alloc_phase_e phase = ZSTD_cwksp_alloc_aligned;
    void* alloc = ws->tableEnd;
    void* end = (BYTE *)alloc + bytes;
    void* top = ws->allocStart;
 
    DEBUGLOG(5, "cwksp: reserving %p table %zd bytes, %zd bytes remaining",
        alloc, bytes, ZSTD_cwksp_available_space(ws) - bytes);
    assert((bytes & (sizeof(U32)-1)) == 0);
    ZSTD_cwksp_internal_advance_phase(ws, phase);
    ZSTD_cwksp_assert_internal_consistency(ws);
    assert(end <= top);
    if (end > top) {
        DEBUGLOG(4, "cwksp: table alloc failed!");
        ws->allocFailed = 1;
        return NULL;
    }
    ws->tableEnd = end;
 
#if defined (ADDRESS_SANITIZER) && !defined (ZSTD_ASAN_DONT_POISON_WORKSPACE)
    __asan_unpoison_memory_region(alloc, bytes);
#endif
 
    return alloc;
}

Referenced by ZSTD_reset_matchState().

ZSTD_cwksp_sizeof()

MEM_STATIC size_t ZSTD_cwksp_sizeof

(

const ZSTD_cwksp *

ws

)

Definition at line 482 of file zstd_cwksp.h.

                                                          {
    return (size_t)((BYTE*)ws->workspaceEnd - (BYTE*)ws->workspace);
}

Referenced by ZSTD_resetCCtx_internal(), ZSTD_sizeof_CCtx(), and ZSTD_sizeof_CDict().