src/vulkan/util/vk_alloc.h - third_party/mesa - Git at Google

 /*
  * Copyright © 2015 Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice (including the next
  * paragraph) shall be included in all copies or substantial portions of the
  * Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */
 #ifndef VK_ALLOC_H
 #define VK_ALLOC_H

 /* common allocation inlines for vulkan drivers */

 #include <stdio.h>
 #include <string.h>
 #include <vulkan/vulkan_core.h>

 #include "util/u_math.h"
 #include "util/macros.h"
 #include "util/u_printf.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

 const VkAllocationCallbacks *
 vk_default_allocator(void);

 static inline void *
 vk_alloc(const VkAllocationCallbacks *alloc,
          size_t size, size_t align,
          VkSystemAllocationScope scope)
 {
    return alloc->pfnAllocation(alloc->pUserData, size, align, scope);
 }

 static inline void *
 vk_zalloc(const VkAllocationCallbacks *alloc,
           size_t size, size_t align,
           VkSystemAllocationScope scope)
 {
    void *mem = vk_alloc(alloc, size, align, scope);
    if (mem == NULL)
       return NULL;

    memset(mem, 0, size);

    return mem;
 }

 static inline void *
 vk_realloc(const VkAllocationCallbacks *alloc,
            void *ptr, size_t size, size_t align,
            VkSystemAllocationScope scope)
 {
    return alloc->pfnReallocation(alloc->pUserData, ptr, size, align, scope);
 }

 static inline void
 vk_free(const VkAllocationCallbacks *alloc, void *data)
 {
    if (data == NULL)
       return;

    alloc->pfnFree(alloc->pUserData, data);
 }

 static inline char *
 vk_strdup(const VkAllocationCallbacks *alloc, const char *s,
           VkSystemAllocationScope scope)
 {
    if (s == NULL)
       return NULL;

    size_t size = strlen(s) + 1;
    char *copy = (char *)vk_alloc(alloc, size, 1, scope);
    if (copy == NULL)
       return NULL;

    memcpy(copy, s, size);

    return copy;
 }

 static inline char *
 vk_vasprintf(const VkAllocationCallbacks *alloc,
              VkSystemAllocationScope scope,
              const char *fmt, va_list args)
 {
    size_t size = u_printf_length(fmt, args) + 1;
    char *ptr = (char *)vk_alloc(alloc, size, 1, scope);
    if (ptr != NULL)
       vsnprintf(ptr, size, fmt, args);

    return ptr;
 }

 PRINTFLIKE(3, 4) static inline char *
 vk_asprintf(const VkAllocationCallbacks *alloc,
             VkSystemAllocationScope scope,
             const char *fmt, ...)
 {
    va_list args;
    va_start(args, fmt);
    char *ptr = vk_vasprintf(alloc, scope, fmt, args);
    va_end(args);

    return ptr;
 }

 static inline void *
 vk_alloc2(const VkAllocationCallbacks *parent_alloc,
           const VkAllocationCallbacks *alloc,
           size_t size, size_t align,
           VkSystemAllocationScope scope)
 {
    if (alloc)
       return vk_alloc(alloc, size, align, scope);
    else
       return vk_alloc(parent_alloc, size, align, scope);
 }

 static inline void *
 vk_zalloc2(const VkAllocationCallbacks *parent_alloc,
            const VkAllocationCallbacks *alloc,
            size_t size, size_t align,
            VkSystemAllocationScope scope)
 {
    void *mem = vk_alloc2(parent_alloc, alloc, size, align, scope);
    if (mem == NULL)
       return NULL;

    memset(mem, 0, size);

    return mem;
 }

 static inline void *
 vk_realloc2(const VkAllocationCallbacks *parent_alloc,
             const VkAllocationCallbacks *alloc,
             void *ptr, size_t size, size_t align,
             VkSystemAllocationScope scope)
 {
    if (alloc)
       return vk_realloc(alloc, ptr, size, align, scope);
    else
       return vk_realloc(parent_alloc, ptr, size, align, scope);
 }

 static inline void
 vk_free2(const VkAllocationCallbacks *parent_alloc,
          const VkAllocationCallbacks *alloc,
          void *data)
 {
    if (alloc)
       vk_free(alloc, data);
    else
       vk_free(parent_alloc, data);
 }

 /* A multi-pointer allocator
  *
  * When copying data structures from the user (such as a render pass), it's
  * common to need to allocate data for a bunch of different things.  Instead
  * of doing several allocations and having to handle all of the error checking
  * that entails, it can be easier to do a single allocation.  This struct
  * helps facilitate that.  The intended usage looks like this:
  *
  *    VK_MULTIALLOC(ma)
  *    vk_multialloc_add(&ma, &main_ptr, 1);
  *    vk_multialloc_add(&ma, &substruct1, substruct1Count);
  *    vk_multialloc_add(&ma, &substruct2, substruct2Count);
  *
  *    if (!vk_multialloc_alloc(&ma, pAllocator, VK_ALLOCATION_SCOPE_FOO))
  *       return vk_error(VK_ERROR_OUT_OF_HOST_MEORY);
  */
 struct vk_multialloc {
     size_t size;
     size_t align;

     uint32_t ptr_count;
     void **ptrs[16];
 };

 #define VK_MULTIALLOC(_name) \
    struct vk_multialloc _name = { .align = 1 }

 static ALWAYS_INLINE void
 vk_multialloc_add_size_align(struct vk_multialloc *ma,
                              void **ptr, size_t size, size_t align)
 {
    assert(util_is_power_of_two_nonzero_uintptr(align));
    if (size == 0) {
       *ptr = NULL;
       return;
    }

    size_t offset = ALIGN_POT(ma->size, align);
    ma->size = offset + size;
    ma->align = MAX2(ma->align, align);

    /* Store the offset in the pointer. */
    *ptr = (void *)(uintptr_t)offset;

    assert(ma->ptr_count < ARRAY_SIZE(ma->ptrs));
    ma->ptrs[ma->ptr_count++] = ptr;
 }

 #define vk_multialloc_add_size(_ma, _ptr, _type, _size) \
    do { \
       _type **_tmp = (_ptr); \
       (void)_tmp; \
       vk_multialloc_add_size_align((_ma), (void **)(_ptr), \
                                    (_size), alignof(_type)); \
    } while(0)

 #define vk_multialloc_add(_ma, _ptr, _type, _count) \
    vk_multialloc_add_size(_ma, _ptr, _type, (_count) * sizeof(**(_ptr)));

 #define VK_MULTIALLOC_DECL_SIZE(_ma, _type, _name, _size) \
    _type *_name; \
    vk_multialloc_add_size(_ma, &_name, _type, _size);

 #define VK_MULTIALLOC_DECL(_ma, _type, _name, _count) \
    VK_MULTIALLOC_DECL_SIZE(_ma, _type, _name, (_count) * sizeof(_type));

 static ALWAYS_INLINE void *
 vk_multialloc_alloc(struct vk_multialloc *ma,
                     const VkAllocationCallbacks *alloc,
                     VkSystemAllocationScope scope)
 {
    void *ptr = vk_alloc(alloc, ma->size, ma->align, scope);
    if (!ptr)
       return NULL;

    /* Fill out each of the pointers with their final value.
     *
     *   for (uint32_t i = 0; i < ma->ptr_count; i++)
     *      *ma->ptrs[i] = ptr + (uintptr_t)*ma->ptrs[i];
     *
     * Unfortunately, even though ma->ptr_count is basically guaranteed to be a
     * constant, GCC is incapable of figuring this out and unrolling the loop
     * so we have to give it a little help.
     */
    STATIC_ASSERT(ARRAY_SIZE(ma->ptrs) == 16);
 #define _VK_MULTIALLOC_UPDATE_POINTER(_i) \
    if ((_i) < ma->ptr_count) \
       *ma->ptrs[_i] = (char *)ptr + (uintptr_t)*ma->ptrs[_i]
    _VK_MULTIALLOC_UPDATE_POINTER(0);
    _VK_MULTIALLOC_UPDATE_POINTER(1);
    _VK_MULTIALLOC_UPDATE_POINTER(2);
    _VK_MULTIALLOC_UPDATE_POINTER(3);
    _VK_MULTIALLOC_UPDATE_POINTER(4);
    _VK_MULTIALLOC_UPDATE_POINTER(5);
    _VK_MULTIALLOC_UPDATE_POINTER(6);
    _VK_MULTIALLOC_UPDATE_POINTER(7);
    _VK_MULTIALLOC_UPDATE_POINTER(8);
    _VK_MULTIALLOC_UPDATE_POINTER(9);
    _VK_MULTIALLOC_UPDATE_POINTER(10);
    _VK_MULTIALLOC_UPDATE_POINTER(11);
    _VK_MULTIALLOC_UPDATE_POINTER(12);
    _VK_MULTIALLOC_UPDATE_POINTER(13);
    _VK_MULTIALLOC_UPDATE_POINTER(14);
    _VK_MULTIALLOC_UPDATE_POINTER(15);
 #undef _VK_MULTIALLOC_UPDATE_POINTER

    return ptr;
 }

 static ALWAYS_INLINE void *
 vk_multialloc_alloc2(struct vk_multialloc *ma,
                      const VkAllocationCallbacks *parent_alloc,
                      const VkAllocationCallbacks *alloc,
                      VkSystemAllocationScope scope)
 {
    return vk_multialloc_alloc(ma, alloc ? alloc : parent_alloc, scope);
 }

 static ALWAYS_INLINE void *
 vk_multialloc_zalloc(struct vk_multialloc *ma,
                      const VkAllocationCallbacks *alloc,
                      VkSystemAllocationScope scope)
 {
    void *ptr = vk_multialloc_alloc(ma, alloc, scope);

    if (ptr == NULL)
       return NULL;

    memset(ptr, 0, ma->size);

    return ptr;
 }

 static ALWAYS_INLINE void *
 vk_multialloc_zalloc2(struct vk_multialloc *ma,
                       const VkAllocationCallbacks *parent_alloc,
                       const VkAllocationCallbacks *alloc,
                       VkSystemAllocationScope scope)
 {
    return vk_multialloc_zalloc(ma, alloc ? alloc : parent_alloc, scope);
 }

 #ifdef __cplusplus
 }
 #endif

 #endif
	/*
	* Copyright © 2015 Intel Corporation
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice (including the next
	* paragraph) shall be included in all copies or substantial portions of the
	* Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
	* IN THE SOFTWARE.
	*/
	#ifndef VK_ALLOC_H
	#define VK_ALLOC_H

	/* common allocation inlines for vulkan drivers */

	#include <stdio.h>
	#include <string.h>
	#include <vulkan/vulkan_core.h>

	#include "util/u_math.h"
	#include "util/macros.h"
	#include "util/u_printf.h"

	#ifdef __cplusplus
	extern "C" {
	#endif

	const VkAllocationCallbacks *
	vk_default_allocator(void);

	static inline void *
	vk_alloc(const VkAllocationCallbacks *alloc,
	size_t size, size_t align,
	VkSystemAllocationScope scope)
	{
	return alloc->pfnAllocation(alloc->pUserData, size, align, scope);
	}

	static inline void *
	vk_zalloc(const VkAllocationCallbacks *alloc,
	size_t size, size_t align,
	VkSystemAllocationScope scope)
	{
	void *mem = vk_alloc(alloc, size, align, scope);
	if (mem == NULL)
	return NULL;

	memset(mem, 0, size);

	return mem;
	}

	static inline void *
	vk_realloc(const VkAllocationCallbacks *alloc,
	void *ptr, size_t size, size_t align,
	VkSystemAllocationScope scope)
	{
	return alloc->pfnReallocation(alloc->pUserData, ptr, size, align, scope);
	}

	static inline void
	vk_free(const VkAllocationCallbacks alloc, void data)
	{
	if (data == NULL)
	return;

	alloc->pfnFree(alloc->pUserData, data);
	}

	static inline char *
	vk_strdup(const VkAllocationCallbacks alloc, const char s,
	VkSystemAllocationScope scope)
	{
	if (s == NULL)
	return NULL;

	size_t size = strlen(s) + 1;
	char copy = (char )vk_alloc(alloc, size, 1, scope);
	if (copy == NULL)
	return NULL;

	memcpy(copy, s, size);

	return copy;
	}

	static inline char *
	vk_vasprintf(const VkAllocationCallbacks *alloc,
	VkSystemAllocationScope scope,
	const char *fmt, va_list args)
	{
	size_t size = u_printf_length(fmt, args) + 1;
	char ptr = (char )vk_alloc(alloc, size, 1, scope);
	if (ptr != NULL)
	vsnprintf(ptr, size, fmt, args);

	return ptr;
	}

	PRINTFLIKE(3, 4) static inline char *
	vk_asprintf(const VkAllocationCallbacks *alloc,
	VkSystemAllocationScope scope,
	const char *fmt, ...)
	{
	va_list args;
	va_start(args, fmt);
	char *ptr = vk_vasprintf(alloc, scope, fmt, args);
	va_end(args);

	return ptr;
	}

	static inline void *
	vk_alloc2(const VkAllocationCallbacks *parent_alloc,
	const VkAllocationCallbacks *alloc,
	size_t size, size_t align,
	VkSystemAllocationScope scope)
	{
	if (alloc)
	return vk_alloc(alloc, size, align, scope);
	else
	return vk_alloc(parent_alloc, size, align, scope);
	}

	static inline void *
	vk_zalloc2(const VkAllocationCallbacks *parent_alloc,
	const VkAllocationCallbacks *alloc,
	size_t size, size_t align,
	VkSystemAllocationScope scope)
	{
	void *mem = vk_alloc2(parent_alloc, alloc, size, align, scope);
	if (mem == NULL)
	return NULL;

	memset(mem, 0, size);

	return mem;
	}

	static inline void *
	vk_realloc2(const VkAllocationCallbacks *parent_alloc,
	const VkAllocationCallbacks *alloc,
	void *ptr, size_t size, size_t align,
	VkSystemAllocationScope scope)
	{
	if (alloc)
	return vk_realloc(alloc, ptr, size, align, scope);
	else
	return vk_realloc(parent_alloc, ptr, size, align, scope);
	}

	static inline void
	vk_free2(const VkAllocationCallbacks *parent_alloc,
	const VkAllocationCallbacks *alloc,
	void *data)
	{
	if (alloc)
	vk_free(alloc, data);
	else
	vk_free(parent_alloc, data);
	}

	/* A multi-pointer allocator
	*
	* When copying data structures from the user (such as a render pass), it's
	* common to need to allocate data for a bunch of different things. Instead
	* of doing several allocations and having to handle all of the error checking
	* that entails, it can be easier to do a single allocation. This struct
	* helps facilitate that. The intended usage looks like this:
	*
	* VK_MULTIALLOC(ma)
	* vk_multialloc_add(&ma, &main_ptr, 1);
	* vk_multialloc_add(&ma, &substruct1, substruct1Count);
	* vk_multialloc_add(&ma, &substruct2, substruct2Count);
	*
	* if (!vk_multialloc_alloc(&ma, pAllocator, VK_ALLOCATION_SCOPE_FOO))
	* return vk_error(VK_ERROR_OUT_OF_HOST_MEORY);
	*/
	struct vk_multialloc {
	size_t size;
	size_t align;

	uint32_t ptr_count;
	void **ptrs[16];
	};

	#define VK_MULTIALLOC(_name) \
	struct vk_multialloc _name = { .align = 1 }

	static ALWAYS_INLINE void
	vk_multialloc_add_size_align(struct vk_multialloc *ma,
	void **ptr, size_t size, size_t align)
	{
	assert(util_is_power_of_two_nonzero_uintptr(align));
	if (size == 0) {
	*ptr = NULL;
	return;
	}

	size_t offset = ALIGN_POT(ma->size, align);
	ma->size = offset + size;
	ma->align = MAX2(ma->align, align);

	/* Store the offset in the pointer. */
	ptr = (void )(uintptr_t)offset;

	assert(ma->ptr_count < ARRAY_SIZE(ma->ptrs));
	ma->ptrs[ma->ptr_count++] = ptr;
	}

	#define vk_multialloc_add_size(_ma, _ptr, _type, _size) \
	do { \
	_type **_tmp = (_ptr); \
	(void)_tmp; \
	vk_multialloc_add_size_align((_ma), (void **)(_ptr), \
	(_size), alignof(_type)); \
	} while(0)

	#define vk_multialloc_add(_ma, _ptr, _type, _count) \
	vk_multialloc_add_size(_ma, _ptr, _type, (_count) * sizeof(**(_ptr)));

	#define VK_MULTIALLOC_DECL_SIZE(_ma, _type, _name, _size) \
	_type *_name; \
	vk_multialloc_add_size(_ma, &_name, _type, _size);

	#define VK_MULTIALLOC_DECL(_ma, _type, _name, _count) \
	VK_MULTIALLOC_DECL_SIZE(_ma, _type, _name, (_count) * sizeof(_type));

	static ALWAYS_INLINE void *
	vk_multialloc_alloc(struct vk_multialloc *ma,
	const VkAllocationCallbacks *alloc,
	VkSystemAllocationScope scope)
	{
	void *ptr = vk_alloc(alloc, ma->size, ma->align, scope);
	if (!ptr)
	return NULL;

	/* Fill out each of the pointers with their final value.
	*
	* for (uint32_t i = 0; i < ma->ptr_count; i++)
	* ma->ptrs[i] = ptr + (uintptr_t)ma->ptrs[i];
	*
	* Unfortunately, even though ma->ptr_count is basically guaranteed to be a
	* constant, GCC is incapable of figuring this out and unrolling the loop
	* so we have to give it a little help.
	*/
	STATIC_ASSERT(ARRAY_SIZE(ma->ptrs) == 16);
	#define _VK_MULTIALLOC_UPDATE_POINTER(_i) \
	if ((_i) < ma->ptr_count) \
	ma->ptrs[_i] = (char )ptr + (uintptr_t)*ma->ptrs[_i]
	_VK_MULTIALLOC_UPDATE_POINTER(0);
	_VK_MULTIALLOC_UPDATE_POINTER(1);
	_VK_MULTIALLOC_UPDATE_POINTER(2);
	_VK_MULTIALLOC_UPDATE_POINTER(3);
	_VK_MULTIALLOC_UPDATE_POINTER(4);
	_VK_MULTIALLOC_UPDATE_POINTER(5);
	_VK_MULTIALLOC_UPDATE_POINTER(6);
	_VK_MULTIALLOC_UPDATE_POINTER(7);
	_VK_MULTIALLOC_UPDATE_POINTER(8);
	_VK_MULTIALLOC_UPDATE_POINTER(9);
	_VK_MULTIALLOC_UPDATE_POINTER(10);
	_VK_MULTIALLOC_UPDATE_POINTER(11);
	_VK_MULTIALLOC_UPDATE_POINTER(12);
	_VK_MULTIALLOC_UPDATE_POINTER(13);
	_VK_MULTIALLOC_UPDATE_POINTER(14);
	_VK_MULTIALLOC_UPDATE_POINTER(15);
	#undef _VK_MULTIALLOC_UPDATE_POINTER

	return ptr;
	}

	static ALWAYS_INLINE void *
	vk_multialloc_alloc2(struct vk_multialloc *ma,
	const VkAllocationCallbacks *parent_alloc,
	const VkAllocationCallbacks *alloc,
	VkSystemAllocationScope scope)
	{
	return vk_multialloc_alloc(ma, alloc ? alloc : parent_alloc, scope);
	}

	static ALWAYS_INLINE void *
	vk_multialloc_zalloc(struct vk_multialloc *ma,
	const VkAllocationCallbacks *alloc,
	VkSystemAllocationScope scope)
	{
	void *ptr = vk_multialloc_alloc(ma, alloc, scope);

	if (ptr == NULL)
	return NULL;

	memset(ptr, 0, ma->size);

	return ptr;
	}

	static ALWAYS_INLINE void *
	vk_multialloc_zalloc2(struct vk_multialloc *ma,
	const VkAllocationCallbacks *parent_alloc,
	const VkAllocationCallbacks *alloc,
	VkSystemAllocationScope scope)
	{
	return vk_multialloc_zalloc(ma, alloc ? alloc : parent_alloc, scope);
	}

	#ifdef __cplusplus
	}
	#endif

	#endif