/* Copyright (C) 2001-2023 Artifex Software, Inc.
   All Rights Reserved.

   This software is provided AS-IS with no warranty, either express or
   implied.

   This software is distributed under license and may not be copied,
   modified or distributed except as expressly authorized under the terms
   of the license contained in the file LICENSE in this distribution.

   Refer to licensing information at http://www.artifex.com or contact
   Artifex Software, Inc.,  39 Mesa Street, Suite 108A, San Francisco,
   CA 94129, USA, for further information.
*/


/* Retrying memory allocator */

#include "gx.h"
#include "gsmemret.h"
#include "gserrors.h"

/* Raw memory procedures */
static gs_memory_proc_alloc_bytes(gs_retrying_alloc_bytes_immovable);
static gs_memory_proc_resize_object(gs_retrying_resize_object);
static gs_memory_proc_free_object(gs_forward_free_object);
static gs_memory_proc_stable(gs_retrying_stable);
static gs_memory_proc_status(gs_forward_status);
static gs_memory_proc_free_all(gs_forward_free_all);
static gs_memory_proc_consolidate_free(gs_forward_consolidate_free);

/* Object memory procedures */
static gs_memory_proc_alloc_bytes(gs_retrying_alloc_bytes);
static gs_memory_proc_alloc_struct(gs_retrying_alloc_struct);
static gs_memory_proc_alloc_struct(gs_retrying_alloc_struct_immovable);
static gs_memory_proc_alloc_byte_array(gs_retrying_alloc_byte_array);
static gs_memory_proc_alloc_byte_array(gs_retrying_alloc_byte_array_immovable);
static gs_memory_proc_alloc_struct_array(gs_retrying_alloc_struct_array);
static gs_memory_proc_alloc_struct_array(gs_retrying_alloc_struct_array_immovable);
static gs_memory_proc_object_size(gs_forward_object_size);
static gs_memory_proc_object_type(gs_forward_object_type);
static gs_memory_proc_alloc_string(gs_retrying_alloc_string);
static gs_memory_proc_alloc_string(gs_retrying_alloc_string_immovable);
static gs_memory_proc_resize_string(gs_retrying_resize_string);
static gs_memory_proc_free_string(gs_forward_free_string);
static gs_memory_proc_register_root(gs_retrying_register_root);
static gs_memory_proc_unregister_root(gs_forward_unregister_root);
static gs_memory_proc_enable_free(gs_forward_enable_free);
static gs_memory_proc_set_object_type(gs_forward_set_object_type);
static gs_memory_proc_defer_frees(gs_forward_defer_frees);
static const gs_memory_procs_t retrying_procs = {
    /* Raw memory procedures */
    gs_retrying_alloc_bytes_immovable,
    gs_retrying_resize_object,
    gs_forward_free_object,
    gs_retrying_stable,
    gs_forward_status,
    gs_forward_free_all,
    gs_forward_consolidate_free,
    /* Object memory procedures */
    gs_retrying_alloc_bytes,
    gs_retrying_alloc_struct,
    gs_retrying_alloc_struct_immovable,
    gs_retrying_alloc_byte_array,
    gs_retrying_alloc_byte_array_immovable,
    gs_retrying_alloc_struct_array,
    gs_retrying_alloc_struct_array_immovable,
    gs_forward_object_size,
    gs_forward_object_type,
    gs_retrying_alloc_string,
    gs_retrying_alloc_string_immovable,
    gs_retrying_resize_string,
    gs_forward_free_string,
    gs_retrying_register_root,
    gs_forward_unregister_root,
    gs_forward_enable_free,
    gs_forward_set_object_type,
    gs_forward_defer_frees
};

/* Define a vacuous recovery procedure. */
static gs_memory_recover_status_t
no_recover_proc(gs_memory_retrying_t *rmem, void *proc_data)
{
    return RECOVER_STATUS_NO_RETRY;
}

/* ---------- Public constructors/destructors ---------- */

/* Initialize a gs_memory_retrying_t */
int				/* -ve error code or 0 */
gs_memory_retrying_init(
                      gs_memory_retrying_t * rmem,	/* allocator to init */
                      gs_memory_t * target	/* allocator to wrap */
)
{
    rmem->stable_memory = 0;
    rmem->procs = retrying_procs;
    rmem->target = target;
    rmem->gs_lib_ctx = target->gs_lib_ctx;
    rmem->non_gc_memory = (gs_memory_t *)rmem;				  /* WRONG: not necessarily non_gc since */
                                                                          /* the target may be GC memory */
    rmem->thread_safe_memory = (gs_memory_t *)target->thread_safe_memory; /* WRONG: this won't retry */
    gs_memory_retrying_set_recover(rmem, no_recover_proc, NULL);
    return 0;
}

