From 3bd2d89e7c6ce4ef29379d5d0ae969323ef3e211 Mon Sep 17 00:00:00 2001 From: Mike Stroyan Date: Thu, 4 Dec 2014 11:08:39 +0000 Subject: xgl: Resource transition proposal from Bug 12904. Added resource transition proposal from Bug 12904. Updated function prototypes. Added XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT based on Intel's request. Unless this flag is specified, image views created from the image must match the base format. xgl.py: changes for resource tracking loader: changes for resource tracking icd: changes for resource tracking tests: changes for resource tracking demos: changes for resource tracking --- demos/cube.c | 9 +-- demos/tri.c | 7 +- include/xgl.h | 224 ++++++++++++++++++++++++++++++++------------------- include/xglLayer.h | 4 +- layers/draw_state.c | 18 ++++- layers/mem_tracker.c | 18 ++++- xgl.py | 25 +++--- 7 files changed, 188 insertions(+), 117 deletions(-) diff --git a/demos/cube.c b/demos/cube.c index f5b27cb3..155729ff 100644 --- a/demos/cube.c +++ b/demos/cube.c @@ -262,12 +262,11 @@ static void demo_draw_build_cmd(struct demo *demo) { const XGL_COLOR_ATTACHMENT_BIND_INFO color_attachment = { .view = demo->buffers[demo->current_buffer].view, - .colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL, + .layout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, }; const XGL_DEPTH_STENCIL_BIND_INFO depth_stencil = { .view = demo->depth.view, - .depthState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL, - .stencilState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL, + .layout = XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }; const XGL_FLOAT clear_color[4] = { 0.2f, 0.2f, 0.2f, 0.2f }; const XGL_FLOAT clear_depth = 1.0f; @@ -880,8 +879,6 @@ void demo_prepare_cube_data_buffer(struct demo *demo) demo->uniform_data.attach.sType = XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO; demo->uniform_data.attach.view = demo->uniform_data.view; - // no preparation.. - demo->uniform_data.attach.state = XGL_BUFFER_STATE_DATA_TRANSFER; } static void demo_prepare_descriptor_set(struct demo *demo) @@ -908,7 +905,7 @@ static void demo_prepare_descriptor_set(struct demo *demo) image_view.sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO; image_view.pNext = NULL; image_view.view = demo->textures[0].view; - image_view.state = XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY; + image_view.layout = XGL_IMAGE_LAYOUT_GENERAL; xglAttachSamplerDescriptors(demo->dset, 1, 1, &demo->textures[0].sampler); xglAttachImageViewDescriptors(demo->dset, 2, 1, &image_view); diff --git a/demos/tri.c b/demos/tri.c index 82aadc74..8d746987 100644 --- a/demos/tri.c +++ b/demos/tri.c @@ -86,12 +86,11 @@ static void demo_draw_build_cmd(struct demo *demo) { const XGL_COLOR_ATTACHMENT_BIND_INFO color_attachment = { .view = demo->buffers[demo->current_buffer].view, - .colorAttachmentState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL, + .layout = XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, }; const XGL_DEPTH_STENCIL_BIND_INFO depth_stencil = { .view = demo->depth.view, - .depthState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL, - .stencilState = XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL, + .layout = XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, }; const XGL_FLOAT clear_color[4] = { 0.2f, 0.2f, 0.2f, 0.2f }; const XGL_FLOAT clear_depth = 0.9f; @@ -565,7 +564,7 @@ static void demo_prepare_descriptor_set(struct demo *demo) .sType = XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO, .pNext = NULL, .view = demo->textures[i].view, - .state = XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY, + .layout = XGL_IMAGE_LAYOUT_GENERAL, }; xglAttachSamplerDescriptors(demo->dset, 2 * i, 1, diff --git a/include/xgl.h b/include/xgl.h index 724211e8..f17305bc 100644 --- a/include/xgl.h +++ b/include/xgl.h @@ -148,50 +148,56 @@ typedef enum _XGL_MEMORY_PRIORITY XGL_NUM_MEMORY_PRIORITY = (XGL_MEMORY_PRIORITY_END_RANGE - XGL_MEMORY_PRIORITY_BEGIN_RANGE + 1), } XGL_MEMORY_PRIORITY; -typedef enum _XGL_BUFFER_STATE -{ - XGL_BUFFER_STATE_DATA_TRANSFER = 0x00000000, - XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_ONLY = 0x00000001, - XGL_BUFFER_STATE_GRAPHICS_SHADER_WRITE_ONLY = 0x00000002, - XGL_BUFFER_STATE_GRAPHICS_SHADER_READ_WRITE = 0x00000003, - XGL_BUFFER_STATE_COMPUTE_SHADER_READ_ONLY = 0x00000004, - XGL_BUFFER_STATE_COMPUTE_SHADER_WRITE_ONLY = 0x00000005, - XGL_BUFFER_STATE_COMPUTE_SHADER_READ_WRITE = 0x00000006, - XGL_BUFFER_STATE_MULTI_SHADER_READ_ONLY = 0x00000007, - XGL_BUFFER_STATE_INDEX_DATA = 0x00000008, - XGL_BUFFER_STATE_INDIRECT_ARG = 0x00000009, - XGL_BUFFER_STATE_WRITE_TIMESTAMP = 0x0000000A, - XGL_BUFFER_STATE_QUEUE_ATOMIC = 0x0000000B, - - XGL_BUFFER_STATE_BEGIN_RANGE = XGL_BUFFER_STATE_DATA_TRANSFER, - XGL_BUFFER_STATE_END_RANGE = XGL_BUFFER_STATE_QUEUE_ATOMIC, - XGL_NUM_BUFFER_STATE = (XGL_BUFFER_STATE_END_RANGE - XGL_BUFFER_STATE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_BUFFER_STATE) -} XGL_BUFFER_STATE; - -typedef enum _XGL_IMAGE_STATE -{ - XGL_IMAGE_STATE_DATA_TRANSFER = 0x00000000, - XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_ONLY = 0x00000001, - XGL_IMAGE_STATE_GRAPHICS_SHADER_WRITE_ONLY = 0x00000002, - XGL_IMAGE_STATE_GRAPHICS_SHADER_READ_WRITE = 0x00000003, - XGL_IMAGE_STATE_COMPUTE_SHADER_READ_ONLY = 0x00000004, - XGL_IMAGE_STATE_COMPUTE_SHADER_WRITE_ONLY = 0x00000005, - XGL_IMAGE_STATE_COMPUTE_SHADER_READ_WRITE = 0x00000006, - XGL_IMAGE_STATE_MULTI_SHADER_READ_ONLY = 0x00000007, - XGL_IMAGE_STATE_TARGET_AND_SHADER_READ_ONLY = 0x00000008, - XGL_IMAGE_STATE_UNINITIALIZED_TARGET = 0x00000009, - XGL_IMAGE_STATE_TARGET_RENDER_ACCESS_OPTIMAL = 0x0000000A, - XGL_IMAGE_STATE_TARGET_SHADER_ACCESS_OPTIMAL = 0x0000000B, - XGL_IMAGE_STATE_CLEAR = 0x0000000C, - XGL_IMAGE_STATE_RESOLVE_SOURCE = 0x0000000D, - XGL_IMAGE_STATE_RESOLVE_DESTINATION = 0x0000000E, - - XGL_IMAGE_STATE_BEGIN_RANGE = XGL_IMAGE_STATE_DATA_TRANSFER, - XGL_IMAGE_STATE_END_RANGE = XGL_IMAGE_STATE_RESOLVE_DESTINATION, - XGL_NUM_IMAGE_STATE = (XGL_IMAGE_STATE_END_RANGE - XGL_IMAGE_STATE_BEGIN_RANGE + 1), - XGL_MAX_ENUM(_XGL_IMAGE_STATE) -} XGL_IMAGE_STATE; +typedef enum _XGL_IMAGE_LAYOUT +{ + XGL_IMAGE_LAYOUT_GENERAL = 0x00000000, // General layout when image can be used for any kind of access + XGL_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 0x00000001, // Optimal layout when image is only used for color attachment read/write + XGL_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000002, // Optimal layout when image is only used for depth/stencil attachment read/write + XGL_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000003, // Optimal layout when image is used for read only depth/stencil attachment and shader access + XGL_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000004, // Optimal layout when image is used for read only shader access + XGL_IMAGE_LAYOUT_CLEAR_OPTIMAL = 0x00000005, // Optimal layout when image is used only for clear operations + XGL_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000006, // Optimal layout when image is used only as source of transfer operations + XGL_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000007, // Optimal layout when image is used only as destination of transfer operations +} XGL_IMAGE_LAYOUT; + +typedef enum _XGL_SET_EVENT +{ + XGL_SET_EVENT_TOP_OF_PIPE = 0x00000001, // Set event before the GPU starts processing subsequent command + XGL_SET_EVENT_VERTEX_PROCESSING_COMPLETE = 0x00000002, // Set event when all pending vertex processing is complete + XGL_SET_EVENT_FRAGMENT_PROCESSING_COMPLETE = 0x00000003, // Set event when all pending fragment shader executions are complete + XGL_SET_EVENT_GRAPHICS_PIPELINE_COMPLETE = 0x00000004, // Set event when all pending graphics operations are complete + XGL_SET_EVENT_COMPUTE_PIPELINE_COMPLETE = 0x00000005, // Set event when all pending compute operations are complete + XGL_SET_EVENT_TRANSFER_COMPLETE = 0x00000006, // Set event when all pending transfer operations are complete + XGL_SET_EVENT_GPU_COMMANDS_COMPLETE = 0x00000007, // Set event when all pending GPU work is complete +} XGL_SET_EVENT; + +typedef enum _XGL_WAIT_EVENT +{ + XGL_WAIT_EVENT_TOP_OF_PIPE = 0x00000001, // Wait event before the GPU starts processing subsequent commands + XGL_WAIT_EVENT_BEFORE_FRAGMENT_PROCESSING = 0x00000002, // Wait event before subsequent fragment processing +} XGL_WAIT_EVENT; + +typedef enum _XGL_MEMORY_OUTPUT_FLAGS +{ + XGL_MEMORY_OUTPUT_CPU_WRITE_BIT = 0x00000001, // Controls output coherency of CPU writes + XGL_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002, // Controls output coherency of generic shader writes + XGL_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004, // Controls output coherency of color attachment writes + XGL_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008, // Controls output coherency of depth/stencil attachment writes + XGL_MEMORY_OUTPUT_COPY_BIT = 0x00000010, // Controls output coherency of copy operations +} XGL_MEMORY_OUTPUT_FLAGS; + +typedef enum _XGL_MEMORY_INPUT_FLAGS +{ + XGL_MEMORY_INPUT_CPU_READ_BIT = 0x00000001, // Controls input coherency of CPU reads + XGL_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002, // Controls input coherency of indirect command reads + XGL_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004, // Controls input coherency of index fetches + XGL_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008, // Controls input coherency of vertex attribute fetches + XGL_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010, // Controls input coherency of uniform buffer reads + XGL_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020, // Controls input coherency of generic shader reads + XGL_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040, // Controls input coherency of color attachment reads + XGL_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080, // Controls input coherency of depth/stencil attachment reads + XGL_MEMORY_INPUT_COPY_BIT = 0x00000100, // Controls input coherency of copy operations +} XGL_MEMORY_INPUT_FLAGS; typedef enum _XGL_ATTACHMENT_LOAD_OP { @@ -878,7 +884,7 @@ typedef enum _XGL_STRUCTURE_TYPE XGL_STRUCTURE_TYPE_PEER_MEMORY_OPEN_INFO = 5, XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO = 6, XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO = 7, - XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION = 8, + XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO = 8, XGL_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 9, XGL_STRUCTURE_TYPE_COLOR_ATTACHMENT_VIEW_CREATE_INFO = 10, XGL_STRUCTURE_TYPE_DEPTH_STENCIL_VIEW_CREATE_INFO = 11, @@ -914,6 +920,10 @@ typedef enum _XGL_STRUCTURE_TYPE XGL_STRUCTURE_TYPE_CMD_BUFFER_GRAPHICS_BEGIN_INFO = 41, XGL_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 42, XGL_STRUCTURE_TYPE_LAYER_CREATE_INFO = 43, + XGL_STRUCTURE_TYPE_PIPELINE_BARRIER = 44, + XGL_STRUCTURE_TYPE_MEMORY_BARRIER = 45, + XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 46, + XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 47, XGL_MAX_ENUM(_XGL_STRUCTURE_TYPE) } XGL_STRUCTURE_TYPE; @@ -1001,6 +1011,7 @@ typedef enum _XGL_IMAGE_CREATE_FLAGS XGL_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002, XGL_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004, XGL_IMAGE_CREATE_SPARSE_BIT = 0x00000008, + XGL_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010, // Allows image views to have different format than the base image } XGL_IMAGE_CREATE_FLAGS; // Depth-stencil view creation flags @@ -1287,7 +1298,6 @@ typedef struct _XGL_BUFFER_VIEW_ATTACH_INFO XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_VIEW_ATTACH_INFO XGL_VOID* pNext; // Pointer to next structure XGL_BUFFER_VIEW view; - XGL_BUFFER_STATE state; } XGL_BUFFER_VIEW_ATTACH_INFO; typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO @@ -1295,20 +1305,9 @@ typedef struct _XGL_IMAGE_VIEW_ATTACH_INFO XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_VIEW_ATTACH_INFO XGL_VOID* pNext; // Pointer to next structure XGL_IMAGE_VIEW view; - XGL_IMAGE_STATE state; + XGL_IMAGE_LAYOUT layout; } XGL_IMAGE_VIEW_ATTACH_INFO; -typedef struct _XGL_BUFFER_STATE_TRANSITION -{ - XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_STATE_TRANSITION - XGL_VOID* pNext; // Pointer to next structure - XGL_BUFFER buffer; - XGL_BUFFER_STATE oldState; - XGL_BUFFER_STATE newState; - XGL_GPU_SIZE offset; - XGL_GPU_SIZE regionSize; -} XGL_BUFFER_STATE_TRANSITION; - typedef struct _XGL_BUFFER_CREATE_INFO { XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_CREATE_INFO @@ -1347,13 +1346,72 @@ typedef struct _XGL_IMAGE_SUBRESOURCE_RANGE XGL_UINT arraySize; } XGL_IMAGE_SUBRESOURCE_RANGE; -typedef struct _XGL_IMAGE_STATE_TRANSITION +typedef struct _XGL_EVENT_WAIT_INFO { - XGL_IMAGE image; - XGL_IMAGE_STATE oldState; - XGL_IMAGE_STATE newState; - XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange; -} XGL_IMAGE_STATE_TRANSITION; + XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_EVENT_WAIT_INFO + const XGL_VOID* pNext; // Pointer to next structure. + + XGL_UINT eventCount; // Number of events to wait on + const XGL_EVENT* pEvents; // Array of event objects to wait on + + XGL_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen + + XGL_UINT memBarrierCount; // Number of memory barriers + const XGL_VOID* pMemBarriers; // Array of pointers to memory barriers (any of them can be either XGL_MEMORY_BARRIER, XGL_BUFFER_MEMORY_BARRIER, or XGL_IMAGE_MEMORY_BARRIER) +} XGL_EVENT_WAIT_INFO; + +typedef struct _XGL_PIPELINE_BARRIER +{ + XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_PIPELINE_BARRIER + const XGL_VOID* pNext; // Pointer to next structure. + + XGL_UINT eventCount; // Number of events to wait on + const XGL_SET_EVENT* pEvents; // Array of pipeline events to wait on + + XGL_WAIT_EVENT waitEvent; // Pipeline event where the wait should happen + + XGL_UINT memBarrierCount; // Number of memory barriers + const XGL_VOID* pMemBarriers; // Array of pointers to memory barriers (any of them can be either XGL_MEMORY_BARRIER, XGL_BUFFER_MEMORY_BARRIER, or XGL_IMAGE_MEMORY_BARRIER) +} XGL_PIPELINE_BARRIER; + +typedef struct _XGL_MEMORY_BARRIER +{ + XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_MEMORY_BARRIER + const XGL_VOID* pNext; // Pointer to next structure. + + XGL_FLAGS outputMask; // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS) + XGL_FLAGS inputMask; // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS) +} XGL_MEMORY_BARRIER; + +typedef struct _XGL_BUFFER_MEMORY_BARRIER +{ + XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER + const XGL_VOID* pNext; // Pointer to next structure. + + XGL_FLAGS outputMask; // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS) + XGL_FLAGS inputMask; // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS) + + XGL_BUFFER buffer; // Buffer to sync + + XGL_GPU_SIZE offset; // Offset within the buffer to sync + XGL_GPU_SIZE size; // Amount of bytes to sync +} XGL_BUFFER_MEMORY_BARRIER; + +typedef struct _XGL_IMAGE_MEMORY_BARRIER +{ + XGL_STRUCTURE_TYPE sType; // Must be XGL_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER + const XGL_VOID* pNext; // Pointer to next structure. + + XGL_FLAGS outputMask; // Outputs the barrier should sync (see XGL_MEMORY_OUTPUT_FLAGS) + XGL_FLAGS inputMask; // Inputs the barrier should sync to (see XGL_MEMORY_INPUT_FLAGS) + + XGL_IMAGE_LAYOUT oldLayout; // Current layout of the image + XGL_IMAGE_LAYOUT newLayout; // New layout to transition the image to + + XGL_IMAGE image; // Image to sync + + XGL_IMAGE_SUBRESOURCE_RANGE subresourceRange; // Subresource range to sync +} XGL_IMAGE_MEMORY_BARRIER; typedef struct _XGL_IMAGE_CREATE_INFO { @@ -1424,14 +1482,13 @@ typedef struct _XGL_DEPTH_STENCIL_VIEW_CREATE_INFO typedef struct _XGL_COLOR_ATTACHMENT_BIND_INFO { XGL_COLOR_ATTACHMENT_VIEW view; - XGL_IMAGE_STATE colorAttachmentState; // XGL_IMAGE_STATE + XGL_IMAGE_LAYOUT layout; } XGL_COLOR_ATTACHMENT_BIND_INFO; typedef struct _XGL_DEPTH_STENCIL_BIND_INFO { XGL_DEPTH_STENCIL_VIEW view; - XGL_IMAGE_STATE depthState; // XGL_IMAGE_STATE - XGL_IMAGE_STATE stencilState; // XGL_IMAGE_STATE + XGL_IMAGE_LAYOUT layout; } XGL_DEPTH_STENCIL_BIND_INFO; typedef struct _XGL_BUFFER_COPY @@ -2010,8 +2067,6 @@ typedef XGL_VOID (XGLAPI *xglCmdBindDescriptorSetType)(XGL_CMD_BUFFER cmdBuffer, typedef XGL_VOID (XGLAPI *xglCmdBindDynamicBufferViewType)(XGL_CMD_BUFFER cmdBuffer, XGL_PIPELINE_BIND_POINT pipelineBindPoint, const XGL_BUFFER_VIEW_ATTACH_INFO* pBufferView); typedef XGL_VOID (XGLAPI *xglCmdBindVertexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT binding); typedef XGL_VOID (XGLAPI *xglCmdBindIndexBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType); -typedef XGL_VOID (XGLAPI *xglCmdPrepareBufferRegionsType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_BUFFER_STATE_TRANSITION* pStateTransitions); -typedef XGL_VOID (XGLAPI *xglCmdPrepareImagesType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT transitionCount, const XGL_IMAGE_STATE_TRANSITION* pStateTransitions); typedef XGL_VOID (XGLAPI *xglCmdDrawType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, XGL_UINT vertexCount, XGL_UINT firstInstance, XGL_UINT instanceCount); typedef XGL_VOID (XGLAPI *xglCmdDrawIndexedType)(XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstIndex, XGL_UINT indexCount, XGL_INT vertexOffset, XGL_UINT firstInstance, XGL_UINT instanceCount); typedef XGL_VOID (XGLAPI *xglCmdDrawIndirectType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER buffer, XGL_GPU_SIZE offset, XGL_UINT32 count, XGL_UINT32 stride); @@ -2022,15 +2077,17 @@ typedef XGL_VOID (XGLAPI *xglCmdCopyBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BU typedef XGL_VOID (XGLAPI *xglCmdCopyImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_IMAGE_COPY* pRegions); typedef XGL_VOID (XGLAPI *xglCmdCopyBufferToImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER srcBuffer, XGL_IMAGE destImage, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions); typedef XGL_VOID (XGLAPI *xglCmdCopyImageToBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_BUFFER destBuffer, XGL_UINT regionCount, const XGL_BUFFER_IMAGE_COPY* pRegions); -typedef XGL_VOID (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState); +typedef XGL_VOID (XGLAPI *xglCmdCloneImageDataType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout); typedef XGL_VOID (XGLAPI *xglCmdUpdateBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData); typedef XGL_VOID (XGLAPI *xglCmdFillBufferType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE fillSize, XGL_UINT32 data); typedef XGL_VOID (XGLAPI *xglCmdClearColorImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_FLOAT color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges); typedef XGL_VOID (XGLAPI *xglCmdClearColorImageRawType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, const XGL_UINT32 color[4], XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges); typedef XGL_VOID (XGLAPI *xglCmdClearDepthStencilType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE image, XGL_FLOAT depth, XGL_UINT32 stencil, XGL_UINT rangeCount, const XGL_IMAGE_SUBRESOURCE_RANGE* pRanges); typedef XGL_VOID (XGLAPI *xglCmdResolveImageType)(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE destImage, XGL_UINT rectCount, const XGL_IMAGE_RESOLVE* pRects); -typedef XGL_VOID (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event); +typedef XGL_VOID (XGLAPI *xglCmdSetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_SET_EVENT pipeEvent); typedef XGL_VOID (XGLAPI *xglCmdResetEventType)(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event); +typedef XGL_VOID (XGLAPI *xglCmdWaitEventsType)(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo); +typedef XGL_VOID (XGLAPI *xglCmdPipelineBarrierType)(XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier); typedef XGL_VOID (XGLAPI *xglCmdBufferAtomicType)(XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp); typedef XGL_VOID (XGLAPI *xglCmdBeginQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot, XGL_FLAGS flags); typedef XGL_VOID (XGLAPI *xglCmdEndQueryType)(XGL_CMD_BUFFER cmdBuffer, XGL_QUERY_POOL queryPool, XGL_UINT slot); @@ -2494,16 +2551,6 @@ XGL_VOID XGLAPI xglCmdBindIndexBuffer( XGL_GPU_SIZE offset, XGL_INDEX_TYPE indexType); -XGL_VOID XGLAPI xglCmdPrepareBufferRegions( - XGL_CMD_BUFFER cmdBuffer, - XGL_UINT transitionCount, - const XGL_BUFFER_STATE_TRANSITION* pStateTransitions); - -XGL_VOID XGLAPI xglCmdPrepareImages( - XGL_CMD_BUFFER cmdBuffer, - XGL_UINT transitionCount, - const XGL_IMAGE_STATE_TRANSITION* pStateTransitions); - XGL_VOID XGLAPI xglCmdDraw( XGL_CMD_BUFFER cmdBuffer, XGL_UINT firstVertex, @@ -2575,9 +2622,9 @@ XGL_VOID XGLAPI xglCmdCopyImageToBuffer( XGL_VOID XGLAPI xglCmdCloneImageData( XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, - XGL_IMAGE_STATE srcImageState, + XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, - XGL_IMAGE_STATE destImageState); + XGL_IMAGE_LAYOUT destImageLayout); XGL_VOID XGLAPI xglCmdUpdateBuffer( XGL_CMD_BUFFER cmdBuffer, @@ -2624,12 +2671,21 @@ XGL_VOID XGLAPI xglCmdResolveImage( XGL_VOID XGLAPI xglCmdSetEvent( XGL_CMD_BUFFER cmdBuffer, - XGL_EVENT event); + XGL_EVENT event, + XGL_SET_EVENT pipeEvent); XGL_VOID XGLAPI xglCmdResetEvent( XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event); +XGL_VOID XGLAPI xglCmdWaitEvents( + XGL_CMD_BUFFER cmdBuffer, + const XGL_EVENT_WAIT_INFO* pWaitInfo); + +XGL_VOID XGLAPI xglCmdPipelineBarrier( + XGL_CMD_BUFFER cmdBuffer, + const XGL_PIPELINE_BARRIER* pBarrier); + XGL_VOID XGLAPI xglCmdBufferAtomic( XGL_CMD_BUFFER cmdBuffer, XGL_BUFFER destBuffer, diff --git a/include/xglLayer.h b/include/xglLayer.h index 3803168e..494d77d2 100644 --- a/include/xglLayer.h +++ b/include/xglLayer.h @@ -105,8 +105,6 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE xglCmdBindDynamicBufferViewType CmdBindDynamicBufferView; xglCmdBindVertexBufferType CmdBindVertexBuffer; xglCmdBindIndexBufferType CmdBindIndexBuffer; - xglCmdPrepareBufferRegionsType CmdPrepareBufferRegions; - xglCmdPrepareImagesType CmdPrepareImages; xglCmdDrawType CmdDraw; xglCmdDrawIndexedType CmdDrawIndexed; xglCmdDrawIndirectType CmdDrawIndirect; @@ -126,6 +124,8 @@ typedef struct _XGL_LAYER_DISPATCH_TABLE xglCmdResolveImageType CmdResolveImage; xglCmdSetEventType CmdSetEvent; xglCmdResetEventType CmdResetEvent; + xglCmdWaitEventsType CmdWaitEvents; + xglCmdPipelineBarrierType CmdPipelineBarrier; xglCmdBufferAtomicType CmdBufferAtomic; xglCmdBeginQueryType CmdBeginQuery; xglCmdEndQueryType CmdEndQuery; diff --git a/layers/draw_state.c b/layers/draw_state.c index 2ba05bb1..1b379d74 100644 --- a/layers/draw_state.c +++ b/layers/draw_state.c @@ -1670,9 +1670,9 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCopyImageToMemory(XGL_CMD_BUFFER cmdBuffe nextTable.CmdCopyImageToMemory(cmdBuffer, srcImage, destMem, regionCount, pRegions); } -XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState) +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout) { - nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageState, destImage, destImageState); + nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdUpdateMemory(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData) @@ -1705,9 +1705,9 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XG nextTable.CmdResolveImage(cmdBuffer, srcImage, destImage, rectCount, pRects); } -XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event) +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_SET_EVENT pipeEvent) { - nextTable.CmdSetEvent(cmdBuffer, event); + nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event) @@ -1715,6 +1715,16 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_ nextTable.CmdResetEvent(cmdBuffer, event); } +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo) +{ + nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); +} + +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdPipelineBarrier( XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier) +{ + nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); +} + XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdMemoryAtomic(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp) { nextTable.CmdMemoryAtomic(cmdBuffer, destMem, destOffset, srcData, atomicOp); diff --git a/layers/mem_tracker.c b/layers/mem_tracker.c index 5003fcdb..4085b156 100644 --- a/layers/mem_tracker.c +++ b/layers/mem_tracker.c @@ -1847,7 +1847,7 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCopyImageToMemory(XGL_CMD_BUFFER cmdBuffe nextTable.CmdCopyImageToMemory(cmdBuffer, srcImage, destMem, regionCount, pRegions); } -XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_STATE srcImageState, XGL_IMAGE destImage, XGL_IMAGE_STATE destImageState) +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, XGL_IMAGE srcImage, XGL_IMAGE_LAYOUT srcImageLayout, XGL_IMAGE destImage, XGL_IMAGE_LAYOUT destImageLayout) { // TODO : Each image will have mem mapping so track them XGL_GPU_MEMORY mem = getMemBindingFromObject(srcImage); @@ -1862,7 +1862,7 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdCloneImageData(XGL_CMD_BUFFER cmdBuffer, sprintf(str, "In xglCmdCloneImageData() call unable to update binding of destImage mem %p to cmdBuffer %p", mem, cmdBuffer); layerCbMsg(XGL_DBG_MSG_ERROR, XGL_VALIDATION_LEVEL_0, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str); } - nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageState, destImage, destImageState); + nextTable.CmdCloneImageData(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout); } XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdUpdateMemory(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_GPU_SIZE dataSize, const XGL_UINT32* pData) @@ -1938,9 +1938,9 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResolveImage(XGL_CMD_BUFFER cmdBuffer, XG nextTable.CmdResolveImage(cmdBuffer, srcImage, destImage, rectCount, pRects); } -XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event) +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdSetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event, XGL_SET_EVENT pipeEvent) { - nextTable.CmdSetEvent(cmdBuffer, event); + nextTable.CmdSetEvent(cmdBuffer, event, pipeEvent); } XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_EVENT event) @@ -1948,6 +1948,16 @@ XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdResetEvent(XGL_CMD_BUFFER cmdBuffer, XGL_ nextTable.CmdResetEvent(cmdBuffer, event); } +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdWaitEvents(XGL_CMD_BUFFER cmdBuffer, const XGL_EVENT_WAIT_INFO* pWaitInfo) +{ + nextTable.CmdWaitEvents(cmdBuffer, pWaitInfo); +} + +XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdPipelineBarrier( XGL_CMD_BUFFER cmdBuffer, const XGL_PIPELINE_BARRIER* pBarrier) +{ + nextTable.CmdPipelineBarrier(cmdBuffer, pBarrier); +} + XGL_LAYER_EXPORT XGL_VOID XGLAPI xglCmdMemoryAtomic(XGL_CMD_BUFFER cmdBuffer, XGL_GPU_MEMORY destMem, XGL_GPU_SIZE destOffset, XGL_UINT64 srcData, XGL_ATOMIC_OP atomicOp) { if (XGL_FALSE == updateCBBinding(cmdBuffer, destMem)) { diff --git a/xgl.py b/xgl.py index 996f84ca..0e410562 100644 --- a/xgl.py +++ b/xgl.py @@ -615,16 +615,6 @@ core = Extension( Param("XGL_GPU_SIZE", "offset"), Param("XGL_INDEX_TYPE", "indexType")]), - Proto("XGL_VOID", "CmdPrepareBufferRegions", - [Param("XGL_CMD_BUFFER", "cmdBuffer"), - Param("XGL_UINT", "transitionCount"), - Param("const XGL_BUFFER_STATE_TRANSITION*", "pStateTransitions")]), - - Proto("XGL_VOID", "CmdPrepareImages", - [Param("XGL_CMD_BUFFER", "cmdBuffer"), - Param("XGL_UINT", "transitionCount"), - Param("const XGL_IMAGE_STATE_TRANSITION*", "pStateTransitions")]), - Proto("XGL_VOID", "CmdDraw", [Param("XGL_CMD_BUFFER", "cmdBuffer"), Param("XGL_UINT", "firstVertex"), @@ -696,9 +686,9 @@ core = Extension( Proto("XGL_VOID", "CmdCloneImageData", [Param("XGL_CMD_BUFFER", "cmdBuffer"), Param("XGL_IMAGE", "srcImage"), - Param("XGL_IMAGE_STATE", "srcImageState"), + Param("XGL_IMAGE_LAYOUT", "srcImageLayout"), Param("XGL_IMAGE", "destImage"), - Param("XGL_IMAGE_STATE", "destImageState")]), + Param("XGL_IMAGE_LAYOUT", "destImageLayout")]), Proto("XGL_VOID", "CmdUpdateBuffer", [Param("XGL_CMD_BUFFER", "cmdBuffer"), @@ -745,12 +735,21 @@ core = Extension( Proto("XGL_VOID", "CmdSetEvent", [Param("XGL_CMD_BUFFER", "cmdBuffer"), - Param("XGL_EVENT", "event")]), + Param("XGL_EVENT", "event"), + Param("XGL_SET_EVENT", "pipeEvent")]), Proto("XGL_VOID", "CmdResetEvent", [Param("XGL_CMD_BUFFER", "cmdBuffer"), Param("XGL_EVENT", "event")]), + Proto("XGL_VOID", "CmdWaitEvents", + [Param("XGL_CMD_BUFFER", "cmdBuffer"), + Param("const XGL_EVENT_WAIT_INFO*", "pWaitInfo")]), + + Proto("XGL_VOID", "CmdPipelineBarrier", + [Param("XGL_CMD_BUFFER", "cmdBuffer"), + Param("const XGL_PIPELINE_BARRIER*", "pBarrier")]), + Proto("XGL_VOID", "CmdBufferAtomic", [Param("XGL_CMD_BUFFER", "cmdBuffer"), Param("XGL_BUFFER", "destBuffer"), -- cgit v1.2.3