memory alloc: Add IMAGE and BUFFER alloc info structures

For images have the tests fill in the IMAGE_ALLOC structures.  For buffers
this is not yet done.

Conflicts:
	demos/cube.c
	demos/tri.c
	include/xgl.h
	tests/init.cpp
	tests/xgltestbinding.cpp

5 files changed, 335 insertions, 84 deletions

diff --git a/demos/cube.c b/demos/cube.c
index c0ce5fed..d7deecb3 100644
--- a/demos/cube.c
+++ b/demos/cube.c
@@ -229,7 +229,8 @@ struct demo {
 
     struct {
         XGL_BUFFER buf;
-        XGL_GPU_MEMORY mem;
+        XGL_UINT num_mem;
+        XGL_GPU_MEMORY *mem;
         XGL_BUFFER_VIEW view;
         XGL_BUFFER_VIEW_ATTACH_INFO attach;
     } uniform_data;
@@ -365,12 +366,13 @@ void demo_update_data_buffer(struct demo *demo)
     mat4x4_rotate(demo->model_matrix, Model, 0.0f, 1.0f, 0.0f, degreesToRadians(demo->spin_angle));
     mat4x4_mul(MVP, VP, demo->model_matrix);
 
-    err = xglMapMemory(demo->uniform_data.mem, 0, (XGL_VOID **) &pData);
+    assert(demo->uniform_data.num_mem == 1);
+    err = xglMapMemory(demo->uniform_data.mem[0], 0, (XGL_VOID **) &pData);
     assert(!err);
 
     memcpy(pData, (const void*) &MVP[0][0], matrixSize);
 
-    err = xglUnmapMemory(demo->uniform_data.mem);
+    err = xglUnmapMemory(demo->uniform_data.mem[0]);
     assert(!err);
 }
 
@@ -461,9 +463,13 @@ static void demo_prepare_depth(struct demo *demo)
         .usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT,
         .flags = 0,
     };
+    XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+        .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+        .pNext = NULL,
+    };
     XGL_MEMORY_ALLOC_INFO mem_alloc = {
         .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
-        .pNext = NULL,
+        .pNext = &img_alloc,
         .allocationSize = 0,
         .alignment = 0,
         .flags = 0,
@@ -481,6 +487,8 @@ static void demo_prepare_depth(struct demo *demo)
     };
     XGL_MEMORY_REQUIREMENTS *mem_reqs;
     XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+    XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+    XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
     XGL_RESULT err;
     XGL_UINT num_allocations = 0;
     XGL_SIZE num_alloc_size = sizeof(num_allocations);
@@ -502,7 +510,13 @@ static void demo_prepare_depth(struct demo *demo)
                     XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
                     &mem_reqs_size, mem_reqs);
     assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+    err = xglGetObjectInfo(demo->depth.image,
+                    XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+                    &img_reqs_size, &img_reqs);
+    assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+    img_alloc.usage = img_reqs.usage;
+    img_alloc.formatClass = img_reqs.formatClass;
+    img_alloc.samples = img_reqs.samples;
     for (XGL_UINT i = 0; i < num_allocations; i ++) {
         mem_alloc.allocationSize = mem_reqs[i].size;
         mem_alloc.alignment = mem_reqs[i].alignment;
@@ -719,9 +733,13 @@ static void demo_prepare_textures(struct demo *demo)
             .usage = XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT,
             .flags = 0,
         };