/* Set the recovery closure of a retrying memory manager. */
void
gs_memory_retrying_set_recover(gs_memory_retrying_t *rmem,
                               gs_memory_recover_proc_t recover_proc,
                               void *recover_proc_data)
{
    rmem->recover_proc = recover_proc;
    rmem->recover_proc_data = recover_proc_data;
}

/* Release a retrying memory manager. */
/* Note that this has no effect on the target. */
void
gs_memory_retrying_release(gs_memory_retrying_t *rmem)
{
    gs_memory_free_all((gs_memory_t *)rmem, FREE_ALL_STRUCTURES,
                       "gs_memory_retrying_release");
}

/* ---------- Accessors ------------- */

/* Retrieve this allocator's target */
gs_memory_t *
gs_memory_retrying_target(const gs_memory_retrying_t *rmem)
{
    return rmem->target;
}

/* -------- Private members just wrap retrying around a gs_memory --- */

/*
 * Contrary to our usual practice, we don't use BEGIN/END here, because
 * that causes some compilers to give bogus error messages.
 */

#define DO_FORWARD(call_target)\
        gs_memory_retrying_t * const rmem = (gs_memory_retrying_t *)mem;\
        gs_memory_t *const target = rmem->target;\
\
        call_target

#define RETURN_RETRYING(result_type, call_target)\
        gs_memory_retrying_t * const rmem = (gs_memory_retrying_t *)mem;\
        gs_memory_t *const target = rmem->target;\
        result_type temp;\
        gs_memory_recover_status_t retry = RECOVER_STATUS_RETRY_OK;\
\
        for (;;) {\
            temp = call_target;\
            if (temp != 0 || retry != RECOVER_STATUS_RETRY_OK)\
                break;\
            retry = rmem->recover_proc(rmem, rmem->recover_proc_data);\
        }\
        return temp

