diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/gallium/drivers/ilo/Makefile.sources | 1 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_context.c | 1 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_resource.c | 450 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_resource.h | 5 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_transfer.c | 473 | ||||
| -rw-r--r-- | src/gallium/drivers/ilo/ilo_transfer.h | 38 |
6 files changed, 518 insertions, 450 deletions
diff --git a/src/gallium/drivers/ilo/Makefile.sources b/src/gallium/drivers/ilo/Makefile.sources index 661f3f12f3e..0a1cc85c58e 100644 --- a/src/gallium/drivers/ilo/Makefile.sources +++ b/src/gallium/drivers/ilo/Makefile.sources @@ -16,6 +16,7 @@ C_SOURCES := \ ilo_screen.c \ ilo_shader.c \ ilo_state.c \ + ilo_transfer.c \ ilo_video.c \ shader/ilo_shader_cs.c \ shader/ilo_shader_fs.c \ diff --git a/src/gallium/drivers/ilo/ilo_context.c b/src/gallium/drivers/ilo/ilo_context.c index 3a101b47e6f..bd4197bd84b 100644 --- a/src/gallium/drivers/ilo/ilo_context.c +++ b/src/gallium/drivers/ilo/ilo_context.c @@ -37,6 +37,7 @@ #include "ilo_screen.h" #include "ilo_shader.h" #include "ilo_state.h" +#include "ilo_transfer.h" #include "ilo_video.h" #include "ilo_context.h" diff --git a/src/gallium/drivers/ilo/ilo_resource.c b/src/gallium/drivers/ilo/ilo_resource.c index 41e4ffb1a9b..96f9d003793 100644 --- a/src/gallium/drivers/ilo/ilo_resource.c +++ b/src/gallium/drivers/ilo/ilo_resource.c @@ -25,38 +25,12 @@ * Chia-I Wu <[email protected]> */ -#include "util/u_surface.h" -#include "util/u_transfer.h" -#include "util/u_format_etc.h" - -#include "ilo_cp.h" -#include "ilo_context.h" #include "ilo_screen.h" #include "ilo_resource.h" /* use PIPE_BIND_CUSTOM to indicate MCS */ #define ILO_BIND_MCS PIPE_BIND_CUSTOM -enum ilo_transfer_map_method { - ILO_TRANSFER_MAP_DIRECT, - ILO_TRANSFER_MAP_STAGING_SYS, -}; - -struct ilo_transfer { - struct pipe_transfer base; - - enum ilo_transfer_map_method method; - void *ptr; - - void *staging_sys; -}; - -static inline struct ilo_transfer * -ilo_transfer(struct pipe_transfer *transfer) -{ - return (struct ilo_transfer *) transfer; -} - static struct intel_bo * alloc_buf_bo(const struct ilo_resource *res) { @@ -162,8 +136,8 @@ alloc_tex_bo(const struct ilo_resource *res) return bo; } -static bool -realloc_bo(struct ilo_resource *res) +bool +ilo_resource_alloc_bo(struct ilo_resource *res) { struct intel_bo *old_bo = res->bo; @@ -191,412 +165,6 @@ realloc_bo(struct ilo_resource *res) return true; } -static void -ilo_transfer_inline_write(struct pipe_context *pipe, - struct pipe_resource *r, - unsigned level, - unsigned usage, - const struct pipe_box *box, - const void *data, - unsigned stride, - unsigned layer_stride) -{ - struct ilo_context *ilo = ilo_context(pipe); - struct ilo_resource *res = ilo_resource(r); - int offset, size; - bool will_be_busy; - - /* - * Fall back to map(), memcpy(), and unmap(). We use this path for - * unsynchronized write, as the buffer is likely to be busy and pwrite() - * will stall. - */ - if (unlikely(res->base.target != PIPE_BUFFER) || - (usage & PIPE_TRANSFER_UNSYNCHRONIZED)) { - u_default_transfer_inline_write(pipe, r, - level, usage, box, data, stride, layer_stride); - - return; - } - - /* - * XXX With hardware context support, the bo may be needed by GPU without - * being referenced by ilo->cp->bo. We have to flush unconditionally, and - * that is bad. - */ - if (ilo->cp->hw_ctx) - ilo_cp_flush(ilo->cp); - - will_be_busy = ilo->cp->bo->references(ilo->cp->bo, res->bo); - - /* see if we can avoid stalling */ - if (will_be_busy || intel_bo_is_busy(res->bo)) { - bool will_stall = true; - - if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) { - /* old data not needed so discard the old bo to avoid stalling */ - if (realloc_bo(res)) - will_stall = false; - } - else { - /* - * We could allocate a temporary bo to hold the data and emit - * pipelined copy blit to move them to res->bo. But for now, do - * nothing. - */ - } - - /* flush to make bo busy (so that pwrite() stalls as it should be) */ - if (will_stall && will_be_busy) - ilo_cp_flush(ilo->cp); - } - - /* for PIPE_BUFFERs, conversion should not be needed */ - assert(res->bo_format == res->base.format); - - /* they should specify just an offset and a size */ - assert(level == 0); - assert(box->y == 0); - assert(box->z == 0); - assert(box->height == 1); - assert(box->depth == 1); - offset = box->x; - size = box->width; - - res->bo->pwrite(res->bo, offset, size, data); -} - -static void -transfer_unmap_sys_convert(enum pipe_format dst_fmt, - const struct pipe_transfer *dst_xfer, - void *dst, - enum pipe_format src_fmt, - const struct pipe_transfer *src_xfer, - const void *src) -{ - int i; - - switch (src_fmt) { - case PIPE_FORMAT_ETC1_RGB8: - assert(dst_fmt == PIPE_FORMAT_R8G8B8X8_UNORM); - - for (i = 0; i < dst_xfer->box.depth; i++) { - util_format_etc1_rgb8_unpack_rgba_8unorm(dst, - dst_xfer->stride, src, src_xfer->stride, - dst_xfer->box.width, dst_xfer->box.height); - - dst += dst_xfer->layer_stride; - src += src_xfer->layer_stride; - } - break; - default: - assert(!"unable to convert the staging data"); - break; - } -} - -static void -transfer_unmap_sys(struct ilo_context *ilo, - struct ilo_resource *res, - struct ilo_transfer *xfer) -{ - const void *src = xfer->ptr; - struct pipe_transfer *dst_xfer; - void *dst; - - dst = ilo->base.transfer_map(&ilo->base, - xfer->base.resource, xfer->base.level, - PIPE_TRANSFER_WRITE | - PIPE_TRANSFER_MAP_DIRECTLY | - PIPE_TRANSFER_DISCARD_RANGE, - &xfer->base.box, &dst_xfer); - if (!dst_xfer) { - ilo_err("failed to map resource for moving staging data\n"); - FREE(xfer->staging_sys); - return; - } - - if (likely(res->bo_format != res->base.format)) { - transfer_unmap_sys_convert(res->bo_format, dst_xfer, dst, - res->base.format, &xfer->base, src); - } - else { - util_copy_box(dst, res->bo_format, - dst_xfer->stride, dst_xfer->layer_stride, 0, 0, 0, - dst_xfer->box.width, dst_xfer->box.height, dst_xfer->box.depth, - src, xfer->base.stride, xfer->base.layer_stride, 0, 0, 0); - } - - ilo->base.transfer_unmap(&ilo->base, dst_xfer); - FREE(xfer->staging_sys); -} - -static bool -transfer_map_sys(struct ilo_context *ilo, - struct ilo_resource *res, - struct ilo_transfer *xfer) -{ - const struct pipe_box *box = &xfer->base.box; - const size_t stride = util_format_get_stride(res->base.format, box->width); - const size_t size = - util_format_get_2d_size(res->base.format, stride, box->height); - bool read_back = false; - - if (xfer->base.usage & PIPE_TRANSFER_READ) { - read_back = true; - } - else if (xfer->base.usage & PIPE_TRANSFER_WRITE) { - const unsigned discard_flags = - (PIPE_TRANSFER_DISCARD_RANGE | PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE); - - if (!(xfer->base.usage & discard_flags)) - read_back = true; - } - - /* TODO */ - if (read_back) - return false; - - xfer->staging_sys = MALLOC(size * box->depth); - if (!xfer->staging_sys) - return false; - - xfer->base.stride = stride; - xfer->base.layer_stride = size; - xfer->ptr = xfer->staging_sys; - - return true; -} - -static void -transfer_unmap_direct(struct ilo_context *ilo, - struct ilo_resource *res, - struct ilo_transfer *xfer) -{ - res->bo->unmap(res->bo); -} - -static bool -transfer_map_direct(struct ilo_context *ilo, - struct ilo_resource *res, - struct ilo_transfer *xfer) -{ - int x, y, err; - - if (xfer->base.usage & PIPE_TRANSFER_UNSYNCHRONIZED) - err = res->bo->map_unsynchronized(res->bo); - /* prefer map() when there is the last-level cache */ - else if (res->tiling == INTEL_TILING_NONE && - (ilo->dev->has_llc || (xfer->base.usage & PIPE_TRANSFER_READ))) - err = res->bo->map(res->bo, (xfer->base.usage & PIPE_TRANSFER_WRITE)); - else - err = res->bo->map_gtt(res->bo); - - if (err) - return false; - - /* note that stride is for a block row, not a texel row */ - xfer->base.stride = res->bo_stride; - - /* - * we can walk through layers when the resource is a texture array or - * when this is the first level of a 3D texture being mapped - */ - if (res->base.array_size > 1 || - (res->base.target == PIPE_TEXTURE_3D && xfer->base.level == 0)) { - const unsigned qpitch = res->slice_offsets[xfer->base.level][1].y - - res->slice_offsets[xfer->base.level][0].y; - - assert(qpitch % res->block_height == 0); - xfer->base.layer_stride = (qpitch / res->block_height) * xfer->base.stride; - } - else { - xfer->base.layer_stride = 0; - } - - x = res->slice_offsets[xfer->base.level][xfer->base.box.z].x; - y = res->slice_offsets[xfer->base.level][xfer->base.box.z].y; - - x += xfer->base.box.x; - y += xfer->base.box.y; - - /* in blocks */ - assert(x % res->block_width == 0 && y % res->block_height == 0); - x /= res->block_width; - y /= res->block_height; - - xfer->ptr = res->bo->get_virtual(res->bo); - xfer->ptr += y * res->bo_stride + x * res->bo_cpp; - - return true; -} - -/** - * Choose the best mapping method, depending on the transfer usage and whether - * the bo is busy. - */ -static bool -transfer_map_choose_method(struct ilo_context *ilo, - struct ilo_resource *res, - struct ilo_transfer *xfer) -{ - bool will_be_busy, will_stall; - - /* need to convert on-the-fly */ - if (res->bo_format != res->base.format && - !(xfer->base.usage & PIPE_TRANSFER_MAP_DIRECTLY)) { - xfer->method = ILO_TRANSFER_MAP_STAGING_SYS; - - return true; - } - - xfer->method = ILO_TRANSFER_MAP_DIRECT; - - /* unsynchronized map does not stall */ - if (xfer->base.usage & PIPE_TRANSFER_UNSYNCHRONIZED) - return true; - - will_be_busy = ilo->cp->bo->references(ilo->cp->bo, res->bo); - if (!will_be_busy) { - /* - * XXX With hardware context support, the bo may be needed by GPU - * without being referenced by ilo->cp->bo. We have to flush - * unconditionally, and that is bad. - */ - if (ilo->cp->hw_ctx) - ilo_cp_flush(ilo->cp); - - if (!intel_bo_is_busy(res->bo)) - return true; - } - - /* bo is busy and mapping it will stall */ - will_stall = true; - - if (xfer->base.usage & PIPE_TRANSFER_MAP_DIRECTLY) { - /* nothing we can do */ - } - else if (xfer->base.usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) { - /* discard old bo and allocate a new one for mapping */ - if (realloc_bo(res)) - will_stall = false; - } - else if (xfer->base.usage & PIPE_TRANSFER_FLUSH_EXPLICIT) { - /* - * We could allocate and return a system buffer here. When a region of - * the buffer is explicitly flushed, we pwrite() the region to a - * temporary bo and emit pipelined copy blit. - * - * For now, do nothing. - */ - } - else if (xfer->base.usage & PIPE_TRANSFER_DISCARD_RANGE) { - /* - * We could allocate a temporary bo for mapping, and emit pipelined copy - * blit upon unmapping. - * - * For now, do nothing. - */ - } - - if (will_stall) { - if (xfer->base.usage & PIPE_TRANSFER_DONTBLOCK) - return false; - - /* flush to make bo busy (so that map() stalls as it should be) */ - if (will_be_busy) - ilo_cp_flush(ilo->cp); - } - - return true; -} - -static void -ilo_transfer_flush_region(struct pipe_context *pipe, - struct pipe_transfer *transfer, - const struct pipe_box *box) -{ -} - -static void -ilo_transfer_unmap(struct pipe_context *pipe, - struct pipe_transfer *transfer) -{ - struct ilo_context *ilo = ilo_context(pipe); - struct ilo_resource *res = ilo_resource(transfer->resource); - struct ilo_transfer *xfer = ilo_transfer(transfer); - - switch (xfer->method) { - case ILO_TRANSFER_MAP_DIRECT: - transfer_unmap_direct(ilo, res, xfer); - break; - case ILO_TRANSFER_MAP_STAGING_SYS: - transfer_unmap_sys(ilo, res, xfer); - break; - default: - assert(!"unknown mapping method"); - break; - } - - pipe_resource_reference(&xfer->base.resource, NULL); - FREE(xfer); -} - -static void * -ilo_transfer_map(struct pipe_context *pipe, - struct pipe_resource *r, - unsigned level, - unsigned usage, - const struct pipe_box *box, - struct pipe_transfer **transfer) -{ - struct ilo_context *ilo = ilo_context(pipe); - struct ilo_resource *res = ilo_resource(r); - struct ilo_transfer *xfer; - int ok; - - xfer = MALLOC_STRUCT(ilo_transfer); - if (!xfer) { - *transfer = NULL; - return NULL; - } - - xfer->base.resource = NULL; - pipe_resource_reference(&xfer->base.resource, &res->base); - xfer->base.level = level; - xfer->base.usage = usage; - xfer->base.box = *box; - - ok = transfer_map_choose_method(ilo, res, xfer); - if (ok) { - switch (xfer->method) { - case ILO_TRANSFER_MAP_DIRECT: - ok = transfer_map_direct(ilo, res, xfer); - break; - case ILO_TRANSFER_MAP_STAGING_SYS: - ok = transfer_map_sys(ilo, res, xfer); - break; - default: - assert(!"unknown mapping method"); - ok = false; - break; - } - } - - if (!ok) { - pipe_resource_reference(&xfer->base.resource, NULL); - FREE(xfer); - - *transfer = NULL; - - return NULL; - } - - *transfer = &xfer->base; - - return xfer->ptr; -} - static bool alloc_slice_offsets(struct ilo_resource *res) { @@ -1373,7 +941,7 @@ create_resource(struct pipe_screen *screen, else init_texture(res); - if (!realloc_bo(res)) { + if (!ilo_resource_alloc_bo(res)) { free_slice_offsets(res); FREE(res); return NULL; @@ -1449,18 +1017,6 @@ ilo_init_resource_functions(struct ilo_screen *is) } /** - * Initialize transfer-related functions. - */ -void -ilo_init_transfer_functions(struct ilo_context *ilo) -{ - ilo->base.transfer_map = ilo_transfer_map; - ilo->base.transfer_flush_region = ilo_transfer_flush_region; - ilo->base.transfer_unmap = ilo_transfer_unmap; - ilo->base.transfer_inline_write = ilo_transfer_inline_write; -} - -/** * Return the offset (in bytes) to a slice within the bo. * * When tile_aligned is true, the offset is to the tile containing the start diff --git a/src/gallium/drivers/ilo/ilo_resource.h b/src/gallium/drivers/ilo/ilo_resource.h index 03d31d4bcb9..87f80d5c575 100644 --- a/src/gallium/drivers/ilo/ilo_resource.h +++ b/src/gallium/drivers/ilo/ilo_resource.h @@ -33,7 +33,6 @@ #include "ilo_common.h" struct ilo_screen; -struct ilo_context; struct winsys_handle; /* @@ -89,8 +88,8 @@ ilo_resource(struct pipe_resource *res) void ilo_init_resource_functions(struct ilo_screen *is); -void -ilo_init_transfer_functions(struct ilo_context *ilo); +bool +ilo_resource_alloc_bo(struct ilo_resource *res); unsigned ilo_resource_get_slice_offset(const struct ilo_resource *res, diff --git a/src/gallium/drivers/ilo/ilo_transfer.c b/src/gallium/drivers/ilo/ilo_transfer.c new file mode 100644 index 00000000000..3b9c4d6994f --- /dev/null +++ b/src/gallium/drivers/ilo/ilo_transfer.c @@ -0,0 +1,473 @@ +/* + * Mesa 3-D graphics library + * + * Copyright (C) 2012-2013 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu <[email protected]> + */ + +#include "util/u_surface.h" +#include "util/u_transfer.h" +#include "util/u_format_etc.h" + +#include "ilo_cp.h" +#include "ilo_context.h" +#include "ilo_resource.h" +#include "ilo_transfer.h" + +enum ilo_transfer_map_method { + ILO_TRANSFER_MAP_DIRECT, + ILO_TRANSFER_MAP_STAGING_SYS, +}; + +struct ilo_transfer { + struct pipe_transfer base; + + enum ilo_transfer_map_method method; + void *ptr; + + void *staging_sys; +}; + +static inline struct ilo_transfer * +ilo_transfer(struct pipe_transfer *transfer) +{ + return (struct ilo_transfer *) transfer; +} + +static void +ilo_transfer_inline_write(struct pipe_context *pipe, + struct pipe_resource *r, + unsigned level, + unsigned usage, + const struct pipe_box *box, + const void *data, + unsigned stride, + unsigned layer_stride) +{ + struct ilo_context *ilo = ilo_context(pipe); + struct ilo_resource *res = ilo_resource(r); + int offset, size; + bool will_be_busy; + + /* + * Fall back to map(), memcpy(), and unmap(). We use this path for + * unsynchronized write, as the buffer is likely to be busy and pwrite() + * will stall. + */ + if (unlikely(res->base.target != PIPE_BUFFER) || + (usage & PIPE_TRANSFER_UNSYNCHRONIZED)) { + u_default_transfer_inline_write(pipe, r, + level, usage, box, data, stride, layer_stride); + + return; + } + + /* + * XXX With hardware context support, the bo may be needed by GPU without + * being referenced by ilo->cp->bo. We have to flush unconditionally, and + * that is bad. + */ + if (ilo->cp->hw_ctx) + ilo_cp_flush(ilo->cp); + + will_be_busy = ilo->cp->bo->references(ilo->cp->bo, res->bo); + + /* see if we can avoid stalling */ + if (will_be_busy || intel_bo_is_busy(res->bo)) { + bool will_stall = true; + + if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) { + /* old data not needed so discard the old bo to avoid stalling */ + if (ilo_resource_alloc_bo(res)) + will_stall = false; + } + else { + /* + * We could allocate a temporary bo to hold the data and emit + * pipelined copy blit to move them to res->bo. But for now, do + * nothing. + */ + } + + /* flush to make bo busy (so that pwrite() stalls as it should be) */ + if (will_stall && will_be_busy) + ilo_cp_flush(ilo->cp); + } + + /* for PIPE_BUFFERs, conversion should not be needed */ + assert(res->bo_format == res->base.format); + + /* they should specify just an offset and a size */ + assert(level == 0); + assert(box->y == 0); + assert(box->z == 0); + assert(box->height == 1); + assert(box->depth == 1); + offset = box->x; + size = box->width; + + res->bo->pwrite(res->bo, offset, size, data); +} + +static void +transfer_unmap_sys_convert(enum pipe_format dst_fmt, + const struct pipe_transfer *dst_xfer, + void *dst, + enum pipe_format src_fmt, + const struct pipe_transfer *src_xfer, + const void *src) +{ + int i; + + switch (src_fmt) { + case PIPE_FORMAT_ETC1_RGB8: + assert(dst_fmt == PIPE_FORMAT_R8G8B8X8_UNORM); + + for (i = 0; i < dst_xfer->box.depth; i++) { + util_format_etc1_rgb8_unpack_rgba_8unorm(dst, + dst_xfer->stride, src, src_xfer->stride, + dst_xfer->box.width, dst_xfer->box.height); + + dst += dst_xfer->layer_stride; + src += src_xfer->layer_stride; + } + break; + default: + assert(!"unable to convert the staging data"); + break; + } +} + +static void +transfer_unmap_sys(struct ilo_context *ilo, + struct ilo_resource *res, + struct ilo_transfer *xfer) +{ + const void *src = xfer->ptr; + struct pipe_transfer *dst_xfer; + void *dst; + + dst = ilo->base.transfer_map(&ilo->base, + xfer->base.resource, xfer->base.level, + PIPE_TRANSFER_WRITE | + PIPE_TRANSFER_MAP_DIRECTLY | + PIPE_TRANSFER_DISCARD_RANGE, + &xfer->base.box, &dst_xfer); + if (!dst_xfer) { + ilo_err("failed to map resource for moving staging data\n"); + FREE(xfer->staging_sys); + return; + } + + if (likely(res->bo_format != res->base.format)) { + transfer_unmap_sys_convert(res->bo_format, dst_xfer, dst, + res->base.format, &xfer->base, src); + } + else { + util_copy_box(dst, res->bo_format, + dst_xfer->stride, dst_xfer->layer_stride, 0, 0, 0, + dst_xfer->box.width, dst_xfer->box.height, dst_xfer->box.depth, + src, xfer->base.stride, xfer->base.layer_stride, 0, 0, 0); + } + + ilo->base.transfer_unmap(&ilo->base, dst_xfer); + FREE(xfer->staging_sys); +} + +static bool +transfer_map_sys(struct ilo_context *ilo, + struct ilo_resource *res, + struct ilo_transfer *xfer) +{ + const struct pipe_box *box = &xfer->base.box; + const size_t stride = util_format_get_stride(res->base.format, box->width); + const size_t size = + util_format_get_2d_size(res->base.format, stride, box->height); + bool read_back = false; + + if (xfer->base.usage & PIPE_TRANSFER_READ) { + read_back = true; + } + else if (xfer->base.usage & PIPE_TRANSFER_WRITE) { + const unsigned discard_flags = + (PIPE_TRANSFER_DISCARD_RANGE | PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE); + + if (!(xfer->base.usage & discard_flags)) + read_back = true; + } + + /* TODO */ + if (read_back) + return false; + + xfer->staging_sys = MALLOC(size * box->depth); + if (!xfer->staging_sys) + return false; + + xfer->base.stride = stride; + xfer->base.layer_stride = size; + xfer->ptr = xfer->staging_sys; + + return true; +} + +static void +transfer_unmap_direct(struct ilo_context *ilo, + struct ilo_resource *res, + struct ilo_transfer *xfer) +{ + res->bo->unmap(res->bo); +} + +static bool +transfer_map_direct(struct ilo_context *ilo, + struct ilo_resource *res, + struct ilo_transfer *xfer) +{ + int x, y, err; + + if (xfer->base.usage & PIPE_TRANSFER_UNSYNCHRONIZED) + err = res->bo->map_unsynchronized(res->bo); + /* prefer map() when there is the last-level cache */ + else if (res->tiling == INTEL_TILING_NONE && + (ilo->dev->has_llc || (xfer->base.usage & PIPE_TRANSFER_READ))) + err = res->bo->map(res->bo, (xfer->base.usage & PIPE_TRANSFER_WRITE)); + else + err = res->bo->map_gtt(res->bo); + + if (err) + return false; + + /* note that stride is for a block row, not a texel row */ + xfer->base.stride = res->bo_stride; + + /* + * we can walk through layers when the resource is a texture array or + * when this is the first level of a 3D texture being mapped + */ + if (res->base.array_size > 1 || + (res->base.target == PIPE_TEXTURE_3D && xfer->base.level == 0)) { + const unsigned qpitch = res->slice_offsets[xfer->base.level][1].y - + res->slice_offsets[xfer->base.level][0].y; + + assert(qpitch % res->block_height == 0); + xfer->base.layer_stride = (qpitch / res->block_height) * xfer->base.stride; + } + else { + xfer->base.layer_stride = 0; + } + + x = res->slice_offsets[xfer->base.level][xfer->base.box.z].x; + y = res->slice_offsets[xfer->base.level][xfer->base.box.z].y; + + x += xfer->base.box.x; + y += xfer->base.box.y; + + /* in blocks */ + assert(x % res->block_width == 0 && y % res->block_height == 0); + x /= res->block_width; + y /= res->block_height; + + xfer->ptr = res->bo->get_virtual(res->bo); + xfer->ptr += y * res->bo_stride + x * res->bo_cpp; + + return true; +} + +/** + * Choose the best mapping method, depending on the transfer usage and whether + * the bo is busy. + */ +static bool +transfer_map_choose_method(struct ilo_context *ilo, + struct ilo_resource *res, + struct ilo_transfer *xfer) +{ + bool will_be_busy, will_stall; + + /* need to convert on-the-fly */ + if (res->bo_format != res->base.format && + !(xfer->base.usage & PIPE_TRANSFER_MAP_DIRECTLY)) { + xfer->method = ILO_TRANSFER_MAP_STAGING_SYS; + + return true; + } + + xfer->method = ILO_TRANSFER_MAP_DIRECT; + + /* unsynchronized map does not stall */ + if (xfer->base.usage & PIPE_TRANSFER_UNSYNCHRONIZED) + return true; + + will_be_busy = ilo->cp->bo->references(ilo->cp->bo, res->bo); + if (!will_be_busy) { + /* + * XXX With hardware context support, the bo may be needed by GPU + * without being referenced by ilo->cp->bo. We have to flush + * unconditionally, and that is bad. + */ + if (ilo->cp->hw_ctx) + ilo_cp_flush(ilo->cp); + + if (!intel_bo_is_busy(res->bo)) + return true; + } + + /* bo is busy and mapping it will stall */ + will_stall = true; + + if (xfer->base.usage & PIPE_TRANSFER_MAP_DIRECTLY) { + /* nothing we can do */ + } + else if (xfer->base.usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) { + /* discard old bo and allocate a new one for mapping */ + if (ilo_resource_alloc_bo(res)) + will_stall = false; + } + else if (xfer->base.usage & PIPE_TRANSFER_FLUSH_EXPLICIT) { + /* + * We could allocate and return a system buffer here. When a region of + * the buffer is explicitly flushed, we pwrite() the region to a + * temporary bo and emit pipelined copy blit. + * + * For now, do nothing. + */ + } + else if (xfer->base.usage & PIPE_TRANSFER_DISCARD_RANGE) { + /* + * We could allocate a temporary bo for mapping, and emit pipelined copy + * blit upon unmapping. + * + * For now, do nothing. + */ + } + + if (will_stall) { + if (xfer->base.usage & PIPE_TRANSFER_DONTBLOCK) + return false; + + /* flush to make bo busy (so that map() stalls as it should be) */ + if (will_be_busy) + ilo_cp_flush(ilo->cp); + } + + return true; +} + +static void +ilo_transfer_flush_region(struct pipe_context *pipe, + struct pipe_transfer *transfer, + const struct pipe_box *box) +{ +} + +static void +ilo_transfer_unmap(struct pipe_context *pipe, + struct pipe_transfer *transfer) +{ + struct ilo_context *ilo = ilo_context(pipe); + struct ilo_resource *res = ilo_resource(transfer->resource); + struct ilo_transfer *xfer = ilo_transfer(transfer); + + switch (xfer->method) { + case ILO_TRANSFER_MAP_DIRECT: + transfer_unmap_direct(ilo, res, xfer); + break; + case ILO_TRANSFER_MAP_STAGING_SYS: + transfer_unmap_sys(ilo, res, xfer); + break; + default: + assert(!"unknown mapping method"); + break; + } + + pipe_resource_reference(&xfer->base.resource, NULL); + FREE(xfer); +} + +static void * +ilo_transfer_map(struct pipe_context *pipe, + struct pipe_resource *r, + unsigned level, + unsigned usage, + const struct pipe_box *box, + struct pipe_transfer **transfer) +{ + struct ilo_context *ilo = ilo_context(pipe); + struct ilo_resource *res = ilo_resource(r); + struct ilo_transfer *xfer; + int ok; + + xfer = MALLOC_STRUCT(ilo_transfer); + if (!xfer) { + *transfer = NULL; + return NULL; + } + + xfer->base.resource = NULL; + pipe_resource_reference(&xfer->base.resource, &res->base); + xfer->base.level = level; + xfer->base.usage = usage; + xfer->base.box = *box; + + ok = transfer_map_choose_method(ilo, res, xfer); + if (ok) { + switch (xfer->method) { + case ILO_TRANSFER_MAP_DIRECT: + ok = transfer_map_direct(ilo, res, xfer); + break; + case ILO_TRANSFER_MAP_STAGING_SYS: + ok = transfer_map_sys(ilo, res, xfer); + break; + default: + assert(!"unknown mapping method"); + ok = false; + break; + } + } + + if (!ok) { + pipe_resource_reference(&xfer->base.resource, NULL); + FREE(xfer); + + *transfer = NULL; + + return NULL; + } + + *transfer = &xfer->base; + + return xfer->ptr; +} + +/** + * Initialize transfer-related functions. + */ +void +ilo_init_transfer_functions(struct ilo_context *ilo) +{ + ilo->base.transfer_map = ilo_transfer_map; + ilo->base.transfer_flush_region = ilo_transfer_flush_region; + ilo->base.transfer_unmap = ilo_transfer_unmap; + ilo->base.transfer_inline_write = ilo_transfer_inline_write; +} diff --git a/src/gallium/drivers/ilo/ilo_transfer.h b/src/gallium/drivers/ilo/ilo_transfer.h new file mode 100644 index 00000000000..25bcc442ffc --- /dev/null +++ b/src/gallium/drivers/ilo/ilo_transfer.h @@ -0,0 +1,38 @@ +/* + * Mesa 3-D graphics library + * + * Copyright (C) 2012-2013 LunarG, Inc. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Authors: + * Chia-I Wu <[email protected]> + */ + +#ifndef ILO_TRANSFER_H +#define ILO_TRANSFER_H + +#include "ilo_common.h" + +struct ilo_context; + +void +ilo_init_transfer_functions(struct ilo_context *ilo); + +#endif /* ILO_TRANSFER_H */ |