+        XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+            .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+            .pNext = NULL,
+        };
         XGL_MEMORY_ALLOC_INFO mem_alloc = {
             .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
-            .pNext = NULL,
+            .pNext = &img_alloc,
             .allocationSize = 0,
             .alignment = 0,
             .flags = 0,
@@ -745,6 +763,8 @@ static void demo_prepare_textures(struct demo *demo)
 
         XGL_MEMORY_REQUIREMENTS *mem_reqs;
         XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+        XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+        XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
         XGL_UINT num_allocations = 0;
         XGL_SIZE num_alloc_size = sizeof(num_allocations);
 
@@ -769,7 +789,13 @@ static void demo_prepare_textures(struct demo *demo)
                     XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
                     &mem_reqs_size, mem_reqs);
         assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+        err = xglGetObjectInfo(demo->textures[i].image,
+                        XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+                        &img_reqs_size, &img_reqs);
+        assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+        img_alloc.usage = img_reqs.usage;
+        img_alloc.formatClass = img_reqs.formatClass;
+        img_alloc.samples = img_reqs.samples;
         for (XGL_UINT j = 0; j < num_allocations; j ++) {
             mem_alloc.allocationSize = mem_reqs[j].size;
             mem_alloc.alignment = mem_reqs[j].alignment;
@@ -826,9 +852,25 @@ void demo_prepare_cube_data_buffer(struct demo *demo)
 {
     XGL_BUFFER_CREATE_INFO buf_info;
     XGL_BUFFER_VIEW_CREATE_INFO view_info;
-    XGL_MEMORY_ALLOC_INFO alloc_info;
-    XGL_MEMORY_REQUIREMENTS mem_reqs;
+    XGL_MEMORY_ALLOC_BUFFER_INFO buf_alloc = {
+        .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO,
+        .pNext = NULL,
+    };
+    XGL_MEMORY_ALLOC_INFO alloc_info = {
+        .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
+        .pNext = &buf_alloc,
+        .allocationSize = 0,
+        .alignment = 0,
+        .flags = 0,
+        .heapCount = 0,
+        .memPriority = XGL_MEMORY_PRIORITY_NORMAL,
+    };
+    XGL_MEMORY_REQUIREMENTS *mem_reqs;
     XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+    XGL_BUFFER_MEMORY_REQUIREMENTS buf_reqs;
+    XGL_SIZE buf_reqs_size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+    XGL_UINT num_allocations = 0;
+    XGL_SIZE num_alloc_size = sizeof(num_allocations);
     XGL_UINT8 *pData;
     int i;
     mat4x4 MVP, VP;
@@ -859,35 +901,45 @@ void demo_prepare_cube_data_buffer(struct demo *demo)
     assert(!err);
 
     err = xglGetObjectInfo(demo->uniform_data.buf,
+                           XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+                           &num_alloc_size, &num_allocations);
+    assert(!err && num_alloc_size == sizeof(num_allocations));
+    mem_reqs = malloc(num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
+    demo->uniform_data.mem = malloc(num_allocations * sizeof(XGL_GPU_MEMORY));
+    demo->uniform_data.num_mem = num_allocations;
+    err = xglGetObjectInfo(demo->uniform_data.buf,
             XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
-            &mem_reqs_size, &mem_reqs);
-    assert(!err && mem_reqs_size == sizeof(mem_reqs));
-
-    memset(&alloc_info, 0, sizeof(alloc_info));
-    alloc_info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
-    alloc_info.allocationSize = mem_reqs.size;
-    alloc_info.alignment = mem_reqs.alignment;
-    alloc_info.heapCount = mem_reqs.heapCount;
-    XGL_UINT heapInfo[mem_reqs.heapCount];
-    alloc_info.pHeaps = (const XGL_UINT *)heapInfo;
-    memcpy(heapInfo, mem_reqs.pHeaps,
-            sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
-    alloc_info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;
-
-    err = xglAllocMemory(demo->device, &alloc_info, &demo->uniform_data.mem);
-    assert(!err);
+            &mem_reqs_size, mem_reqs);
+    assert(!err && mem_reqs_size == num_allocations * sizeof(*mem_reqs));
+    err = xglGetObjectInfo(demo->uniform_data.buf,
+                    XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS,
+                    &buf_reqs_size, &buf_reqs);
+    assert(!err && buf_reqs_size == sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS));
+    buf_alloc.usage = buf_reqs.usage;
+    for (XGL_UINT i = 0; i < num_allocations; i ++) {
+        alloc_info.allocationSize = mem_reqs[i].size;
+        alloc_info.alignment = mem_reqs[i].alignment;
+        alloc_info.heapCount = mem_reqs[i].heapCount;
+        XGL_UINT heapInfo[mem_reqs[i].heapCount];
+        alloc_info.pHeaps = (const XGL_UINT *)heapInfo;
+        memcpy(heapInfo, mem_reqs[i].pHeaps,
+                sizeof(mem_reqs[i].pHeaps[0]) * mem_reqs[i].heapCount);
 
-    err = xglMapMemory(demo->uniform_data.mem, 0, (XGL_VOID **) &pData);
-    assert(!err);
+        err = xglAllocMemory(demo->device, &alloc_info, &(demo->uniform_data.mem[i]));
+        assert(!err);
 
-    memcpy(pData, &data, alloc_info.allocationSize);
+        err = xglMapMemory(demo->uniform_data.mem[i], 0, (XGL_VOID **) &pData);
+        assert(!err);
 
-    err = xglUnmapMemory(demo->uniform_data.mem);
-    assert(!err);
+        memcpy(pData, &data, alloc_info.allocationSize);
 
-    err = xglBindObjectMemory(demo->uniform_data.buf, 0,
-            demo->uniform_data.mem, 0);
-    assert(!err);
+        err = xglUnmapMemory(demo->uniform_data.mem[i]);
+        assert(!err);
+
+        err = xglBindObjectMemory(demo->uniform_data.buf, i,
+                    demo->uniform_data.mem[i], 0);
+        assert(!err);
+    }
 
     memset(&view_info, 0, sizeof(view_info));
     view_info.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
@@ -1537,6 +1589,9 @@ static void demo_cleanup(struct demo *demo)
     xglDestroyObject(demo->depth.image);
     for (j = 0; j < demo->depth.num_mem; j++)
         xglFreeMemory(demo->depth.mem[j]);
+    xglDestroyObject(demo->uniform_data.buf);
+    for (j = 0; j < demo->uniform_data.num_mem; j++)
+        xglFreeMemory(demo->uniform_data.mem[j]);
 
     for (i = 0; i < DEMO_BUFFER_COUNT; i++) {
         xglDestroyObject(demo->buffers[i].fence);
diff --git a/demos/tri.c b/demos/tri.c
index d2a780bb..96c22194 100644
--- a/demos/tri.c
+++ b/demos/tri.c
@@ -59,7 +59,8 @@ struct demo {
 
     struct {
         XGL_BUFFER buf;
-        XGL_GPU_MEMORY mem;
+        XGL_UINT  num_mem;
+        XGL_GPU_MEMORY *mem;
 
         XGL_PIPELINE_VERTEX_INPUT_CREATE_INFO vi;
         XGL_VERTEX_INPUT_BINDING_DESCRIPTION vi_bindings[1];
@@ -189,20 +190,28 @@ static void demo_draw(struct demo *demo)
     err = xglWaitForFences(demo->device, 1, &fence, XGL_TRUE, ~((XGL_UINT64) 0));
     assert(err == XGL_SUCCESS || err == XGL_ERROR_UNAVAILABLE);
 
-    static const uint32_t NUM_MEM_REFS = 5;
-    XGL_MEMORY_REF memRefs[NUM_MEM_REFS];
-    memRefs[0].mem = demo->depth.mem;
-    memRefs[0].flags = 0;
-    memRefs[1].mem = demo->textures[0].mem;
-    memRefs[1].flags = 0;
-    memRefs[2].mem = demo->buffers[0].mem;
-    memRefs[2].flags = 0;
-    memRefs[3].mem = demo->buffers[1].mem;
-    memRefs[3].flags = 0;
-    memRefs[4].mem = demo->vertices.mem;
-    memRefs[4].flags = 0;
+    XGL_UINT i, idx = 0;
+    XGL_MEMORY_REF *memRefs;
+    memRefs = malloc(sizeof(XGL_MEMORY_REF) * (2 + demo->depth.num_mem +
+                     demo->textures[0].num_mem + demo->vertices.num_mem));
+    for (i = 0; i < demo->depth.num_mem; i++, idx++) {
+        memRefs[idx].mem = demo->depth.mem[i];
+        memRefs[idx].flags = 0;
+    }
+    for (i = 0; i < demo->textures[0].num_mem; i++, idx++) {
+        memRefs[idx].mem = demo->textures[0].mem[i];
+        memRefs[idx].flags = 0;
+    }
+    memRefs[idx].mem = demo->buffers[0].mem;
+    memRefs[idx++].flags = 0;
+    memRefs[idx].mem = demo->buffers[1].mem;
+    memRefs[idx++].flags = 0;
+    for (i = 0; i < demo->vertices.num_mem; i++, idx++) {
+        memRefs[idx].mem = demo->vertices.mem[i];
+        memRefs[idx].flags = 0;
+    }
     err = xglQueueSubmit(demo->queue, 1, &demo->cmd,
-            NUM_MEM_REFS, memRefs, XGL_NULL_HANDLE);
+            idx, memRefs, XGL_NULL_HANDLE);
     assert(!err);
 
     err = xglWsiX11QueuePresent(demo->queue, &present, fence);
@@ -272,9 +281,13 @@ static void demo_prepare_depth(struct demo *demo)
         .usage = XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT,
         .flags = 0,
     };
+    XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+        .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+        .pNext = NULL,
+    };
     XGL_MEMORY_ALLOC_INFO mem_alloc = {
         .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
-        .pNext = NULL,
+        .pNext = &img_alloc,
         .allocationSize = 0,
         .alignment = 0,
         .flags = 0,
@@ -293,6 +306,8 @@ static void demo_prepare_depth(struct demo *demo)
 
     XGL_MEMORY_REQUIREMENTS *mem_reqs;
     XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+    XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+    XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
     XGL_RESULT err;
     XGL_UINT num_allocations = 0;
     XGL_SIZE num_alloc_size = sizeof(num_allocations);
@@ -314,7 +329,13 @@ static void demo_prepare_depth(struct demo *demo)
                     XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
                     &mem_reqs_size, mem_reqs);
     assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+    err = xglGetObjectInfo(demo->depth.image,
+                    XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+                    &img_reqs_size, &img_reqs);
+    assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+    img_alloc.usage = img_reqs.usage;
+    img_alloc.formatClass = img_reqs.formatClass;
+    img_alloc.samples = img_reqs.samples;
     for (XGL_UINT i = 0; i < num_allocations; i ++) {
         mem_alloc.allocationSize = mem_reqs[i].size;
         mem_alloc.alignment = mem_reqs[i].alignment;
@@ -383,9 +404,13 @@ static void demo_prepare_textures(struct demo *demo)
             .usage = XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT,
             .flags = 0,
         };
+        XGL_MEMORY_ALLOC_IMAGE_INFO img_alloc = {
+            .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO,
+            .pNext = NULL,
+        };
         XGL_MEMORY_ALLOC_INFO mem_alloc = {
             .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
-            .pNext = NULL,
+            .pNext = &img_alloc,
             .allocationSize = 0,
             .alignment = 0,
             .flags = 0,
@@ -408,6 +433,8 @@ static void demo_prepare_textures(struct demo *demo)
 
         XGL_MEMORY_REQUIREMENTS *mem_reqs;
         XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+        XGL_IMAGE_MEMORY_REQUIREMENTS img_reqs;
+        XGL_SIZE img_reqs_size = sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS);
         XGL_UINT num_allocations = 0;
         XGL_SIZE num_alloc_size = sizeof(num_allocations);
 
@@ -432,7 +459,13 @@ static void demo_prepare_textures(struct demo *demo)
                     XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
                     &mem_reqs_size, mem_reqs);
         assert(!err && mem_reqs_size == num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
-
+        err = xglGetObjectInfo(demo->textures[i].image,
+                        XGL_INFO_TYPE_IMAGE_MEMORY_REQUIREMENTS,
+                        &img_reqs_size, &img_reqs);
+        assert(!err && img_reqs_size == sizeof(XGL_IMAGE_MEMORY_REQUIREMENTS));
+        img_alloc.usage = img_reqs.usage;
+        img_alloc.formatClass = img_reqs.formatClass;
+        img_alloc.samples = img_reqs.samples;
         for (XGL_UINT j = 0; j < num_allocations; j ++) {
             mem_alloc.allocationSize = mem_reqs[j].size;
             mem_alloc.alignment = mem_reqs[j].alignment;
@@ -505,9 +538,13 @@ static void demo_prepare_vertices(struct demo *demo)
         .usage = XGL_BUFFER_USAGE_VERTEX_FETCH_BIT,
         .flags = 0,
     };
+    XGL_MEMORY_ALLOC_BUFFER_INFO buf_alloc = {
+        .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO,
+        .pNext = NULL,
+    };
     XGL_MEMORY_ALLOC_INFO mem_alloc = {
         .sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO,
-        .pNext = NULL,
+        .pNext = &buf_alloc,
         .allocationSize = 0,
         .alignment = 0,
         .flags = 0,
@@ -515,8 +552,12 @@ static void demo_prepare_vertices(struct demo *demo)
         .pHeaps = 0,
         .memPriority = XGL_MEMORY_PRIORITY_NORMAL,
     };
-    XGL_MEMORY_REQUIREMENTS mem_reqs;
+    XGL_MEMORY_REQUIREMENTS *mem_reqs;
     XGL_SIZE mem_reqs_size = sizeof(XGL_MEMORY_REQUIREMENTS);
+    XGL_BUFFER_MEMORY_REQUIREMENTS buf_reqs;
+    XGL_SIZE buf_reqs_size = sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS);
+    XGL_UINT num_allocations = 0;
+    XGL_SIZE num_alloc_size = sizeof(num_allocations);
     XGL_RESULT err;
     void *data;
 
@@ -526,29 +567,43 @@ static void demo_prepare_vertices(struct demo *demo)
     assert(!err);
 
     err = xglGetObjectInfo(demo->vertices.buf,
+                           XGL_INFO_TYPE_MEMORY_ALLOCATION_COUNT,
+                           &num_alloc_size, &num_allocations);
+    assert(!err && num_alloc_size == sizeof(num_allocations));
+    mem_reqs = malloc(num_allocations * sizeof(XGL_MEMORY_REQUIREMENTS));
+    demo->vertices.mem = malloc(num_allocations * sizeof(XGL_GPU_MEMORY));
+    demo->vertices.num_mem = num_allocations;
+    err = xglGetObjectInfo(demo->vertices.buf,
             XGL_INFO_TYPE_MEMORY_REQUIREMENTS,
-            &mem_reqs_size, &mem_reqs);
-    assert(!err && mem_reqs_size == sizeof(mem_reqs));
-    mem_alloc.allocationSize = mem_reqs.size;
-    mem_alloc.alignment = mem_reqs.alignment;
-    mem_alloc.heapCount = mem_reqs.heapCount;
-    mem_alloc.pHeaps = mem_reqs.pHeaps;
-    memcpy((XGL_UINT *)mem_alloc.pHeaps, mem_reqs.pHeaps,
-            sizeof(mem_reqs.pHeaps[0]) * mem_reqs.heapCount);
-
-    err = xglAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem);
-    assert(!err);
+            &mem_reqs_size, mem_reqs);
+    assert(!err && mem_reqs_size == sizeof(*mem_reqs));
+    err = xglGetObjectInfo(demo->vertices.buf,
+                    XGL_INFO_TYPE_BUFFER_MEMORY_REQUIREMENTS,
+                    &buf_reqs_size, &buf_reqs);
+    assert(!err && buf_reqs_size == sizeof(XGL_BUFFER_MEMORY_REQUIREMENTS));
+    buf_alloc.usage = buf_reqs.usage;
+    for (XGL_UINT i = 0; i < num_allocations; i ++) {
+        mem_alloc.allocationSize = mem_reqs[i].size;
+        mem_alloc.alignment = mem_reqs[i].alignment;
+        mem_alloc.heapCount = mem_reqs[i].heapCount;
+        mem_alloc.pHeaps = mem_reqs[i].pHeaps;
+        memcpy(mem_alloc.pHeaps, mem_reqs[i].pHeaps,
+                sizeof(mem_reqs[i].pHeaps[0]) * mem_reqs[i].heapCount);
 
-    err = xglMapMemory(demo->vertices.mem, 0, &data);
-    assert(!err);
+        err = xglAllocMemory(demo->device, &mem_alloc, &demo->vertices.mem[i]);
+        assert(!err);
 
-    memcpy(data, vb, sizeof(vb));
+        err = xglMapMemory(demo->vertices.mem[i], 0, &data);
+        assert(!err);
 
-    err = xglUnmapMemory(demo->vertices.mem);
-    assert(!err);
+        memcpy(data, vb, sizeof(vb));
 
-    err = xglBindObjectMemory(demo->vertices.buf, 0, demo->vertices.mem, 0);
-    assert(!err);
+        err = xglUnmapMemory(demo->vertices.mem[i]);
+        assert(!err);
+
+        err = xglBindObjectMemory(demo->vertices.buf, i, demo->vertices.mem[i], 0);
+        assert(!err);
+    }
 
     demo->vertices.vi.sType = XGL_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_CREATE_INFO;
     demo->vertices.vi.pNext = NULL;
