VkImage image;
VkImageLayout imageLayout;
- uint32_t num_mem;
- VkDeviceMemory *mem;
+ VkDeviceMemory mem;
VkImageView view;
int32_t tex_width, tex_height;
};
VkFormat format;
VkImage image;
- uint32_t num_mem;
- VkDeviceMemory *mem;
+ VkDeviceMemory mem;
VkDepthStencilView view;
} depth;
struct {
VkBuffer buf;
- uint32_t num_mem;
- VkDeviceMemory *mem;
+ VkDeviceMemory mem;
VkBufferView view;
VkBufferViewAttachInfo attach;
} uniform_data;
mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, (float)degreesToRadians(demo->spin_angle));
mat4x4_mul(MVP, VP, demo->model_matrix);
- assert(demo->uniform_data.num_mem == 1);
- err = vkMapMemory(demo->device, demo->uniform_data.mem[0], 0, 0, 0, (void **) &pData);
+ err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, 0, 0, (void **) &pData);
assert(!err);
memcpy(pData, (const void*) &MVP[0][0], matrixSize);
- err = vkUnmapMemory(demo->device, demo->uniform_data.mem[0]);
+ err = vkUnmapMemory(demo->device, demo->uniform_data.mem);
assert(!err);
}
.flags = 0,
};
- VkMemoryRequirements *mem_reqs;
+ VkMemoryRequirements mem_reqs;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
VkResult U_ASSERT_ONLY err;
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
demo->depth.format = depth_format;
err = vkGetObjectInfo(demo->device,
VK_OBJECT_TYPE_IMAGE, demo->depth.image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- assert(!err && num_alloc_size == sizeof(num_allocations));
- mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements));
- demo->depth.mem = malloc(num_allocations * sizeof(VkDeviceMemory));
- demo->depth.num_mem = num_allocations;
- err = vkGetObjectInfo(demo->device,
- VK_OBJECT_TYPE_IMAGE, demo->depth.image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
- &mem_reqs_size, mem_reqs);
- assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements));
- for (uint32_t i = 0; i < num_allocations; i ++) {
- mem_alloc.allocationSize = mem_reqs[i].size;
-
- /* allocate memory */
- err = vkAllocMemory(demo->device, &mem_alloc,
- &(demo->depth.mem[i]));
- assert(!err);
+ &mem_reqs_size, &mem_reqs);
+ mem_alloc.allocationSize = mem_reqs.size;
- /* bind memory */
- err = vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_IMAGE, demo->depth.image,
- i, demo->depth.mem[i], 0);
- assert(!err);
- }
+ /* allocate memory */
+ err = vkAllocMemory(demo->device, &mem_alloc, &demo->depth.mem);
+ assert(!err);
+
+ /* bind memory */
+ err = vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_IMAGE, demo->depth.image,
+ demo->depth.mem, 0);
+ assert(!err);
demo_set_image_layout(demo, demo->depth.image,
VK_IMAGE_LAYOUT_UNDEFINED,
.memPriority = VK_MEMORY_PRIORITY_NORMAL,
};
- VkMemoryRequirements *mem_reqs;
+ VkMemoryRequirements mem_reqs;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
err = vkCreateImage(demo->device, &image_create_info,
&tex_obj->image);
err = vkGetObjectInfo(demo->device,
VK_OBJECT_TYPE_IMAGE, tex_obj->image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- assert(!err && num_alloc_size == sizeof(num_allocations));
- mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements));
- tex_obj->mem = malloc(num_allocations * sizeof(VkDeviceMemory));
- err = vkGetObjectInfo(demo->device,
- VK_OBJECT_TYPE_IMAGE, tex_obj->image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
- &mem_reqs_size, mem_reqs);
- assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements));
- for (uint32_t j = 0; j < num_allocations; j ++) {
- mem_alloc.allocationSize = mem_reqs[j].size;
-
- /* allocate memory */
- err = vkAllocMemory(demo->device, &mem_alloc,
- &(tex_obj->mem[j]));
- assert(!err);
+ &mem_reqs_size, &mem_reqs);
+ assert(!err && mem_reqs_size == sizeof(VkMemoryRequirements));
- /* bind memory */
- err = vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_IMAGE, tex_obj->image,
- j, tex_obj->mem[j], 0);
- assert(!err);
- }
- free(mem_reqs);
- mem_reqs = NULL;
+ mem_alloc.allocationSize = mem_reqs.size;
+
+ /* allocate memory */
+ err = vkAllocMemory(demo->device, &mem_alloc,
+ &(tex_obj->mem));
+ assert(!err);
- tex_obj->num_mem = num_allocations;
+ /* bind memory */
+ err = vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_IMAGE, tex_obj->image,
+ tex_obj->mem, 0);
+ assert(!err);
if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
const VkImageSubresource subres = {
VK_SUBRESOURCE_INFO_TYPE_LAYOUT,
&layout_size, &layout);
assert(!err && layout_size == sizeof(layout));
- /* Linear texture must be within a single memory object */
- assert(num_allocations == 1);
- err = vkMapMemory(demo->device, tex_obj->mem[0], 0, 0, 0, &data);
+ err = vkMapMemory(demo->device, tex_obj->mem, 0, 0, 0, &data);
assert(!err);
if (!loadTexture(filename, data, &layout, &tex_width, &tex_height)) {
fprintf(stderr, "Error loading texture: %s\n", filename);
}
- err = vkUnmapMemory(demo->device, tex_obj->mem[0]);
+ err = vkUnmapMemory(demo->device, tex_obj->mem);
assert(!err);
}
static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_objs)
{
/* clean up staging resources */
- for (uint32_t j = 0; j < tex_objs->num_mem; j ++) {
- vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_IMAGE, tex_objs->image, j, VK_NULL_HANDLE, 0);
- vkFreeMemory(demo->device, tex_objs->mem[j]);
- }
+ vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_IMAGE, tex_objs->image, VK_NULL_HANDLE, 0);
+ vkFreeMemory(demo->device, tex_objs->mem);
- free(tex_objs->mem);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, tex_objs->image);
}
.memProps = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
.memPriority = VK_MEMORY_PRIORITY_NORMAL,
};
- VkMemoryRequirements *mem_reqs;
+ VkMemoryRequirements mem_reqs;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
uint8_t *pData;
int i;
mat4x4 MVP, VP;
assert(!err);
err = vkGetObjectInfo(demo->device,
- VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- assert(!err && num_alloc_size == sizeof(num_allocations));
- mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements));
- demo->uniform_data.mem = malloc(num_allocations * sizeof(VkDeviceMemory));
- demo->uniform_data.num_mem = num_allocations;
- err = vkGetObjectInfo(demo->device,
VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
- &mem_reqs_size, mem_reqs);
- assert(!err && mem_reqs_size == num_allocations * sizeof(*mem_reqs));
- for (uint32_t i = 0; i < num_allocations; i ++) {
- alloc_info.allocationSize = mem_reqs[i].size;
+ &mem_reqs_size, &mem_reqs);
+ assert(!err && mem_reqs_size == sizeof(mem_reqs));
- err = vkAllocMemory(demo->device, &alloc_info, &(demo->uniform_data.mem[i]));
- assert(!err);
+ alloc_info.allocationSize = mem_reqs.size;
- err = vkMapMemory(demo->device, demo->uniform_data.mem[i], 0, 0, 0, (void **) &pData);
- assert(!err);
+ err = vkAllocMemory(demo->device, &alloc_info, &(demo->uniform_data.mem));
+ assert(!err);
- memcpy(pData, &data, sizeof data);
+ err = vkMapMemory(demo->device, demo->uniform_data.mem, 0, 0, 0, (void **) &pData);
+ assert(!err);
- err = vkUnmapMemory(demo->device, demo->uniform_data.mem[i]);
- assert(!err);
+ memcpy(pData, &data, sizeof data);
- err = vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf,
- i, demo->uniform_data.mem[i], 0);
- assert(!err);
- }
+ err = vkUnmapMemory(demo->device, demo->uniform_data.mem);
+ assert(!err);
+
+ err = vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf,
+ demo->uniform_data.mem, 0);
+ assert(!err);
memset(&view_info, 0, sizeof(view_info));
view_info.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
static void demo_cleanup(struct demo *demo)
{
- uint32_t i, j;
+ uint32_t i;
demo->prepared = false;
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE_VIEW, demo->textures[i].view);
- vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image, 0, VK_NULL_HANDLE, 0);
+ vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image, VK_NULL_HANDLE, 0);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image);
- for (j = 0; j < demo->textures[i].num_mem; j++)
- vkFreeMemory(demo->device, demo->textures[i].mem[j]);
- free(demo->textures[i].mem);
+ vkFreeMemory(demo->device, demo->textures[i].mem);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_SAMPLER, demo->textures[i].sampler);
}
vkDestroySwapChainWSI(demo->swap_chain);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, demo->depth.view);
- vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image, 0, VK_NULL_HANDLE, 0);
+ vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image, VK_NULL_HANDLE, 0);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image);
- for (j = 0; j < demo->depth.num_mem; j++) {
- vkFreeMemory(demo->device, demo->depth.mem[j]);
- }
+ vkFreeMemory(demo->device, demo->depth.mem);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER_VIEW, demo->uniform_data.view);
- vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf, 0, VK_NULL_HANDLE, 0);
+ vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf, VK_NULL_HANDLE, 0);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER, demo->uniform_data.buf);
- for (j = 0; j < demo->uniform_data.num_mem; j++)
- vkFreeMemory(demo->device, demo->uniform_data.mem[j]);
+ vkFreeMemory(demo->device, demo->uniform_data.mem);
for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
vkDestroyObject(demo->device, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, demo->buffers[i].view);
VkImage image;
VkImageLayout imageLayout;
- uint32_t num_mem;
- VkDeviceMemory *mem;
+ VkDeviceMemory mem;
VkImageView view;
int32_t tex_width, tex_height;
};
VkFormat format;
VkImage image;
- uint32_t num_mem;
- VkDeviceMemory *mem;
+ VkDeviceMemory mem;
VkDepthStencilView view;
} depth;
struct {
VkBuffer buf;
- uint32_t num_mem;
- VkDeviceMemory *mem;
+ VkDeviceMemory mem;
VkPipelineVertexInputCreateInfo vi;
VkVertexInputBindingDescription vi_bindings[1];
.flags = 0,
};
- VkMemoryRequirements *mem_reqs;
+ VkMemoryRequirements mem_reqs;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
VkResult U_ASSERT_ONLY err;
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
demo->depth.format = depth_format;
err = vkGetObjectInfo(demo->device,
VK_OBJECT_TYPE_IMAGE, demo->depth.image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- assert(!err && num_alloc_size == sizeof(num_allocations));
- mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements));
- demo->depth.mem = malloc(num_allocations * sizeof(VkDeviceMemory));
- demo->depth.num_mem = num_allocations;
- err = vkGetObjectInfo(demo->device,
- VK_OBJECT_TYPE_IMAGE, demo->depth.image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
- &mem_reqs_size, mem_reqs);
- assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements));
- for (uint32_t i = 0; i < num_allocations; i ++) {
- mem_alloc.allocationSize = mem_reqs[i].size;
-
- /* allocate memory */
- err = vkAllocMemory(demo->device, &mem_alloc,
- &(demo->depth.mem[i]));
- assert(!err);
+ &mem_reqs_size, &mem_reqs);
+ mem_alloc.allocationSize = mem_reqs.size;
- /* bind memory */
- err = vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_IMAGE, demo->depth.image,
- i, demo->depth.mem[i], 0);
- assert(!err);
- }
+ /* allocate memory */
+ err = vkAllocMemory(demo->device, &mem_alloc, &demo->depth.mem);
+ assert(!err);
+
+ /* bind memory */
+ err = vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_IMAGE, demo->depth.image,
+ demo->depth.mem, 0);
+ assert(!err);
demo_set_image_layout(demo, demo->depth.image,
VK_IMAGE_LAYOUT_UNDEFINED,
.memPriority = VK_MEMORY_PRIORITY_NORMAL,
};
- VkMemoryRequirements *mem_reqs;
+ VkMemoryRequirements mem_reqs;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
err = vkCreateImage(demo->device, &image_create_info,
&tex_obj->image);
err = vkGetObjectInfo(demo->device,
VK_OBJECT_TYPE_IMAGE, tex_obj->image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- assert(!err && num_alloc_size == sizeof(num_allocations));
- mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements));
- tex_obj->mem = malloc(num_allocations * sizeof(VkDeviceMemory));
- err = vkGetObjectInfo(demo->device,
- VK_OBJECT_TYPE_IMAGE, tex_obj->image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
- &mem_reqs_size, mem_reqs);
- assert(!err && mem_reqs_size == num_allocations * sizeof(VkMemoryRequirements));
- for (uint32_t j = 0; j < num_allocations; j ++) {
- mem_alloc.allocationSize = mem_reqs[j].size;
-
- /* allocate memory */
- err = vkAllocMemory(demo->device, &mem_alloc,
- &(tex_obj->mem[j]));
- assert(!err);
+ &mem_reqs_size, &mem_reqs);
+ mem_alloc.allocationSize = mem_reqs.size;
- /* bind memory */
- err = vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_IMAGE, tex_obj->image,
- j, tex_obj->mem[j], 0);
- assert(!err);
- }
- free(mem_reqs);
- mem_reqs = NULL;
+ /* allocate memory */
+ err = vkAllocMemory(demo->device, &mem_alloc, &tex_obj->mem);
+ assert(!err);
- tex_obj->num_mem = num_allocations;
+ /* bind memory */
+ err = vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_IMAGE, tex_obj->image,
+ tex_obj->mem, 0);
+ assert(!err);
if (mem_props & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) {
const VkImageSubresource subres = {
VK_SUBRESOURCE_INFO_TYPE_LAYOUT,
&layout_size, &layout);
assert(!err && layout_size == sizeof(layout));
- /* Linear texture must be within a single memory object */
- assert(num_allocations == 1);
- err = vkMapMemory(demo->device, tex_obj->mem[0], 0, 0, 0, &data);
+ err = vkMapMemory(demo->device, tex_obj->mem, 0, 0, 0, &data);
assert(!err);
for (y = 0; y < tex_height; y++) {
row[x] = tex_colors[(x & 1) ^ (y & 1)];
}
- err = vkUnmapMemory(demo->device, tex_obj->mem[0]);
+ err = vkUnmapMemory(demo->device, tex_obj->mem);
assert(!err);
}
static void demo_destroy_texture_image(struct demo *demo, struct texture_object *tex_obj)
{
/* clean up staging resources */
- for (uint32_t j = 0; j < tex_obj->num_mem; j ++) {
- vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_IMAGE, tex_obj->image, j, VK_NULL_HANDLE, 0);
- vkFreeMemory(demo->device, tex_obj->mem[j]);
- }
+ vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_IMAGE, tex_obj->image, VK_NULL_HANDLE, 0);
+ vkFreeMemory(demo->device, tex_obj->mem);
- free(tex_obj->mem);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, tex_obj->image);
}
.memProps = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
.memPriority = VK_MEMORY_PRIORITY_NORMAL,
};
- VkMemoryRequirements *mem_reqs;
+ VkMemoryRequirements mem_reqs;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
VkResult U_ASSERT_ONLY err;
void *data;
assert(!err);
err = vkGetObjectInfo(demo->device,
- VK_OBJECT_TYPE_BUFFER, demo->vertices.buf,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- assert(!err && num_alloc_size == sizeof(num_allocations));
- mem_reqs = malloc(num_allocations * sizeof(VkMemoryRequirements));
- demo->vertices.mem = malloc(num_allocations * sizeof(VkDeviceMemory));
- demo->vertices.num_mem = num_allocations;
- err = vkGetObjectInfo(demo->device,
VK_OBJECT_TYPE_BUFFER, demo->vertices.buf,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
- &mem_reqs_size, mem_reqs);
- assert(!err && mem_reqs_size == sizeof(*mem_reqs));
- for (uint32_t i = 0; i < num_allocations; i ++) {
- mem_alloc.allocationSize = mem_reqs[i].size;
+ &mem_reqs_size, &mem_reqs);
- err = vkAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem[i]);
- assert(!err);
+ mem_alloc.allocationSize = mem_reqs.size;
- err = vkMapMemory(demo->device, demo->vertices.mem[i], 0, 0, 0, &data);
- assert(!err);
+ err = vkAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
+ assert(!err);
- memcpy(data, vb, sizeof(vb));
+ err = vkMapMemory(demo->device, demo->vertices.mem, 0, 0, 0, &data);
+ assert(!err);
- err = vkUnmapMemory(demo->device, demo->vertices.mem[i]);
- assert(!err);
+ memcpy(data, vb, sizeof(vb));
- err = vkBindObjectMemory(demo->device,
- VK_OBJECT_TYPE_BUFFER, demo->vertices.buf,
- i, demo->vertices.mem[i], 0);
- assert(!err);
- }
+ err = vkUnmapMemory(demo->device, demo->vertices.mem);
+ assert(!err);
+
+ err = vkBindObjectMemory(demo->device,
+ VK_OBJECT_TYPE_BUFFER, demo->vertices.buf,
+ demo->vertices.mem, 0);
+ assert(!err);
demo->vertices.vi.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
demo->vertices.vi.pNext = NULL;
static void demo_cleanup(struct demo *demo)
{
- uint32_t i, j;
+ uint32_t i;
vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET, demo->desc_set);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_POOL, demo->desc_pool);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_PIPELINE_LAYOUT, demo->pipeline_layout);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, demo->desc_layout);
- vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_BUFFER, demo->vertices.buf, 0, VK_NULL_HANDLE, 0);
+ vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_BUFFER, demo->vertices.buf, VK_NULL_HANDLE, 0);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_BUFFER, demo->vertices.buf);
- for (j = 0; j < demo->vertices.num_mem; j++)
- vkFreeMemory(demo->device, demo->vertices.mem[j]);
+ vkFreeMemory(demo->device, demo->vertices.mem);
for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE_VIEW, demo->textures[i].view);
- vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image, 0, VK_NULL_HANDLE, 0);
+ vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image, VK_NULL_HANDLE, 0);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->textures[i].image);
- for (j = 0; j < demo->textures[i].num_mem; j++)
- vkFreeMemory(demo->device, demo->textures[i].mem[j]);
- free(demo->textures[i].mem);
+ vkFreeMemory(demo->device, demo->textures[i].mem);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_SAMPLER, demo->textures[i].sampler);
}
vkDestroyObject(demo->device, VK_OBJECT_TYPE_DEPTH_STENCIL_VIEW, demo->depth.view);
- vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image, 0, VK_NULL_HANDLE, 0);
+ vkBindObjectMemory(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image, VK_NULL_HANDLE, 0);
vkDestroyObject(demo->device, VK_OBJECT_TYPE_IMAGE, demo->depth.image);
- for (j = 0; j < demo->depth.num_mem; j++) {
- vkFreeMemory(demo->device, demo->depth.mem[j]);
- }
+ vkFreeMemory(demo->device, demo->depth.mem);
for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
vkDestroyObject(demo->device, VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, demo->buffers[i].view);
{
VkResult ret = VK_SUCCESS;
size_t s;
- uint32_t *count;
switch (type) {
case VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS:
mem_req->memPropsAllowed = INTEL_MEMORY_PROPERTY_ALL;
break;
}
- case VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- *size = sizeof(uint32_t);
- if (data == NULL)
- return ret;
- count = (uint32_t *) data;
- *count = 1;
- break;
default:
ret = VK_ERROR_INVALID_VALUE;
break;
VkDevice device,
VkObjectType objType,
VkObject object,
- uint32_t allocationIdx,
VkDeviceMemory mem_,
VkDeviceSize memOffset)
{
ICD_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
VkQueue queue,
VkBuffer buffer,
- uint32_t allocationIdx,
VkDeviceSize rangeOffset,
VkDeviceSize rangeSize,
VkDeviceMemory mem,
ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
VkQueue queue,
VkImage image,
- uint32_t allocationIdx,
const VkImageMemoryBindInfo* pBindInfo,
VkDeviceMemory mem,
VkDeviceSize memOffset)
{
VkResult ret = VK_SUCCESS;
size_t s;
- uint32_t *count;
switch (type) {
case VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS:
memset(data, 0, s);
break;
}
- case VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT:
- *size = sizeof(uint32_t);
- if (data == NULL)
- return ret;
- count = (uint32_t *) data;
- *count = 1;
- break;
default:
ret = VK_ERROR_INVALID_VALUE;
break;
VkDevice device,
VkObjectType objType,
VkObject object,
- uint32_t allocationIdx,
VkDeviceMemory mem_,
VkDeviceSize memOffset)
{
ICD_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
VkQueue queue,
VkBuffer buffer,
- uint32_t allocationIdx,
VkDeviceSize rangeOffset,
VkDeviceSize rangeSize,
VkDeviceMemory mem,
ICD_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(
VkQueue queue,
VkImage image,
- uint32_t allocationIdx,
const VkImageMemoryBindInfo* pBindInfo,
VkDeviceMemory mem,
VkDeviceSize memOffset)
#include "vk_platform.h"
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 96, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 97, 0)
#ifdef __cplusplus
extern "C"
typedef enum VkObjectInfoType_
{
// Info type for vkGetObjectInfo()
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT = 0x00000000,
- VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000001,
+ VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS = 0x00000000,
- VK_ENUM_RANGE(OBJECT_INFO_TYPE, MEMORY_ALLOCATION_COUNT, MEMORY_REQUIREMENTS)
+ VK_ENUM_RANGE(OBJECT_INFO_TYPE, MEMORY_REQUIREMENTS, MEMORY_REQUIREMENTS)
} VkObjectInfoType;
typedef enum VkVertexInputStepRate_
typedef VkResult (VKAPI *PFN_vkOpenPeerImage)(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem);
typedef VkResult (VKAPI *PFN_vkDestroyObject)(VkDevice device, VkObjectType objType, VkObject object);
typedef VkResult (VKAPI *PFN_vkGetObjectInfo)(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData);
-typedef VkResult (VKAPI *PFN_vkBindObjectMemory)(VkDevice device, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset);
-typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkBindObjectMemory)(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize offset);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseBufferMemory)(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkQueueBindSparseImageMemory)(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset);
typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence);
typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, VkFence* pFences);
typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
VkDevice device,
VkObjectType objType,
VkObject object,
- uint32_t allocationIdx,
VkDeviceMemory mem,
VkDeviceSize memOffset);
VkResult VKAPI vkQueueBindSparseBufferMemory(
VkQueue queue,
VkBuffer buffer,
- uint32_t allocationIdx,
VkDeviceSize rangeOffset,
VkDeviceSize rangeSize,
VkDeviceMemory mem,
VkResult VKAPI vkQueueBindSparseImageMemory(
VkQueue queue,
VkImage image,
- uint32_t allocationIdx,
const VkImageMemoryBindInfo* pBindInfo,
VkDeviceMemory mem,
VkDeviceSize memOffset);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkGpuMemory mem, VkGpuSize offset)
+VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkQueue queue, VkObjectType objType, VkObject object, VkGpuMemory mem, VkGpuSize offset)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)object, ll_get_obj_type(object));
loader_platform_thread_unlock_mutex(&objLock);
- VkResult result = nextTable.BindObjectMemory(queue, objType, object, allocationIdx, mem, offset);
+ VkResult result = nextTable.BindObjectMemory(queue, objType, object, mem, offset);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkGpuSize rangeOffset, VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset)
+VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemoryRange(VkQueue queue, VkObjectType objType, VkObject object, VkGpuSize rangeOffset, VkGpuSize rangeSize, VkGpuMemory mem, VkGpuSize memOffset)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)object, ll_get_obj_type(object));
loader_platform_thread_unlock_mutex(&objLock);
- VkResult result = nextTable.BindObjectMemoryRange(queue, objType, object, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+ VkResult result = nextTable.BindObjectMemoryRange(queue, objType, object, rangeOffset, rangeSize, mem, memOffset);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkBindImageMemoryRange(VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkGpuMemory mem, VkGpuSize memOffset)
+VK_LAYER_EXPORT VkResult VKAPI vkBindImageMemoryRange(VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkGpuMemory mem, VkGpuSize memOffset)
{
loader_platform_thread_lock_mutex(&objLock);
ll_increment_use_count((void*)image, VK_OBJECT_TYPE_IMAGE);
loader_platform_thread_unlock_mutex(&objLock);
- VkResult result = nextTable.BindImageMemoryRange(image, allocationIdx, pBindInfo, mem, memOffset);
+ VkResult result = nextTable.BindImageMemoryRange(image, pBindInfo, mem, memOffset);
return result;
}
sprintf(str, "Attempting to clear mem binding for object %p: devices, queues, command buffers, "
"shaders and memory objects do not have external memory requirements and it is "
"unneccessary to call bind/unbindObjectMemory on them.", object);
- layerCbMsg(VK_DBG_MSG_WARNING, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
+ layerCbMsg(VK_DBG_MSG_UNKNOWN, VK_VALIDATION_LEVEL_0, object, 0, MEMTRACK_INVALID_OBJECT, "MEM", str);
} else {
if (!pObjInfo->pMemObjInfo || pObjInfo->pMemObjInfo->pObjBindings.size() <= 0) {
char str[1024];
VkDevice device,
VkObjectType objType,
VkObject object,
- uint32_t allocationIdx,
VkDeviceMemory mem,
VkDeviceSize offset)
{
- VkResult result = nextTable.BindObjectMemory(device, objType, object, allocationIdx, mem, offset);
+ VkResult result = nextTable.BindObjectMemory(device, objType, object, mem, offset);
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
if (VK_FALSE == updateObjectBinding(object, mem)) {
VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(
VkQueue queue,
VkBuffer buffer,
- uint32_t allocationIdx,
VkDeviceSize rangeOffset,
VkDeviceSize rangeSize,
VkDeviceMemory mem,
VkDeviceSize memOffset)
{
- VkResult result = nextTable.QueueBindSparseBufferMemory(queue, buffer, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+ VkResult result = nextTable.QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
loader_platform_thread_lock_mutex(&globalLock);
// Track objects tied to memory
if (VK_FALSE == updateObjectBinding(buffer, mem)) {
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
+VK_LAYER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize offset)
{
- VkResult result = nextTable.BindObjectMemory(device, objType, object, allocationIdx, mem, offset);
+ VkResult result = nextTable.BindObjectMemory(device, objType, object, mem, offset);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
{
- VkResult result = nextTable.QueueBindSparseBufferMemory(queue, buffer, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+ VkResult result = nextTable.QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
+VK_LAYER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
{
char str[1024];
if (!pBindInfo) {
sprintf(str, "Parameter pBindInfo to function BindImageMemoryRange contains an invalid value.");
layerCbMsg(VK_DBG_MSG_ERROR, VK_VALIDATION_LEVEL_0, NULL, 0, 1, "PARAMCHECK", str);
}
- VkResult result = nextTable.QueueBindSparseImageMemory(queue, image, allocationIdx, pBindInfo, mem, memOffset);
+ VkResult result = nextTable.QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset);
return result;
}
return disp->GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
}
-LOADER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, uint32_t allocationIdx, VkDeviceMemory mem, VkDeviceSize offset)
+LOADER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize offset)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(device);
- return disp->BindObjectMemory(device, objType, object, allocationIdx, mem, offset);
+ return disp->BindObjectMemory(device, objType, object, mem, offset);
}
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t allocationIdx, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(queue);
- return disp->QueueBindSparseBufferMemory(queue, buffer, allocationIdx, rangeOffset, rangeSize, mem, memOffset);
+ return disp->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
}
-LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t allocationIdx, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
+LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset)
{
const VkLayerDispatchTable *disp;
disp = loader_get_dispatch(queue);
- return disp->QueueBindSparseImageMemory(queue, image, allocationIdx, pBindInfo, mem, memOffset);
+ return disp->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset);
}
LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
err = vkAllocMemory(dev_.obj(), &mem_info, &event_mem);
ASSERT_VK_SUCCESS(err);
- err = vkBindObjectMemory(dev_.obj(), VK_OBJECT_TYPE_EVENT, event, 0, event_mem, 0);
+ err = vkBindObjectMemory(dev_.obj(), VK_OBJECT_TYPE_EVENT, event, event_mem, 0);
ASSERT_VK_SUCCESS(err);
err = vkResetEvent(dev_.obj(), event);
bufs[2].unmap();
// All done with event memory, clean up
- err = vkBindObjectMemory(dev_.obj(), VK_OBJECT_TYPE_EVENT, event, 0, VK_NULL_HANDLE, 0);
+ err = vkBindObjectMemory(dev_.obj(), VK_OBJECT_TYPE_EVENT, event, VK_NULL_HANDLE, 0);
ASSERT_VK_SUCCESS(err);
err = vkDestroyObject(dev_.obj(), VK_OBJECT_TYPE_EVENT, event);
uint32_t gpu_count;
VkInstance inst;
VkImage m_image;
- VkDeviceMemory *m_image_mem;
- uint32_t m_num_mem;
+ VkDeviceMemory m_image_mem;
virtual void SetUp() {
VkResult err;
err = vkCreateImage(device(), &imageCreateInfo, &m_image);
ASSERT_VK_SUCCESS(err);
- VkMemoryRequirements *mem_req;
+ VkMemoryRequirements mem_req;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
VkMemoryAllocInfo mem_info = {};
mem_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
mem_info.pNext = NULL;
- err = vkGetObjectInfo(device(), VK_OBJECT_TYPE_IMAGE, m_image, VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- ASSERT_VK_SUCCESS(err);
- ASSERT_EQ(num_alloc_size,sizeof(num_allocations));
- mem_req = (VkMemoryRequirements *) malloc(num_allocations * sizeof(VkMemoryRequirements));
- m_image_mem = (VkDeviceMemory *) malloc(num_allocations * sizeof(VkDeviceMemory));
- m_num_mem = num_allocations;
err = vkGetObjectInfo(device(), VK_OBJECT_TYPE_IMAGE, m_image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
- &mem_reqs_size, mem_req);
+ &mem_reqs_size, &mem_req);
ASSERT_VK_SUCCESS(err);
- ASSERT_EQ(mem_reqs_size, num_allocations * sizeof(VkMemoryRequirements));
- for (uint32_t i = 0; i < num_allocations; i ++) {
- ASSERT_NE(0, mem_req[i].size) << "vkGetObjectInfo (Image): Failed - expect images to require memory";
- mem_info.allocationSize = mem_req[i].size;
- mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
- mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
+ ASSERT_NE(0, mem_req.size) << "vkGetObjectInfo (Image): Failed - expect images to require memory";
+ mem_info.allocationSize = mem_req.size;
+ mem_info.memProps = VK_MEMORY_PROPERTY_SHAREABLE_BIT;
+ mem_info.memPriority = VK_MEMORY_PRIORITY_NORMAL;
- /* allocate memory */
- err = vkAllocMemory(device(), &mem_info, &m_image_mem[i]);
- ASSERT_VK_SUCCESS(err);
+ /* allocate memory */
+ err = vkAllocMemory(device(), &mem_info, &m_image_mem);
+ ASSERT_VK_SUCCESS(err);
- /* bind memory */
- err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_image, i, m_image_mem[i], 0);
- ASSERT_VK_SUCCESS(err);
- }
+ /* bind memory */
+ err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_image, m_image_mem, 0);
+ ASSERT_VK_SUCCESS(err);
}
void VkImageTest::DestroyImage()
{
VkResult err;
// All done with image memory, clean up
- ASSERT_VK_SUCCESS(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_image, 0, VK_NULL_HANDLE, 0));
+ ASSERT_VK_SUCCESS(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_image, VK_NULL_HANDLE, 0));
- for (uint32_t i = 0 ; i < m_num_mem; i++) {
- err = vkFreeMemory(device(), m_image_mem[i]);
- ASSERT_VK_SUCCESS(err);
- }
+ err = vkFreeMemory(device(), m_image_mem);
+ ASSERT_VK_SUCCESS(err);
ASSERT_VK_SUCCESS(vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE, m_image));
err = vkAllocMemory(device(), &mem_info, &event_mem);
ASSERT_VK_SUCCESS(err);
- err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, 0, event_mem, 0);
+ err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, event_mem, 0);
ASSERT_VK_SUCCESS(err);
err = vkResetEvent(device(), event);
// TODO: Test actual synchronization with command buffer event.
// All done with event memory, clean up
- err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, 0, VK_NULL_HANDLE, 0);
+ err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, VK_NULL_HANDLE, 0);
ASSERT_VK_SUCCESS(err);
err = vkDestroyObject(device(), VK_OBJECT_TYPE_EVENT, event);
err = vkAllocMemory(device(), &mem_info, &query_mem);
ASSERT_VK_SUCCESS(err);
- err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, 0, query_mem, 0);
+ err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, query_mem, 0);
ASSERT_VK_SUCCESS(err);
// TODO: Test actual synchronization with command buffer event.
}
// All done with QueryPool memory, clean up
- err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, 0, VK_NULL_HANDLE, 0);
+ err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool, VK_NULL_HANDLE, 0);
ASSERT_VK_SUCCESS(err);
err = vkDestroyObject(device(), VK_OBJECT_TYPE_QUERY_POOL, query_pool);
err = vkAllocMemory(device(), &mem_info, &image_mem);
ASSERT_VK_SUCCESS(err);
- err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, 0, image_mem, 0);
+ err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, image_mem, 0);
ASSERT_VK_SUCCESS(err);
// typedef struct VkImageViewCreateInfo_
// TODO: Test image memory.
// All done with image memory, clean up
- ASSERT_VK_SUCCESS(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, 0, VK_NULL_HANDLE, 0));
+ ASSERT_VK_SUCCESS(vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, image, VK_NULL_HANDLE, 0));
ASSERT_VK_SUCCESS(vkFreeMemory(device(), image_mem));
// Create an image, allocate memory, free it, and then try to bind it
VkImage image;
- VkDeviceMemory *mem;
- VkMemoryRequirements *mem_reqs;
+ VkDeviceMemory mem;
+ VkMemoryRequirements mem_reqs;
const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM;
const int32_t tex_width = 32;
const int32_t tex_height = 32;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
const VkImageCreateInfo image_create_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
err = vkGetObjectInfo(m_device->device(),
VK_OBJECT_TYPE_IMAGE,
image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size,
- &num_allocations);
- ASSERT_VK_SUCCESS(err);
-
- mem_reqs = new VkMemoryRequirements[num_allocations];
- mem = new VkDeviceMemory[num_allocations];
-
- err = vkGetObjectInfo(m_device->device(),
- VK_OBJECT_TYPE_IMAGE,
- image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size,
- mem_reqs);
+ &mem_reqs);
ASSERT_VK_SUCCESS(err);
- mem_alloc.allocationSize = mem_reqs[0].size;
+ mem_alloc.allocationSize = mem_reqs.size;
// allocate memory
- err = vkAllocMemory(m_device->device(), &mem_alloc, &(mem[0]));
+ err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
ASSERT_VK_SUCCESS(err);
// Try to bind free memory that has been freed
- err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, 0, mem[0], 0);
+ err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
ASSERT_VK_SUCCESS(err);
// Map memory as if to initialize the image
void *mappedAddress = NULL;
- err = vkMapMemory(m_device->device(), mem[0], 0, 0, 0, &mappedAddress);
+ err = vkMapMemory(m_device->device(), mem, 0, 0, 0, &mappedAddress);
msgType = m_errorMonitor->GetState(&msgString);
ASSERT_EQ(msgType, VK_DBG_MSG_ERROR) << "Did not receive an error while tring to map memory not visible to CPU";
// Create an image, allocate memory, free it, and then try to bind it
VkImage image;
- VkDeviceMemory *mem;
- VkMemoryRequirements *mem_reqs;
+ VkDeviceMemory mem;
+ VkMemoryRequirements mem_reqs;
const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM;
const int32_t tex_width = 32;
const int32_t tex_height = 32;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
const VkImageCreateInfo image_create_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
err = vkGetObjectInfo(m_device->device(),
VK_OBJECT_TYPE_IMAGE,
image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size,
- &num_allocations);
- ASSERT_VK_SUCCESS(err);
-
- mem_reqs = new VkMemoryRequirements[num_allocations];
- mem = new VkDeviceMemory[num_allocations];
-
- err = vkGetObjectInfo(m_device->device(),
- VK_OBJECT_TYPE_IMAGE,
- image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size,
- mem_reqs);
+ &mem_reqs);
ASSERT_VK_SUCCESS(err);
- mem_alloc.allocationSize = mem_reqs[0].size;
+ mem_alloc.allocationSize = mem_reqs.size;
// allocate memory
- err = vkAllocMemory(m_device->device(), &mem_alloc, &(mem[0]));
+ err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
ASSERT_VK_SUCCESS(err);
// Introduce validation failure, free memory before binding
- vkFreeMemory(m_device->device(), mem[0]);
+ vkFreeMemory(m_device->device(), mem);
ASSERT_VK_SUCCESS(err);
// Try to bind free memory that has been freed
- err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, 0, mem[0], 0);
+ err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
ASSERT_VK_SUCCESS(err);
msgType = m_errorMonitor->GetState(&msgString);
// Create an image, allocate memory, free it, and then try to bind it
VkImage image;
- VkDeviceMemory *mem;
- VkMemoryRequirements *mem_reqs;
+ VkDeviceMemory mem;
+ VkMemoryRequirements mem_reqs;
const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM;
const int32_t tex_width = 32;
const int32_t tex_height = 32;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
const VkImageCreateInfo image_create_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
err = vkGetObjectInfo(m_device->device(),
VK_OBJECT_TYPE_IMAGE,
image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size,
- &num_allocations);
- ASSERT_VK_SUCCESS(err);
-
- mem_reqs = new VkMemoryRequirements[num_allocations];
- mem = new VkDeviceMemory[num_allocations];
-
- err = vkGetObjectInfo(m_device->device(),
- VK_OBJECT_TYPE_IMAGE,
- image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size,
- mem_reqs);
+ &mem_reqs);
ASSERT_VK_SUCCESS(err);
- mem_alloc.allocationSize = mem_reqs[0].size;
+ mem_alloc.allocationSize = mem_reqs.size;
// allocate memory
- err = vkAllocMemory(m_device->device(), &mem_alloc, &(mem[0]));
+ err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
ASSERT_VK_SUCCESS(err);
// Bind memory to Image object
- err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, 0, mem[0], 0);
+ err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
ASSERT_VK_SUCCESS(err);
// Introduce validation failure, free memory while still bound to object
- vkFreeMemory(m_device->device(), mem[0]);
+ vkFreeMemory(m_device->device(), mem);
ASSERT_VK_SUCCESS(err);
msgType = m_errorMonitor->GetState(&msgString);
// Create an image object, allocate memory, destroy the object and then try to bind it
VkImage image;
- VkDeviceMemory *mem;
- VkMemoryRequirements *mem_reqs;
+ VkDeviceMemory mem;
+ VkMemoryRequirements mem_reqs;
const VkFormat tex_format = VK_FORMAT_B8G8R8A8_UNORM;
const int32_t tex_width = 32;
const int32_t tex_height = 32;
size_t mem_reqs_size = sizeof(VkMemoryRequirements);
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
const VkImageCreateInfo image_create_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
err = vkGetObjectInfo(m_device->device(),
VK_OBJECT_TYPE_IMAGE,
image,
- VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size,
- &num_allocations);
- ASSERT_VK_SUCCESS(err);
-
- mem_reqs = new VkMemoryRequirements[num_allocations];
- mem = new VkDeviceMemory[num_allocations];
-
- err = vkGetObjectInfo(m_device->device(),
- VK_OBJECT_TYPE_IMAGE,
- image,
VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS,
&mem_reqs_size,
- mem_reqs);
+ &mem_reqs);
ASSERT_VK_SUCCESS(err);
- mem_alloc.allocationSize = mem_reqs[0].size;
+ mem_alloc.allocationSize = mem_reqs.size;
// Allocate memory
- err = vkAllocMemory(m_device->device(), &mem_alloc, &(mem[0]));
+ err = vkAllocMemory(m_device->device(), &mem_alloc, &mem);
ASSERT_VK_SUCCESS(err);
// Introduce validation failure, destroy Image object before binding
ASSERT_VK_SUCCESS(err);
// Now Try to bind memory to this destroyted object
- err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, 0, mem[0], 0);
+ err = vkBindObjectMemory(m_device->device(), VK_OBJECT_TYPE_IMAGE, image, mem, 0);
ASSERT_VK_SUCCESS(err);
msgType = m_errorMonitor->GetState(&msgString);
err = vkAllocMemory(device(), &mem_info, &event_mem);
ASSERT_VK_SUCCESS(err);
- err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, 0, event_mem, 0);
+ err = vkBindObjectMemory(device(), VK_OBJECT_TYPE_EVENT, event, event_mem, 0);
ASSERT_VK_SUCCESS(err);
err = vkResetEvent(device(), event);
}
while (!m_renderTargets.empty()) {
vkDestroyObject(device(), VK_OBJECT_TYPE_COLOR_ATTACHMENT_VIEW, m_renderTargets.back()->targetView());
- vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_renderTargets.back()->image(), 0, VK_NULL_HANDLE, 0);
+ vkBindObjectMemory(device(), VK_OBJECT_TYPE_IMAGE, m_renderTargets.back()->image(), VK_NULL_HANDLE, 0);
vkDestroyObject(device(), VK_OBJECT_TYPE_IMAGE, m_renderTargets.back()->image());
vkFreeMemory(device(), m_renderTargets.back()->memory());
m_renderTargets.pop_back();
uint32_t Object::memory_allocation_count() const
{
- return get_info<uint32_t>(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
+ /// LUGMAL return get_info<uint32_t>(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT, 1)[0];
+ return 1;
}
std::vector<VkMemoryRequirements> Object::memory_requirements() const
{
- VkResult err;
- uint32_t num_allocations = 0;
- size_t num_alloc_size = sizeof(num_allocations);
- err = vkGetObjectInfo(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
- &num_alloc_size, &num_allocations);
- EXPECT(err == VK_SUCCESS && num_alloc_size == sizeof(num_allocations));
+ //// VkResult err;
+ uint32_t num_allocations = 1;
+ //// size_t num_alloc_size = sizeof(num_allocations);
+ //// err = vkGetObjectInfo(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+ //// &num_alloc_size, &num_allocations);
+ //// EXPECT(err == VK_SUCCESS && num_alloc_size == sizeof(num_allocations));
std::vector<VkMemoryRequirements> info =
get_info<VkMemoryRequirements>(dev_->obj(), type(), obj(), VK_OBJECT_INFO_TYPE_MEMORY_REQUIREMENTS, 0);
EXPECT(info.size() == num_allocations);
EXPECT(vkDestroyObject(dev_->obj(), type(), obj()) == VK_SUCCESS);
}
-void Object::bind_memory(uint32_t alloc_idx, const GpuMemory &mem, VkDeviceSize mem_offset)
+void Object::bind_memory(const GpuMemory &mem, VkDeviceSize mem_offset)
{
bound = true;
- EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), alloc_idx, mem.obj(), mem_offset) == VK_SUCCESS);
+ EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), mem.obj(), mem_offset) == VK_SUCCESS);
}
-void Object::unbind_memory(uint32_t alloc_idx)
-{
- EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), alloc_idx, VK_NULL_HANDLE, 0) == VK_SUCCESS);
-}
void Object::unbind_memory()
{
- for (uint32_t i = 0; i < mem_alloc_count_; i++)
- unbind_memory(i);
+ EXPECT(vkBindObjectMemory(dev_->obj(), type(), obj(), VK_NULL_HANDLE, 0) == VK_SUCCESS);
}
void Object::alloc_memory()
info = GpuMemory::alloc_info(mem_reqs[i], next_info);
primary_mem_ = &internal_mems_[i];
internal_mems_[i].init(*dev_, info);
- bind_memory(i, internal_mems_[i], 0);
+ bind_memory(internal_mems_[i], 0);
}
}
info = GpuMemory::alloc_info(mem_reqs[i], next_info);
primary_mem_ = &internal_mems_[i];
internal_mems_[i].init(*dev_, info);
- bind_memory(i, internal_mems_[i], 0);
+ bind_memory(internal_mems_[i], 0);
}
}
primary_mem_ = &internal_mems_[i];
internal_mems_[i].init(*dev_, mems[i]);
- bind_memory(i, internal_mems_[i], 0);
+ bind_memory(internal_mems_[i], 0);
}
}
create_info_ = info;
}
-void Buffer::bind_memory(uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
+void Buffer::bind_memory(VkDeviceSize offset, VkDeviceSize size,
const GpuMemory &mem, VkDeviceSize mem_offset)
{
VkQueue queue = dev_->graphics_queues()[0]->obj();
- EXPECT(!alloc_idx && vkQueueBindSparseBufferMemory(queue, obj(), 0, offset, size, mem.obj(), mem_offset) == VK_SUCCESS);
+ EXPECT(vkQueueBindSparseBufferMemory(queue, obj(), offset, size, mem.obj(), mem_offset) == VK_SUCCESS);
}
void BufferView::init(const Device &dev, const VkBufferViewCreateInfo &info)
}
}
-void Image::bind_memory(const Device &dev, uint32_t alloc_idx, const VkImageMemoryBindInfo &info,
+void Image::bind_memory(const Device &dev, const VkImageMemoryBindInfo &info,
const GpuMemory &mem, VkDeviceSize mem_offset)
{
VkQueue queue = dev.graphics_queues()[0]->obj();
- EXPECT(!alloc_idx && vkQueueBindSparseImageMemory(queue, obj(), 0, &info, mem.obj(), mem_offset) == VK_SUCCESS);
+ EXPECT(vkQueueBindSparseImageMemory(queue, obj(), &info, mem.obj(), mem_offset) == VK_SUCCESS);
}
VkSubresourceLayout Image::subresource_layout(const VkImageSubresource &subres) const
std::vector<VkMemoryRequirements> memory_requirements() const;
// vkBindObjectMemory()
- void bind_memory(uint32_t alloc_idx, const GpuMemory &mem, VkDeviceSize mem_offset);
- void unbind_memory(uint32_t alloc_idx);
+ void bind_memory(const GpuMemory &mem, VkDeviceSize mem_offset);
void unbind_memory();
// Unless an object is initialized with init_no_mem(), memories are
void init_no_mem(const Device &dev, const VkBufferCreateInfo &info);
// vkQueueBindSparseBufferMemory()
- void bind_memory(uint32_t alloc_idx, VkDeviceSize offset, VkDeviceSize size,
+ void bind_memory(VkDeviceSize offset, VkDeviceSize size,
const GpuMemory &mem, VkDeviceSize mem_offset);
static VkBufferCreateInfo create_info(VkDeviceSize size, VkFlags usage);
void init(const Device &dev, const VkPeerImageOpenInfo &info, const VkImageCreateInfo &original_info);
// vkQueueBindSparseImageMemory()
- void bind_memory(const Device &dev, uint32_t alloc_idx, const VkImageMemoryBindInfo &info,
+ void bind_memory(const Device &dev, const VkImageMemoryBindInfo &info,
const GpuMemory &mem, VkDeviceSize mem_offset);
// vkGetImageSubresourceInfo()
Proto("VkResult", "DestroyObject",
[Param("VkDevice", "device"),
- Param("VkObjectType", "objType"),
+ Param("VkObjectType", "objType"),
Param("VkObject", "object")]),
Proto("VkResult", "GetObjectInfo",
[Param("VkDevice", "device"),
- Param("VkObjectType", "objType"),
+ Param("VkObjectType", "objType"),
Param("VkObject", "object"),
Param("VkObjectInfoType", "infoType"),
Param("size_t*", "pDataSize"),
Proto("VkResult", "BindObjectMemory",
[Param("VkDevice", "device"),
- Param("VkObjectType", "objType"),
+ Param("VkObjectType", "objType"),
Param("VkObject", "object"),
- Param("uint32_t", "allocationIdx"),
Param("VkDeviceMemory", "mem"),
Param("VkDeviceSize", "offset")]),
Proto("VkResult", "QueueBindSparseBufferMemory",
[Param("VkQueue", "queue"),
Param("VkBuffer", "buffer"),
- Param("uint32_t", "allocationIdx"),
Param("VkDeviceSize", "rangeOffset"),
Param("VkDeviceSize", "rangeSize"),
Param("VkDeviceMemory", "mem"),
Proto("VkResult", "QueueBindSparseImageMemory",
[Param("VkQueue", "queue"),
Param("VkImage", "image"),
- Param("uint32_t", "allocationIdx"),
Param("const VkImageMemoryBindInfo*", "pBindInfo"),
Param("VkDeviceMemory", "mem"),
Param("VkDeviceSize", "memOffset")]),
projects / platform / upstream / Vulkan-LoaderAndValidationLayers.git / commitdiff