/* Procedures */
static void
gs_forward_free_all(gs_memory_t * mem, uint free_mask, client_name_t cname)
{
    gs_memory_retrying_t * const rmem = (gs_memory_retrying_t *)mem;
    gs_memory_t * const target = rmem->target;

    /* Only free the structures and the allocator itself. */
    rmem->target = 0;
    if (free_mask & FREE_ALL_ALLOCATOR)
        gs_free_object(target, rmem, cname);
}
static void
gs_forward_consolidate_free(gs_memory_t * mem)
{
    DO_FORWARD(target->procs.consolidate_free(target));
}
static byte *
gs_retrying_alloc_bytes(gs_memory_t * mem, size_t size, client_name_t cname)
{
    RETURN_RETRYING(
                    byte *,
                    target->procs.alloc_bytes(target, size, cname)
                    );
}
static byte *
gs_retrying_alloc_bytes_immovable(gs_memory_t * mem, size_t size,
                                client_name_t cname)
{
    RETURN_RETRYING(
                    byte *,
                    target->procs.alloc_bytes_immovable(target, size, cname)
                    );
}
static void *
gs_retrying_alloc_struct(gs_memory_t * mem, gs_memory_type_ptr_t pstype,
                       client_name_t cname)
{
    RETURN_RETRYING(
                    void *,
                    target->procs.alloc_struct(target, pstype, cname)
                    );
}
static void *
gs_retrying_alloc_struct_immovable(gs_memory_t * mem,
                           gs_memory_type_ptr_t pstype, client_name_t cname)
{
    RETURN_RETRYING(
                    void *,
                    target->procs.alloc_struct_immovable(target, pstype, cname)
                    );
}
static byte *
gs_retrying_alloc_byte_array(gs_memory_t * mem, size_t num_elements, size_t elt_size,
                           client_name_t cname)
{
    RETURN_RETRYING(
                    byte *,
                    target->procs.alloc_byte_array(target, num_elements,
                                                   elt_size, cname)
                    );
}
static byte *
gs_retrying_alloc_byte_array_immovable(gs_memory_t * mem, size_t num_elements,
                                       size_t elt_size, client_name_t cname)
{
    RETURN_RETRYING(
                    byte *,
                    target->procs.alloc_byte_array_immovable(target,
                                                        num_elements, elt_size,
                                                        cname)
                    );
}
static void *
gs_retrying_alloc_struct_array(gs_memory_t * mem, size_t num_elements,
                               gs_memory_type_ptr_t pstype, client_name_t cname)
{
    RETURN_RETRYING(
                    void *,
                    target->procs.alloc_struct_array(target, num_elements,
                                                     pstype, cname)
                    );
}
static void *
gs_retrying_alloc_struct_array_immovable(gs_memory_t * mem, size_t num_elements,
                                         gs_memory_type_ptr_t pstype,
                                         client_name_t cname)
{
    RETURN_RETRYING(
                    void *,
                    target->procs.alloc_struct_array_immovable(target,
                                                               num_elements,
                                                               pstype,
                                                               cname)
                    );
}
static void *
gs_retrying_resize_object(gs_memory_t * mem, void *obj, size_t new_num_elements,
                          client_name_t cname)
{
    RETURN_RETRYING(
                    void *,
                    target->procs.resize_object(target, obj, new_num_elements,
                                                cname)
                    );
}
static size_t
gs_forward_object_size(gs_memory_t * mem, const void *ptr)
{
    DO_FORWARD(return target->procs.object_size(target, ptr));
}
static gs_memory_type_ptr_t
gs_forward_object_type(const gs_memory_t * mem, const void *ptr)
{
    DO_FORWARD(return target->procs.object_type(target, ptr));
}
static void
gs_forward_free_object(gs_memory_t * mem, void *ptr, client_name_t cname)
{
    DO_FORWARD(target->procs.free_object(target, ptr, cname));
}
static byte *
gs_retrying_alloc_string(gs_memory_t * mem, size_t nbytes, client_name_t cname)
{
    RETURN_RETRYING(
                    byte *,
                    target->procs.alloc_string(target, nbytes, cname)
                    );
}
static byte *
gs_retrying_alloc_string_immovable(gs_memory_t * mem, size_t nbytes,
                                 client_name_t cname)
{
    RETURN_RETRYING(
                    byte *,
                    target->procs.alloc_string_immovable(target, nbytes, cname)
                    );
}
static byte *
gs_retrying_resize_string(gs_memory_t * mem, byte * data, size_t old_num,
                          size_t new_num, client_name_t cname)
{
    RETURN_RETRYING(
                    byte *,
                    target->procs.resize_string(target, data, old_num, new_num,
                                                cname)
                    );
}
static void
gs_forward_free_string(gs_memory_t * mem, byte * data, size_t nbytes,
                      client_name_t cname)
{
    DO_FORWARD(target->procs.free_string(target, data, nbytes, cname));
}
static int
gs_retrying_register_root(gs_memory_t * mem, gs_gc_root_t ** rp,
                        gs_ptr_type_t ptype, void **up, client_name_t cname)
{
    RETURN_RETRYING(
                    int,
                    target->procs.register_root(target, rp, ptype, up, cname)
                    );
}
static void
gs_forward_unregister_root(gs_memory_t * mem, gs_gc_root_t * rp,
                          client_name_t cname)
{
    DO_FORWARD(target->procs.unregister_root(target, rp, cname));
}
static gs_memory_t *
gs_retrying_stable(gs_memory_t * mem)
{
    if (!mem->stable_memory) {
        gs_memory_retrying_t * const rmem = (gs_memory_retrying_t *)mem;
        gs_memory_t *stable = gs_memory_stable(rmem->target);

        if (stable == rmem->target)
            mem->stable_memory = mem;
        else {
            gs_memory_retrying_t *retrying_stable = (gs_memory_retrying_t *)
                gs_alloc_bytes(stable, sizeof(*rmem), "gs_retrying_stable");

            if (retrying_stable) {
                int code = gs_memory_retrying_init(retrying_stable, stable);

                if (code < 0)
                    gs_free_object(stable, retrying_stable, "gs_retrying_stable");
                else
                    mem->stable_memory = (gs_memory_t *)retrying_stable;
            }
        }
    }
    return mem->stable_memory;
}
static void
gs_forward_status(gs_memory_t * mem, gs_memory_status_t * pstat)
{
    DO_FORWARD(target->procs.status(target, pstat));
    /* Report NOT thread safe even though it _might_ be thread safe if the underlying */
    /* allocator is thread safe AND the 'recover' proc is thread safe, but we don't   */
    /* have any info on the recover proc's thread safety.                             */
    pstat->is_thread_safe = false;
}
static void
gs_forward_enable_free(gs_memory_t * mem, bool enable)
{
    DO_FORWARD(target->procs.enable_free(target, enable));
}

static void gs_forward_set_object_type(gs_memory_t *mem, void *ptr, gs_memory_type_ptr_t type)
{
    DO_FORWARD(target->procs.set_object_type(target, ptr, type));
}

static void gs_forward_defer_frees(gs_memory_t *mem, int defer)
{
    DO_FORWARD(target->procs.defer_frees(target, defer));
}