@@ -1065,7 +1120,8 @@ static void demo_cleanup(struct demo *demo)
 
     xglBindObjectMemory(demo->vertices.buf, 0, XGL_NULL_HANDLE, 0);
     xglDestroyObject(demo->vertices.buf);
-    xglFreeMemory(demo->vertices.mem);
+    for (j = 0; j < demo->vertices.num_mem; j++)
+        xglFreeMemory(demo->vertices.mem[j]);
 
     for (i = 0; i < DEMO_TEXTURE_COUNT; i++) {
         xglDestroyObject(demo->textures[i].view);
diff --git a/icd/common/icd-format.c b/icd/common/icd-format.c
index d53d4248..688ab4fc 100644
--- a/icd/common/icd-format.c
+++ b/icd/common/icd-format.c
@@ -78,6 +78,72 @@ size_t icd_format_get_size(XGL_FORMAT format)
     return icd_format_table[format.channelFormat].size;
 }
 
+XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format)
+{
+    if (icd_format_is_undef(format))
+        assert(!"undefined format");
+    if (icd_format_is_compressed(format)) {
+        switch (icd_format_get_size(format)) {
+        case 8:
+            return XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK;
+        case 16:
+            return XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK;
+        default:
+            assert(!"illegal compressed format");
+        }
+    } else if (icd_format_is_ds(format)) {
+        switch (icd_format_get_size(format)) {
+        case 1:
+            return XGL_IMAGE_FORMAT_CLASS_S8;
+        case 2:
+            return XGL_IMAGE_FORMAT_CLASS_D16;
+        case 3:
+            switch (icd_format_get_channel_count(format)) {
+            case 1:
+                return XGL_IMAGE_FORMAT_CLASS_D24;
+            case 2:
+                return XGL_IMAGE_FORMAT_CLASS_D16S8;
+            default:
+                assert(!"illegal depth stencil format channels");
+            }
+        case 4:
+            switch (icd_format_get_channel_count(format)) {
+            case 1:
+                return XGL_IMAGE_FORMAT_CLASS_D32;
+            case 2:
+                return XGL_IMAGE_FORMAT_CLASS_D24S8;
+            default:
+                assert(!"illegal depth stencil format channels");
+            }
+        case 5:
+            return XGL_IMAGE_FORMAT_CLASS_D32S8;
+        default:
+            assert(!"illegal depth stencil format");
+        }
+    } else { /* uncompressed color format */
+        switch (icd_format_get_size(format)) {
+        case 1:
+            return XGL_IMAGE_FORMAT_CLASS_8_BITS;
+        case 2:
+            return XGL_IMAGE_FORMAT_CLASS_16_BITS;
+        case 3:
+            return XGL_IMAGE_FORMAT_CLASS_24_BITS;
+        case 4:
+            return XGL_IMAGE_FORMAT_CLASS_32_BITS;
+        case 6:
+            return XGL_IMAGE_FORMAT_CLASS_48_BITS;
+        case 8:
+            return XGL_IMAGE_FORMAT_CLASS_64_BITS;
+        case 12:
+            return XGL_IMAGE_FORMAT_CLASS_96_BITS;
+        case 16:
+            return XGL_IMAGE_FORMAT_CLASS_128_BITS;
+        default:
+            assert(!"illegal uncompressed color format");
+        }
+    }
+}
+
 unsigned int icd_format_get_channel_count(XGL_FORMAT format)
 {
     return icd_format_table[format.channelFormat].channel_count;
diff --git a/icd/common/icd-format.h b/icd/common/icd-format.h
index e628b1b0..9c417001 100644
--- a/icd/common/icd-format.h
+++ b/icd/common/icd-format.h
@@ -105,6 +105,8 @@ static inline int icd_format_get_block_width(XGL_FORMAT format)
 
 size_t icd_format_get_size(XGL_FORMAT format);
 
+XGL_IMAGE_FORMAT_CLASS icd_format_get_class(XGL_FORMAT format);
+
 unsigned int icd_format_get_channel_count(XGL_FORMAT format);
 
 void icd_format_get_raw_value(XGL_FORMAT format,
diff --git a/include/xgl.h b/include/xgl.h
index 80f0a64e..45c69d4a 100644
--- a/include/xgl.h
+++ b/include/xgl.h
@@ -952,6 +952,8 @@ typedef enum _XGL_STRUCTURE_TYPE
     XGL_STRUCTURE_TYPE_UPDATE_IMAGES                        = 51,
     XGL_STRUCTURE_TYPE_UPDATE_BUFFERS                       = 52,
     XGL_STRUCTURE_TYPE_UPDATE_AS_COPY                       = 53,
+    XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO             = 54,
+    XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO              = 55,
     XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE)
 } XGL_STRUCTURE_TYPE;
 
@@ -991,16 +993,24 @@ typedef enum _XGL_MEMORY_ALLOC_FLAGS
     XGL_MEMORY_ALLOC_SHAREABLE_BIT                          = 0x00000001,
 } XGL_MEMORY_ALLOC_FLAGS;
 
-// Buffer usage flags
+// Buffer and buffer allocation usage flags
 typedef enum _XGL_BUFFER_USAGE_FLAGS
 {
-    XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT                 = 0x00000001,   // Shader read (e.g. TBO, image buffer, UBO, SBBO)
+    XGL_BUFFER_USAGE_GENERAL                                = 0x00000000,   // no special usage
+    XGL_BUFFER_USAGE_SHADER_ACCESS_READ_BIT                 = 0x00000001,   // Shader read (e.g. TBO, image buffer, UBO, SSBO)
     XGL_BUFFER_USAGE_SHADER_ACCESS_WRITE_BIT                = 0x00000002,   // Shader write (e.g. image buffer, SSBO)
     XGL_BUFFER_USAGE_SHADER_ACCESS_ATOMIC_BIT               = 0x00000004,   // Shader atomic operations (e.g. image buffer, SSBO)
-    XGL_BUFFER_USAGE_UNIFORM_READ_BIT                       = 0x00000008,   // Uniform read (UBO)
-    XGL_BUFFER_USAGE_INDEX_FETCH_BIT                        = 0x00000010,   // Fixed function index fetch (index buffer)
-    XGL_BUFFER_USAGE_VERTEX_FETCH_BIT                       = 0x00000020,   // Fixed function vertex fetch (VBO)
-    XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT           = 0x00000040,   // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
+    XGL_BUFFER_USAGE_TRANSFER_SOURCE_BIT                    = 0x00000008,   // used as a source for copies
+    XGL_BUFFER_USAGE_TRANSFER_DESTINATION_BIT               = 0x00000010,   // used as a destination for copies
+    XGL_BUFFER_USAGE_UNIFORM_READ_BIT                       = 0x00000020,   // Uniform read (UBO)
+    XGL_BUFFER_USAGE_INDEX_FETCH_BIT                        = 0x00000040,   // Fixed function index fetch (index buffer)
+    XGL_BUFFER_USAGE_VERTEX_FETCH_BIT                       = 0x00000080,   // Fixed function vertex fetch (VBO)
+    XGL_BUFFER_USAGE_SHADER_STORAGE_BIT                     = 0x00000100,   // Shader storage buffer (SSBO)
+    XGL_BUFFER_USAGE_RAW_BUFFER_BIT                         = 0x00000200,   // used as a raw buffer
+    XGL_BUFFER_USAGE_INDIRECT_PARAMETER_FETCH_BIT           = 0x00000400,   // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer)
+    XGL_BUFFER_USAGE_TEXTURE_BUFFER_BIT                     = 0x00000800,   // texture buffer (TBO)
+    XGL_BUFFER_USAGE_IMAGE_BUFFER_BIT                       = 0x00001000,   // image buffer (load/store)
+    XGL_MAX_ENUM(_XGL_BUFFER_USAGE_FLAGS)
 } XGL_BUFFER_USAGE_FLAGS;
 
 // Buffer flags
@@ -1022,14 +1032,44 @@ typedef enum _XGL_BUFFER_VIEW_TYPE
     XGL_MAX_ENUM(_XGL_BUFFER_VIEW_TYPE)
 } XGL_BUFFER_VIEW_TYPE;
 
-// Image usage flags
+// Images memory allocations can be used for resources of a given format class.
+typedef enum _XGL_IMAGE_FORMAT_CLASS
+{
+    XGL_IMAGE_FORMAT_CLASS_128_BITS                         = 1,  // color formats
+    XGL_IMAGE_FORMAT_CLASS_96_BITS                          = 2,
+    XGL_IMAGE_FORMAT_CLASS_64_BITS                          = 3,
+    XGL_IMAGE_FORMAT_CLASS_48_BITS                          = 4,
+    XGL_IMAGE_FORMAT_CLASS_32_BITS                          = 5,
+    XGL_IMAGE_FORMAT_CLASS_24_BITS                          = 6,
+    XGL_IMAGE_FORMAT_CLASS_16_BITS                          = 7,
+    XGL_IMAGE_FORMAT_CLASS_8_BITS                           = 8,
+    XGL_IMAGE_FORMAT_CLASS_128_BIT_BLOCK                    = 9,  // 128-bit block compressed formats
+    XGL_IMAGE_FORMAT_CLASS_64_BIT_BLOCK                     = 10, // 64-bit block compressed formats
+    XGL_IMAGE_FORMAT_CLASS_D32                              = 11, // D32_SFLOAT
+    XGL_IMAGE_FORMAT_CLASS_D24                              = 12, // D24_UNORM
+    XGL_IMAGE_FORMAT_CLASS_D16                              = 13, // D16_UNORM
+    XGL_IMAGE_FORMAT_CLASS_S8                               = 14, // S8_UINT
+    XGL_IMAGE_FORMAT_CLASS_D32S8                            = 15, // D32_SFLOAT_S8_UINT
+    XGL_IMAGE_FORMAT_CLASS_D24S8                            = 16, // D24_UNORM_S8_UINT
+    XGL_IMAGE_FORMAT_CLASS_D16S8                            = 17, // D16_UNORM_S8_UINT
+    XGL_IMAGE_FORMAT_CLASS_LINEAR                           = 18, // used for pitch-linear (transparent) textures
+    XGL_MAX_ENUM(_XGL_IMAGE_FORMAT_CLASS)
+} XGL_IMAGE_FORMAT_CLASS;
+
+// Image and image allocation usage flags
 typedef enum _XGL_IMAGE_USAGE_FLAGS
 {
-    XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,
-    XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,
-    XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT                = 0x00000004,
-    XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000008,
-    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000010,
+    XGL_IMAGE_USAGE_GENERAL                                 = 0x00000000,   // no special usage
+    XGL_IMAGE_USAGE_SHADER_ACCESS_READ_BIT                  = 0x00000001,   // shader read (e.g. texture, image)
+    XGL_IMAGE_USAGE_SHADER_ACCESS_WRITE_BIT                 = 0x00000002,   // shader write (e.g. image)
+    XGL_IMAGE_USAGE_SHADER_ACCESS_ATOMIC_BIT                = 0x00000004,   // shader atomic operations (e.g. image)
+    XGL_IMAGE_USAGE_TRANSFER_SOURCE_BIT                     = 0x00000008,   // used as a source for copies
+    XGL_IMAGE_USAGE_TRANSFER_DESTINATION_BIT                = 0x00000010,   // used as a destination for copies
+    XGL_IMAGE_USAGE_TEXTURE_BIT                             = 0x00000020,   // opaque texture (2d, 3d, etc.)
+    XGL_IMAGE_USAGE_IMAGE_BIT                               = 0x00000040,   // opaque image (2d, 3d, etc.)
+    XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT                    = 0x00000080,   // framebuffer color attachment
+    XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT                       = 0x00000100,   // framebuffer depth/stencil
+    XGL_MAX_ENUM(_XGL_IMAGE_USAGE_FLAGS)
 } XGL_IMAGE_USAGE_FLAGS;
 
 // Image flags
@@ -1279,6 +1319,26 @@ typedef struct _XGL_MEMORY_ALLOC_INFO
     XGL_MEMORY_PRIORITY                     memPriority;
 } XGL_MEMORY_ALLOC_INFO;
 
+// This structure is included in the XGL_MEMORY_ALLOC_INFO chain
+// for memory regions allocated for buffer usage.
+typedef struct _XGL_MEMORY_ALLOC_BUFFER_INFO
+{
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_BUFFER_INFO
+    XGL_VOID*                               pNext;                      // Pointer to next structure
+    XGL_FLAGS                               usage;                      // XGL_BUFFER_USAGE_FLAGS
+} XGL_MEMORY_ALLOC_BUFFER_INFO;
+
+// This structure is included in the XGL_MEMORY_ALLOC_INFO chain
+// for memory regions allocated for buffer usage.
+typedef struct _XGL_MEMORY_ALLOC_IMAGE_INFO
+{
+    XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_ALLOC_IMAGE_INFO
+    XGL_VOID*                               pNext;                      // Pointer to next structure
+    XGL_FLAGS                               usage;                      // XGL_IMAGE_USAGE_FLAGS
+    XGL_IMAGE_FORMAT_CLASS                  formatClass;
+    XGL_UINT                                samples;
+} XGL_MEMORY_ALLOC_IMAGE_INFO;
+
 typedef struct _XGL_MEMORY_OPEN_INFO
 {
     XGL_STRUCTURE_TYPE                      sType;                      // Must be XGL_STRUCTURE_TYPE_MEMORY_OPEN_INFO
@@ -1302,6 +1362,18 @@ typedef struct _XGL_MEMORY_REQUIREMENTS
     XGL_UINT*                               pHeaps;
 } XGL_MEMORY_REQUIREMENTS;
 
+typedef struct _XGL_BUFFER_MEMORY_REQUIREMENTS
+{
+    XGL_FLAGS                               usage;                      // XGL_BUFFER_USAGE_FLAGS
+} XGL_BUFFER_MEMORY_REQUIREMENTS;
+
+typedef struct _XGL_IMAGE_MEMORY_REQUIREMENTS
+{
+    XGL_FLAGS                               usage;                      // XGL_IMAGE_USAGE_FLAGS
+    XGL_IMAGE_FORMAT_CLASS                  formatClass;
+    XGL_UINT                                samples;
+} XGL_IMAGE_MEMORY_REQUIREMENTS;
+
 typedef struct _XGL_FORMAT_PROPERTIES
 {
     XGL_FLAGS                               linearTilingFeatures;      // XGL_FORMAT_FEATURE_FLAGS