/* One-shot transfer operation with data supplied in a user
* pointer. XXX: strides??
*/
void u_default_transfer_inline_write( struct pipe_context *pipe,
struct pipe_resource *resource,
unsigned level,
unsigned usage,
const struct pipe_box *box,
const void *data,
unsigned stride,
unsigned layer_stride)
{
struct pipe_transfer *transfer = NULL;
uint8_t *map = NULL;
assert(!(usage & PIPE_TRANSFER_READ));
/* the write flag is implicit by the nature of transfer_inline_write */
usage |= PIPE_TRANSFER_WRITE;
/* transfer_inline_write implicitly discards the rewritten buffer range */
if (resource->target == PIPE_BUFFER &&
box->x == 0 && box->width == resource->width0) {
usage |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
} else {
usage |= PIPE_TRANSFER_DISCARD_RANGE;
}
map = pipe->transfer_map(pipe,
resource,
level,
usage,
box, &transfer);
if (map == NULL)
return;
if (resource->target == PIPE_BUFFER) {
assert(box->height == 1);
assert(box->depth == 1);
memcpy(map, data, box->width);
}
else {
const uint8_t *src_data = data;
util_copy_box(map,
resource->format,
transfer->stride, /* bytes */
transfer->layer_stride, /* bytes */
0, 0, 0,
box->width,
box->height,
box->depth,
src_data,
stride, /* bytes */
layer_stride, /* bytes */
0, 0, 0);
}
pipe_transfer_unmap(pipe, transfer);
}
static void etna_pipe_transfer_unmap(struct pipe_context *pipe,
struct pipe_transfer *transfer_)
{
struct etna_pipe_context *priv = etna_pipe_context(pipe);
struct etna_transfer *ptrans = etna_transfer(transfer_);
/* XXX
* When writing to a resource that is already in use, replace the resource with a completely new buffer
* and free the old one using a fenced free.
* The most tricky case to implement will be: tiled or supertiled surface, partial write, target not aligned to 4/64
*/
struct etna_resource *resource = etna_resource(ptrans->base.resource);
assert(ptrans->base.level <= resource->base.last_level);
if(ptrans->base.usage & PIPE_TRANSFER_WRITE)
{
/* write back */
if(unlikely(!ptrans->in_place))
{
/* map buffer object */
struct etna_resource_level *res_level = &resource->levels[ptrans->base.level];
void *mapped = etna_bo_map(resource->bo) + res_level->offset;
if(resource->layout == ETNA_LAYOUT_LINEAR || resource->layout == ETNA_LAYOUT_TILED)
{
if(resource->layout == ETNA_LAYOUT_TILED && !util_format_is_compressed(resource->base.format))
{
etna_texture_tile(mapped + ptrans->base.box.z * res_level->layer_stride, ptrans->buffer,
ptrans->base.box.x, ptrans->base.box.y, res_level->stride,
ptrans->base.box.width, ptrans->base.box.height, ptrans->base.stride,
util_format_get_blocksize(resource->base.format));
} else { /* non-tiled or compressed format */
util_copy_box(mapped,
resource->base.format,
res_level->stride, res_level->layer_stride,
ptrans->base.box.x, ptrans->base.box.y, ptrans->base.box.z,
ptrans->base.box.width, ptrans->base.box.height, ptrans->base.box.depth,
ptrans->buffer,
ptrans->base.stride, ptrans->base.layer_stride,
0, 0, 0 /* src x,y,z */);
}
} else
{
BUG("unsupported tiling %i", resource->layout);
}
FREE(ptrans->buffer);
}
if(resource->base.bind & PIPE_BIND_SAMPLER_VIEW)
{
/* XXX do we need to flush the CPU cache too or start a write barrier
* to make sure the GPU sees it? */
priv->dirty_bits |= ETNA_STATE_TEXTURE_CACHES;
}
}
util_slab_free(&priv->transfer_pool, ptrans);
}
void u_default_texture_subdata(struct pipe_context *pipe,
struct pipe_resource *resource,
unsigned level,
unsigned usage,
const struct pipe_box *box,
const void *data,
unsigned stride,
unsigned layer_stride)
{
struct pipe_transfer *transfer = NULL;
const uint8_t *src_data = data;
uint8_t *map = NULL;
assert(!(usage & PIPE_TRANSFER_READ));
/* the write flag is implicit by the nature of texture_subdata */
usage |= PIPE_TRANSFER_WRITE;
/* texture_subdata implicitly discards the rewritten buffer range */
usage |= PIPE_TRANSFER_DISCARD_RANGE;
map = pipe->transfer_map(pipe,
resource,
level,
usage,
box, &transfer);
if (!map)
return;
util_copy_box(map,
resource->format,
transfer->stride, /* bytes */
transfer->layer_stride, /* bytes */
0, 0, 0,
box->width,
box->height,
box->depth,
src_data,
stride, /* bytes */
layer_stride, /* bytes */
0, 0, 0);
pipe_transfer_unmap(pipe, transfer);
}
/**
* Fallback function for pipe->resource_copy_region().
* Note: (X,Y)=(0,0) is always the upper-left corner.
*/
void
util_resource_copy_region(struct pipe_context *pipe,
struct pipe_resource *dst,
unsigned dst_level,
unsigned dst_x, unsigned dst_y, unsigned dst_z,
struct pipe_resource *src,
unsigned src_level,
const struct pipe_box *src_box)
{
struct pipe_transfer *src_trans, *dst_trans;
uint8_t *dst_map;
const uint8_t *src_map;
enum pipe_format src_format, dst_format;
struct pipe_box dst_box;
assert(src && dst);
if (!src || !dst)
return;
assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||
(src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));
src_format = src->format;
dst_format = dst->format;
assert(util_format_get_blocksize(dst_format) == util_format_get_blocksize(src_format));
assert(util_format_get_blockwidth(dst_format) == util_format_get_blockwidth(src_format));
assert(util_format_get_blockheight(dst_format) == util_format_get_blockheight(src_format));
src_map = pipe->transfer_map(pipe,
src,
src_level,
PIPE_TRANSFER_READ,
src_box, &src_trans);
assert(src_map);
if (!src_map) {
goto no_src_map;
}
dst_box.x = dst_x;
dst_box.y = dst_y;
dst_box.z = dst_z;
dst_box.width = src_box->width;
dst_box.height = src_box->height;
dst_box.depth = src_box->depth;
dst_map = pipe->transfer_map(pipe,
dst,
dst_level,
PIPE_TRANSFER_WRITE | PIPE_TRANSFER_DISCARD_RANGE,
&dst_box, &dst_trans);
assert(dst_map);
if (!dst_map) {
goto no_dst_map;
}
if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
assert(src_box->height == 1);
assert(src_box->depth == 1);
memcpy(dst_map, src_map, src_box->width);
} else {
util_copy_box(dst_map,
dst_format,
dst_trans->stride, dst_trans->layer_stride,
0, 0, 0,
src_box->width, src_box->height, src_box->depth,
src_map,
src_trans->stride, src_trans->layer_stride,
0, 0, 0);
}
pipe->transfer_unmap(pipe, dst_trans);
no_dst_map:
pipe->transfer_unmap(pipe, src_trans);
no_src_map:
;
}
static void
etna_transfer_unmap(struct pipe_context *pctx, struct pipe_transfer *ptrans)
{
struct etna_context *ctx = etna_context(pctx);
struct etna_transfer *trans = etna_transfer(ptrans);
struct etna_resource *rsc = etna_resource(ptrans->resource);
/* XXX
* When writing to a resource that is already in use, replace the resource
* with a completely new buffer
* and free the old one using a fenced free.
* The most tricky case to implement will be: tiled or supertiled surface,
* partial write, target not aligned to 4/64. */
assert(ptrans->level <= rsc->base.last_level);
if (rsc->texture && !etna_resource_newer(rsc, etna_resource(rsc->texture)))
rsc = etna_resource(rsc->texture); /* switch to using the texture resource */
/*
* Temporary resources are always pulled into the CPU domain, must push them
* back into GPU domain before the RS execs the blit to the base resource.
*/
if (trans->rsc)
etna_bo_cpu_fini(etna_resource(trans->rsc)->bo);
if (ptrans->usage & PIPE_TRANSFER_WRITE) {
if (trans->rsc) {
/* We have a temporary resource due to either tile status or
* tiling format. Write back the updated buffer contents.
* FIXME: we need to invalidate the tile status. */
etna_copy_resource_box(pctx, ptrans->resource, trans->rsc, ptrans->level, &ptrans->box);
} else if (trans->staging) {
/* map buffer object */
struct etna_resource_level *res_level = &rsc->levels[ptrans->level];
void *mapped = etna_bo_map(rsc->bo) + res_level->offset;
if (rsc->layout == ETNA_LAYOUT_TILED) {
etna_texture_tile(
mapped + ptrans->box.z * res_level->layer_stride,
trans->staging, ptrans->box.x, ptrans->box.y,
res_level->stride, ptrans->box.width, ptrans->box.height,
ptrans->stride, util_format_get_blocksize(rsc->base.format));
} else if (rsc->layout == ETNA_LAYOUT_LINEAR) {
util_copy_box(mapped, rsc->base.format, res_level->stride,
res_level->layer_stride, ptrans->box.x,
ptrans->box.y, ptrans->box.z, ptrans->box.width,
ptrans->box.height, ptrans->box.depth,
trans->staging, ptrans->stride,
ptrans->layer_stride, 0, 0, 0 /* src x,y,z */);
} else {
BUG("unsupported tiling %i", rsc->layout);
}
FREE(trans->staging);
}
rsc->seqno++;
if (rsc->base.bind & PIPE_BIND_SAMPLER_VIEW) {
ctx->dirty |= ETNA_DIRTY_TEXTURE_CACHES;
}
}
/*
* Transfers without a temporary are only pulled into the CPU domain if they
* are not mapped unsynchronized. If they are, must push them back into GPU
* domain after CPU access is finished.
*/
if (!trans->rsc && !(ptrans->usage & PIPE_TRANSFER_UNSYNCHRONIZED))
etna_bo_cpu_fini(rsc->bo);
pipe_resource_reference(&trans->rsc, NULL);
pipe_resource_reference(&ptrans->resource, NULL);
slab_free(&ctx->transfer_pool, trans);
}
static void *
etna_transfer_map(struct pipe_context *pctx, struct pipe_resource *prsc,
unsigned level,
unsigned usage,
const struct pipe_box *box,
struct pipe_transfer **out_transfer)
{
struct etna_context *ctx = etna_context(pctx);
struct etna_resource *rsc = etna_resource(prsc);
struct etna_transfer *trans;
struct pipe_transfer *ptrans;
enum pipe_format format = prsc->format;
trans = slab_alloc(&ctx->transfer_pool);
if (!trans)
return NULL;
/* slab_alloc() doesn't zero */
memset(trans, 0, sizeof(*trans));
ptrans = &trans->base;
pipe_resource_reference(&ptrans->resource, prsc);
ptrans->level = level;
ptrans->usage = usage;
ptrans->box = *box;
assert(level <= prsc->last_level);
/* Upgrade DISCARD_RANGE to WHOLE_RESOURCE if the whole resource is
* being mapped. If we add buffer reallocation to avoid CPU/GPU sync this
* check needs to be extended to coherent mappings and shared resources.
*/
if ((usage & PIPE_TRANSFER_DISCARD_RANGE) &&
!(usage & PIPE_TRANSFER_UNSYNCHRONIZED) &&
prsc->last_level == 0 &&
prsc->width0 == box->width &&
prsc->height0 == box->height &&
prsc->depth0 == box->depth &&
prsc->array_size == 1) {
usage |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
}
if (rsc->texture && !etna_resource_newer(rsc, etna_resource(rsc->texture))) {
/* We have a texture resource which is the same age or newer than the
* render resource. Use the texture resource, which avoids bouncing
* pixels between the two resources, and we can de-tile it in s/w. */
rsc = etna_resource(rsc->texture);
} else if (rsc->ts_bo ||
(rsc->layout != ETNA_LAYOUT_LINEAR &&
util_format_get_blocksize(format) > 1 &&
/* HALIGN 4 resources are incompatible with the resolve engine,
* so fall back to using software to detile this resource. */
rsc->halign != TEXTURE_HALIGN_FOUR)) {
/* If the surface has tile status, we need to resolve it first.
* The strategy we implement here is to use the RS to copy the
* depth buffer, filling in the "holes" where the tile status
* indicates that it's clear. We also do this for tiled
* resources, but only if the RS can blit them. */
if (usage & PIPE_TRANSFER_MAP_DIRECTLY) {
slab_free(&ctx->transfer_pool, trans);
BUG("unsupported transfer flags %#x with tile status/tiled layout", usage);
return NULL;
}
if (prsc->depth0 > 1) {
slab_free(&ctx->transfer_pool, trans);
BUG("resource has depth >1 with tile status");
return NULL;
}
struct pipe_resource templ = *prsc;
templ.nr_samples = 0;
templ.bind = PIPE_BIND_RENDER_TARGET;
trans->rsc = etna_resource_alloc(pctx->screen, ETNA_LAYOUT_LINEAR,
DRM_FORMAT_MOD_LINEAR, &templ);
if (!trans->rsc) {
slab_free(&ctx->transfer_pool, trans);
return NULL;
}
/* Need to align the transfer region to satisfy RS restrictions, as we
* really want to hit the RS blit path here.
*/
unsigned w_align, h_align;
if (rsc->layout & ETNA_LAYOUT_BIT_SUPER) {
w_align = h_align = 64;
} else {
w_align = ETNA_RS_WIDTH_MASK + 1;
h_align = ETNA_RS_HEIGHT_MASK + 1;
}
h_align *= ctx->screen->specs.pixel_pipes;
ptrans->box.width += ptrans->box.x & (w_align - 1);
ptrans->box.x = ptrans->box.x & ~(w_align - 1);
ptrans->box.width = align(ptrans->box.width, (ETNA_RS_WIDTH_MASK + 1));
ptrans->box.height += ptrans->box.y & (h_align - 1);
ptrans->box.y = ptrans->box.y & ~(h_align - 1);
ptrans->box.height = align(ptrans->box.height,
(ETNA_RS_HEIGHT_MASK + 1) *
ctx->screen->specs.pixel_pipes);
if (!(usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE))
etna_copy_resource_box(pctx, trans->rsc, prsc, level, &ptrans->box);
/* Switch to using the temporary resource instead */
rsc = etna_resource(trans->rsc);
}
struct etna_resource_level *res_level = &rsc->levels[level];
/*
* Always flush if we have the temporary resource and have a copy to this
* outstanding. Otherwise infer flush requirement from resource access and
* current GPU usage (reads must wait for GPU writes, writes must have
* exclusive access to the buffer).
*/
if ((trans->rsc && (etna_resource(trans->rsc)->status & ETNA_PENDING_WRITE)) ||
(!trans->rsc &&
(((usage & PIPE_TRANSFER_READ) && (rsc->status & ETNA_PENDING_WRITE)) ||
((usage & PIPE_TRANSFER_WRITE) && rsc->status))))
pctx->flush(pctx, NULL, 0);
/* XXX we don't handle PIPE_TRANSFER_FLUSH_EXPLICIT; this flag can be ignored
* when mapping in-place,
* but when not in place we need to fire off the copy operation in
* transfer_flush_region (currently
* a no-op) instead of unmap. Need to handle this to support
* ARB_map_buffer_range extension at least.
*/
/* XXX we don't take care of current operations on the resource; which can
be, at some point in the pipeline
which is not yet executed:
- bound as surface
- bound through vertex buffer
- bound through index buffer
- bound in sampler view
- used in clear_render_target / clear_depth_stencil operation
- used in blit
- used in resource_copy_region
How do other drivers record this information over course of the rendering
pipeline?
Is it necessary at all? Only in case we want to provide a fast path and
map the resource directly
(and for PIPE_TRANSFER_MAP_DIRECTLY) and we don't want to force a sync.
We also need to know whether the resource is in use to determine if a sync
is needed (or just do it
always, but that comes at the expense of performance).
A conservative approximation without too much overhead would be to mark
all resources that have
been bound at some point as busy. A drawback would be that accessing
resources that have
been bound but are no longer in use for a while still carry a performance
penalty. On the other hand,
the program could be using PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE or
PIPE_TRANSFER_UNSYNCHRONIZED to
avoid this in the first place...
A) We use an in-pipe copy engine, and queue the copy operation after unmap
so that the copy
will be performed when all current commands have been executed.
Using the RS is possible, not sure if always efficient. This can also
do any kind of tiling for us.
Only possible when PIPE_TRANSFER_DISCARD_RANGE is set.
B) We discard the entire resource (or at least, the mipmap level) and
allocate new memory for it.
Only possible when mapping the entire resource or
PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE is set.
*/
/*
* Pull resources into the CPU domain. Only skipped for unsynchronized
* transfers without a temporary resource.
*/
if (trans->rsc || !(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) {
uint32_t prep_flags = 0;
if (usage & PIPE_TRANSFER_READ)
prep_flags |= DRM_ETNA_PREP_READ;
if (usage & PIPE_TRANSFER_WRITE)
prep_flags |= DRM_ETNA_PREP_WRITE;
if (etna_bo_cpu_prep(rsc->bo, prep_flags))
goto fail_prep;
}
/* map buffer object */
void *mapped = etna_bo_map(rsc->bo);
if (!mapped)
goto fail;
*out_transfer = ptrans;
if (rsc->layout == ETNA_LAYOUT_LINEAR) {
ptrans->stride = res_level->stride;
ptrans->layer_stride = res_level->layer_stride;
return mapped + res_level->offset +
etna_compute_offset(prsc->format, box, res_level->stride,
res_level->layer_stride);
} else {
unsigned divSizeX = util_format_get_blockwidth(format);
unsigned divSizeY = util_format_get_blockheight(format);
/* No direct mappings of tiled, since we need to manually
* tile/untile.
*/
if (usage & PIPE_TRANSFER_MAP_DIRECTLY)
goto fail;
mapped += res_level->offset;
ptrans->stride = align(box->width, divSizeX) * util_format_get_blocksize(format); /* row stride in bytes */
ptrans->layer_stride = align(box->height, divSizeY) * ptrans->stride;
size_t size = ptrans->layer_stride * box->depth;
trans->staging = MALLOC(size);
if (!trans->staging)
goto fail;
if (usage & PIPE_TRANSFER_READ) {
if (rsc->layout == ETNA_LAYOUT_TILED) {
etna_texture_untile(trans->staging,
mapped + ptrans->box.z * res_level->layer_stride,
ptrans->box.x, ptrans->box.y, res_level->stride,
ptrans->box.width, ptrans->box.height, ptrans->stride,
util_format_get_blocksize(rsc->base.format));
} else if (rsc->layout == ETNA_LAYOUT_LINEAR) {
util_copy_box(trans->staging, rsc->base.format, ptrans->stride,
ptrans->layer_stride, 0, 0, 0, /* dst x,y,z */
ptrans->box.width, ptrans->box.height,
ptrans->box.depth, mapped, res_level->stride,
res_level->layer_stride, ptrans->box.x,
ptrans->box.y, ptrans->box.z);
} else {
/* TODO supertiling */
BUG("unsupported tiling %i for reading", rsc->layout);
}
}
return trans->staging;
}
fail:
etna_bo_cpu_fini(rsc->bo);
fail_prep:
etna_transfer_unmap(pctx, ptrans);
return NULL;
}
/**
* Fallback function for pipe->resource_copy_region().
* We support copying between different formats (including compressed/
* uncompressed) if the bytes per block or pixel matches. If copying
* compressed -> uncompressed, the dst region is reduced by the block
* width, height. If copying uncompressed -> compressed, the dest region
* is expanded by the block width, height. See GL_ARB_copy_image.
* Note: (X,Y)=(0,0) is always the upper-left corner.
*/
void
util_resource_copy_region(struct pipe_context *pipe,
struct pipe_resource *dst,
unsigned dst_level,
unsigned dst_x, unsigned dst_y, unsigned dst_z,
struct pipe_resource *src,
unsigned src_level,
const struct pipe_box *src_box_in)
{
struct pipe_transfer *src_trans, *dst_trans;
uint8_t *dst_map;
const uint8_t *src_map;
MAYBE_UNUSED enum pipe_format src_format;
enum pipe_format dst_format;
struct pipe_box src_box, dst_box;
unsigned src_bs, dst_bs, src_bw, dst_bw, src_bh, dst_bh;
assert(src && dst);
if (!src || !dst)
return;
assert((src->target == PIPE_BUFFER && dst->target == PIPE_BUFFER) ||
(src->target != PIPE_BUFFER && dst->target != PIPE_BUFFER));
src_format = src->format;
dst_format = dst->format;
/* init src box */
src_box = *src_box_in;
/* init dst box */
dst_box.x = dst_x;
dst_box.y = dst_y;
dst_box.z = dst_z;
dst_box.width = src_box.width;
dst_box.height = src_box.height;
dst_box.depth = src_box.depth;
src_bs = util_format_get_blocksize(src_format);
src_bw = util_format_get_blockwidth(src_format);
src_bh = util_format_get_blockheight(src_format);
dst_bs = util_format_get_blocksize(dst_format);
dst_bw = util_format_get_blockwidth(dst_format);
dst_bh = util_format_get_blockheight(dst_format);
/* Note: all box positions and sizes are in pixels */
if (src_bw > 1 && dst_bw == 1) {
/* Copy from compressed to uncompressed.
* Shrink dest box by the src block size.
*/
dst_box.width /= src_bw;
dst_box.height /= src_bh;
}
else if (src_bw == 1 && dst_bw > 1) {
/* Copy from uncompressed to compressed.
* Expand dest box by the dest block size.
*/
dst_box.width *= dst_bw;
dst_box.height *= dst_bh;
}
else {
/* compressed -> compressed or uncompressed -> uncompressed copy */
assert(src_bw == dst_bw);
assert(src_bh == dst_bh);
}
assert(src_bs == dst_bs);
if (src_bs != dst_bs) {
/* This can happen if we fail to do format checking before hand.
* Don't crash below.
*/
return;
}
/* check that region boxes are block aligned */
assert(src_box.x % src_bw == 0);
assert(src_box.y % src_bh == 0);
assert(src_box.width % src_bw == 0 ||
src_box.x + src_box.width == u_minify(src->width0, src_level));
assert(src_box.height % src_bh == 0 ||
src_box.y + src_box.height == u_minify(src->height0, src_level));
assert(dst_box.x % dst_bw == 0);
assert(dst_box.y % dst_bh == 0);
assert(dst_box.width % dst_bw == 0 ||
dst_box.x + dst_box.width == u_minify(dst->width0, dst_level));
assert(dst_box.height % dst_bh == 0 ||
dst_box.y + dst_box.height == u_minify(dst->height0, dst_level));
/* check that region boxes are not out of bounds */
assert(src_box.x + src_box.width <= u_minify(src->width0, src_level));
assert(src_box.y + src_box.height <= u_minify(src->height0, src_level));
assert(dst_box.x + dst_box.width <= u_minify(dst->width0, dst_level));
assert(dst_box.y + dst_box.height <= u_minify(dst->height0, dst_level));
/* check that total number of src, dest bytes match */
assert((src_box.width / src_bw) * (src_box.height / src_bh) * src_bs ==
(dst_box.width / dst_bw) * (dst_box.height / dst_bh) * dst_bs);
src_map = pipe->transfer_map(pipe,
src,
src_level,
PIPE_TRANSFER_READ,
&src_box, &src_trans);
assert(src_map);
if (!src_map) {
goto no_src_map;
}
dst_map = pipe->transfer_map(pipe,
dst,
dst_level,
PIPE_TRANSFER_WRITE |
PIPE_TRANSFER_DISCARD_RANGE, &dst_box,
&dst_trans);
assert(dst_map);
if (!dst_map) {
goto no_dst_map;
}
if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
assert(src_box.height == 1);
assert(src_box.depth == 1);
memcpy(dst_map, src_map, src_box.width);
} else {
util_copy_box(dst_map,
src_format,
dst_trans->stride, dst_trans->layer_stride,
0, 0, 0,
src_box.width, src_box.height, src_box.depth,
src_map,
src_trans->stride, src_trans->layer_stride,
0, 0, 0);
}
pipe->transfer_unmap(pipe, dst_trans);
no_dst_map:
pipe->transfer_unmap(pipe, src_trans);
no_src_map:
;
}
HRESULT
NineVolume9_CopyVolume( struct NineVolume9 *This,
struct NineVolume9 *From,
unsigned dstx, unsigned dsty, unsigned dstz,
struct pipe_box *pSrcBox )
{
struct pipe_context *pipe = This->pipe;
struct pipe_resource *r_dst = This->resource;
struct pipe_resource *r_src = From->resource;
struct pipe_transfer *transfer;
struct pipe_box src_box;
struct pipe_box dst_box;
uint8_t *p_dst;
const uint8_t *p_src;
DBG("This=%p From=%p dstx=%u dsty=%u dstz=%u pSrcBox=%p\n",
This, From, dstx, dsty, dstz, pSrcBox);
assert(This->desc.Pool != D3DPOOL_MANAGED &&
From->desc.Pool != D3DPOOL_MANAGED);
user_assert(This->desc.Format == From->desc.Format, D3DERR_INVALIDCALL);
dst_box.x = dstx;
dst_box.y = dsty;
dst_box.z = dstz;
if (pSrcBox) {
/* make sure it doesn't range outside the source volume */
user_assert(pSrcBox->x >= 0 &&
(pSrcBox->width - pSrcBox->x) <= From->desc.Width &&
pSrcBox->y >= 0 &&
(pSrcBox->height - pSrcBox->y) <= From->desc.Height &&
pSrcBox->z >= 0 &&
(pSrcBox->depth - pSrcBox->z) <= From->desc.Depth,
D3DERR_INVALIDCALL);
src_box = *pSrcBox;
} else {
src_box.x = 0;
src_box.y = 0;
src_box.z = 0;
src_box.width = From->desc.Width;
src_box.height = From->desc.Height;
src_box.depth = From->desc.Depth;
}
/* limits */
dst_box.width = This->desc.Width - dst_box.x;
dst_box.height = This->desc.Height - dst_box.y;
dst_box.depth = This->desc.Depth - dst_box.z;
user_assert(src_box.width <= dst_box.width &&
src_box.height <= dst_box.height &&
src_box.depth <= dst_box.depth, D3DERR_INVALIDCALL);
dst_box.width = src_box.width;
dst_box.height = src_box.height;
dst_box.depth = src_box.depth;
if (r_dst && r_src) {
pipe->resource_copy_region(pipe,
r_dst, This->level,
dst_box.x, dst_box.y, dst_box.z,
r_src, From->level,
&src_box);
} else
if (r_dst) {
p_src = NineVolume9_GetSystemMemPointer(From,
src_box.x, src_box.y, src_box.z);
pipe->transfer_inline_write(pipe, r_dst, This->level,
0, /* WRITE|DISCARD are implicit */
&dst_box, p_src,
From->stride, From->layer_stride);
} else
if (r_src) {
p_dst = NineVolume9_GetSystemMemPointer(This, 0, 0, 0);
p_src = pipe->transfer_map(pipe, r_src, From->level,
PIPE_TRANSFER_READ,
&src_box, &transfer);
if (!p_src)
return D3DERR_DRIVERINTERNALERROR;
util_copy_box(p_dst, This->info.format,
This->stride, This->layer_stride,
dst_box.x, dst_box.y, dst_box.z,
dst_box.width, dst_box.height, dst_box.depth,
p_src,
transfer->stride, transfer->layer_stride,
src_box.x, src_box.y, src_box.z);
pipe->transfer_unmap(pipe, transfer);
} else {
p_dst = NineVolume9_GetSystemMemPointer(This, 0, 0, 0);
p_src = NineVolume9_GetSystemMemPointer(From, 0, 0, 0);
util_copy_box(p_dst, This->info.format,
This->stride, This->layer_stride,
dst_box.x, dst_box.y, dst_box.z,
dst_box.width, dst_box.height, dst_box.depth,
p_src,
From->stride, From->layer_stride,
src_box.x, src_box.y, src_box.z);
}
if (This->desc.Pool == D3DPOOL_DEFAULT)
NineVolume9_MarkContainerDirty(This);
if (!r_dst && This->resource)
NineVolume9_AddDirtyRegion(This, &dst_box);
return D3D_OK;
}
void r600_test_dma(struct r600_common_screen *rscreen)
{
struct pipe_screen *screen = &rscreen->b;
struct pipe_context *ctx = screen->context_create(screen, NULL, 0);
struct r600_common_context *rctx = (struct r600_common_context*)ctx;
uint64_t max_alloc_size;
unsigned i, iterations, num_partial_copies, max_levels, max_tex_side;
unsigned num_pass = 0, num_fail = 0;
max_levels = screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS);
max_tex_side = 1 << (max_levels - 1);
/* Max 128 MB allowed for both textures. */
max_alloc_size = 128 * 1024 * 1024;
/* the seed for random test parameters */
srand(0x9b47d95b);
/* the seed for random pixel data */
s_rand_xorshift128plus(seed_xorshift128plus, false);
iterations = 1000000000; /* just kill it when you are bored */
num_partial_copies = 30;
/* These parameters are randomly generated per test:
* - whether to do one whole-surface copy or N partial copies per test
* - which tiling modes to use (LINEAR_ALIGNED, 1D, 2D)
* - which texture dimensions to use
* - whether to use VRAM (all tiling modes) and GTT (staging, linear
* only) allocations
* - random initial pixels in src
* - generate random subrectangle copies for partial blits
*/
for (i = 0; i < iterations; i++) {
struct pipe_resource tsrc = {}, tdst = {}, *src, *dst;
struct r600_texture *rdst;
struct r600_texture *rsrc;
struct cpu_texture src_cpu, dst_cpu;
unsigned bpp, max_width, max_height, max_depth, j, num;
unsigned gfx_blits = 0, dma_blits = 0, max_tex_side_gen;
unsigned max_tex_layers;
bool pass;
bool do_partial_copies = rand() & 1;
/* generate a random test case */
tsrc.target = tdst.target = PIPE_TEXTURE_2D_ARRAY;
tsrc.depth0 = tdst.depth0 = 1;
bpp = 1 << (rand() % 5);
tsrc.format = tdst.format = get_format_from_bpp(bpp);
max_tex_side_gen = generate_max_tex_side(max_tex_side);
max_tex_layers = rand() % 4 ? 1 : 5;
tsrc.width0 = (rand() % max_tex_side_gen) + 1;
tsrc.height0 = (rand() % max_tex_side_gen) + 1;
tsrc.array_size = (rand() % max_tex_layers) + 1;
/* Have a 1/4 chance of getting power-of-two dimensions. */
if (rand() % 4 == 0) {
tsrc.width0 = util_next_power_of_two(tsrc.width0);
tsrc.height0 = util_next_power_of_two(tsrc.height0);
}
if (!do_partial_copies) {
/* whole-surface copies only, same dimensions */
tdst = tsrc;
} else {
max_tex_side_gen = generate_max_tex_side(max_tex_side);
max_tex_layers = rand() % 4 ? 1 : 5;
/* many partial copies, dimensions can be different */
tdst.width0 = (rand() % max_tex_side_gen) + 1;
tdst.height0 = (rand() % max_tex_side_gen) + 1;
tdst.array_size = (rand() % max_tex_layers) + 1;
/* Have a 1/4 chance of getting power-of-two dimensions. */
if (rand() % 4 == 0) {
tdst.width0 = util_next_power_of_two(tdst.width0);
tdst.height0 = util_next_power_of_two(tdst.height0);
}
}
/* check texture sizes */
if ((uint64_t)tsrc.width0 * tsrc.height0 * tsrc.array_size * bpp +
(uint64_t)tdst.width0 * tdst.height0 * tdst.array_size * bpp >
max_alloc_size) {
/* too large, try again */
i--;
continue;
}
/* VRAM + the tiling mode depends on dimensions (3/4 of cases),
* or GTT + linear only (1/4 of cases)
*/
tsrc.usage = rand() % 4 ? PIPE_USAGE_DEFAULT : PIPE_USAGE_STAGING;
tdst.usage = rand() % 4 ? PIPE_USAGE_DEFAULT : PIPE_USAGE_STAGING;
/* Allocate textures (both the GPU and CPU copies).
* The CPU will emulate what the GPU should be doing.
*/
src = screen->resource_create(screen, &tsrc);
dst = screen->resource_create(screen, &tdst);
assert(src);
assert(dst);
rdst = (struct r600_texture*)dst;
rsrc = (struct r600_texture*)src;
alloc_cpu_texture(&src_cpu, &tsrc, bpp);
alloc_cpu_texture(&dst_cpu, &tdst, bpp);
printf("%4u: dst = (%5u x %5u x %u, %s), "
" src = (%5u x %5u x %u, %s), bpp = %2u, ",
i, tdst.width0, tdst.height0, tdst.array_size,
array_mode_to_string(rscreen, &rdst->surface),
tsrc.width0, tsrc.height0, tsrc.array_size,
array_mode_to_string(rscreen, &rsrc->surface), bpp);
fflush(stdout);
/* set src pixels */
set_random_pixels(ctx, src, &src_cpu);
/* clear dst pixels */
rctx->clear_buffer(ctx, dst, 0, rdst->surface.surf_size, 0, true);
memset(dst_cpu.ptr, 0, dst_cpu.layer_stride * tdst.array_size);
/* preparation */
max_width = MIN2(tsrc.width0, tdst.width0);
max_height = MIN2(tsrc.height0, tdst.height0);
max_depth = MIN2(tsrc.array_size, tdst.array_size);
num = do_partial_copies ? num_partial_copies : 1;
for (j = 0; j < num; j++) {
int width, height, depth;
int srcx, srcy, srcz, dstx, dsty, dstz;
struct pipe_box box;
unsigned old_num_draw_calls = rctx->num_draw_calls;
unsigned old_num_dma_calls = rctx->num_dma_calls;
if (!do_partial_copies) {
/* copy whole src to dst */
width = max_width;
height = max_height;
depth = max_depth;
srcx = srcy = srcz = dstx = dsty = dstz = 0;
} else {
/* random sub-rectangle copies from src to dst */
depth = (rand() % max_depth) + 1;
srcz = rand() % (tsrc.array_size - depth + 1);
dstz = rand() % (tdst.array_size - depth + 1);
/* special code path to hit the tiled partial copies */
if (!rsrc->surface.is_linear &&
!rdst->surface.is_linear &&
rand() & 1) {
if (max_width < 8 || max_height < 8)
continue;
width = ((rand() % (max_width / 8)) + 1) * 8;
height = ((rand() % (max_height / 8)) + 1) * 8;
srcx = rand() % (tsrc.width0 - width + 1) & ~0x7;
srcy = rand() % (tsrc.height0 - height + 1) & ~0x7;
dstx = rand() % (tdst.width0 - width + 1) & ~0x7;
dsty = rand() % (tdst.height0 - height + 1) & ~0x7;
} else {
/* just make sure that it doesn't divide by zero */
assert(max_width > 0 && max_height > 0);
width = (rand() % max_width) + 1;
height = (rand() % max_height) + 1;
srcx = rand() % (tsrc.width0 - width + 1);
srcy = rand() % (tsrc.height0 - height + 1);
dstx = rand() % (tdst.width0 - width + 1);
dsty = rand() % (tdst.height0 - height + 1);
}
/* special code path to hit out-of-bounds reads in L2T */
if (rsrc->surface.is_linear &&
!rdst->surface.is_linear &&
rand() % 4 == 0) {
srcx = 0;
srcy = 0;
srcz = 0;
}
}
/* GPU copy */
u_box_3d(srcx, srcy, srcz, width, height, depth, &box);
rctx->dma_copy(ctx, dst, 0, dstx, dsty, dstz, src, 0, &box);
/* See which engine was used. */
gfx_blits += rctx->num_draw_calls > old_num_draw_calls;
dma_blits += rctx->num_dma_calls > old_num_dma_calls;
/* CPU copy */
util_copy_box(dst_cpu.ptr, tdst.format, dst_cpu.stride,
dst_cpu.layer_stride,
dstx, dsty, dstz, width, height, depth,
src_cpu.ptr, src_cpu.stride,
src_cpu.layer_stride,
srcx, srcy, srcz);
}
pass = compare_textures(ctx, dst, &dst_cpu, bpp);
if (pass)
num_pass++;
else
num_fail++;
printf("BLITs: GFX = %2u, DMA = %2u, %s [%u/%u]\n",
gfx_blits, dma_blits, pass ? "pass" : "fail",
num_pass, num_pass+num_fail);
/* cleanup */
pipe_resource_reference(&src, NULL);
pipe_resource_reference(&dst, NULL);
free(src_cpu.ptr);
free(dst_cpu.ptr);
}
ctx->destroy(ctx);
exit(0);
}
static void
lp_resource_copy(struct pipe_context *pipe,
struct pipe_resource *dst, unsigned dst_level,
unsigned dstx, unsigned dsty, unsigned dstz,
struct pipe_resource *src, unsigned src_level,
const struct pipe_box *src_box)
{
struct llvmpipe_resource *src_tex = llvmpipe_resource(src);
struct llvmpipe_resource *dst_tex = llvmpipe_resource(dst);
const enum pipe_format format = src_tex->base.format;
unsigned width = src_box->width;
unsigned height = src_box->height;
unsigned depth = src_box->depth;
unsigned z;
llvmpipe_flush_resource(pipe,
dst, dst_level,
FALSE, /* read_only */
TRUE, /* cpu_access */
FALSE, /* do_not_block */
"blit dest");
llvmpipe_flush_resource(pipe,
src, src_level,
TRUE, /* read_only */
TRUE, /* cpu_access */
FALSE, /* do_not_block */
"blit src");
/* Fallback for buffers. */
if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
util_resource_copy_region(pipe, dst, dst_level, dstx, dsty, dstz,
src, src_level, src_box);
return;
}
/*
printf("surface copy from %u lvl %u to %u lvl %u: %u,%u,%u to %u,%u,%u %u x %u x %u\n",
src_tex->id, src_level, dst_tex->id, dst_level,
src_box->x, src_box->y, src_box->z, dstx, dsty, dstz,
src_box->width, src_box->height, src_box->depth);
*/
for (z = 0; z < src_box->depth; z++){
/* set src tiles to linear layout */
{
unsigned tx, ty, tw, th;
unsigned x, y;
adjust_to_tile_bounds(src_box->x, src_box->y, width, height,
&tx, &ty, &tw, &th);
for (y = 0; y < th; y += TILE_SIZE) {
for (x = 0; x < tw; x += TILE_SIZE) {
(void) llvmpipe_get_texture_tile_linear(src_tex,
src_box->z + z, src_level,
LP_TEX_USAGE_READ,
tx + x, ty + y);
}
}
}
/* set dst tiles to linear layout */
{
unsigned tx, ty, tw, th;
unsigned x, y;
enum lp_texture_usage usage;
adjust_to_tile_bounds(dstx, dsty, width, height, &tx, &ty, &tw, &th);
for (y = 0; y < th; y += TILE_SIZE) {
boolean contained_y = ty + y >= dsty &&
ty + y + TILE_SIZE <= dsty + height ?
TRUE : FALSE;
for (x = 0; x < tw; x += TILE_SIZE) {
boolean contained_x = tx + x >= dstx &&
tx + x + TILE_SIZE <= dstx + width ?
TRUE : FALSE;
/*
* Set the usage mode to WRITE_ALL for the tiles which are
* completely contained by the dest rectangle.
*/
if (contained_y && contained_x)
usage = LP_TEX_USAGE_WRITE_ALL;
else
usage = LP_TEX_USAGE_READ_WRITE;
(void) llvmpipe_get_texture_tile_linear(dst_tex,
dstz + z, dst_level,
usage,
tx + x, ty + y);
}
}
}
}
/* copy */
{
const ubyte *src_linear_ptr
= llvmpipe_get_texture_image_address(src_tex, src_box->z,
src_level);
ubyte *dst_linear_ptr
= llvmpipe_get_texture_image_address(dst_tex, dstz,
dst_level);
if (dst_linear_ptr && src_linear_ptr) {
util_copy_box(dst_linear_ptr, format,
llvmpipe_resource_stride(&dst_tex->base, dst_level),
dst_tex->img_stride[dst_level],
dstx, dsty, 0,
width, height, depth,
src_linear_ptr,
llvmpipe_resource_stride(&src_tex->base, src_level),
src_tex->img_stride[src_level],
src_box->x, src_box->y, 0);
}
}
}
static void *etna_pipe_transfer_map(struct pipe_context *pipe,
struct pipe_resource *resource,
unsigned level,
unsigned usage, /* a combination of PIPE_TRANSFER_x */
const struct pipe_box *box,
struct pipe_transfer **out_transfer)
{
struct etna_pipe_context *priv = etna_pipe_context(pipe);
struct etna_transfer *ptrans = util_slab_alloc(&priv->transfer_pool);
struct etna_resource *resource_priv = etna_resource(resource);
enum pipe_format format = resource->format;
if (!ptrans)
return NULL;
assert(level <= resource->last_level);
/* PIPE_TRANSFER_READ always requires a sync. */
if(usage & PIPE_TRANSFER_READ)
{
etna_finish(priv->ctx);
}
/* XXX we don't handle PIPE_TRANSFER_FLUSH_EXPLICIT; this flag can be ignored when mapping in-place,
* but when not in place we need to fire off the copy operation in transfer_flush_region (currently
* a no-op) instead of unmap. Need to handle this to support ARB_map_buffer_range extension at least.
*/
/* XXX we don't take care of current operations on the resource; which can be, at some point in the pipeline
which is not yet executed:
- bound as surface
- bound through vertex buffer
- bound through index buffer
- bound in sampler view
- used in clear_render_target / clear_depth_stencil operation
- used in blit
- used in resource_copy_region
How do other drivers record this information over course of the rendering pipeline?
Is it necessary at all? Only in case we want to provide a fast path and map the resource directly
(and for PIPE_TRANSFER_MAP_DIRECTLY) and we don't want to force a sync.
We also need to know whether the resource is in use to determine if a sync is needed (or just do it
always, but that comes at the expense of performance).
A conservative approximation without too much overhead would be to mark all resources that have
been bound at some point as busy. A drawback would be that accessing resources that have
been bound but are no longer in use for a while still carry a performance penalty. On the other hand,
the program could be using PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE or PIPE_TRANSFER_UNSYNCHRONIZED to
avoid this in the first place...
A) We use an in-pipe copy engine, and queue the copy operation after unmap so that the copy
will be performed when all current commands have been executed.
Using the RS is possible, not sure if always efficient. This can also do any kind of tiling for us.
Only possible when PIPE_TRANSFER_DISCARD_RANGE is set.
B) We discard the entire resource (or at least, the mipmap level) and allocate new memory for it.
Only possible when mapping the entire resource or PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE is set.
*/
/* No need to allocate a buffer for copying if the resource is not in use,
* and no tiling is needed, can just return a direct pointer.
*/
ptrans->in_place = resource_priv->layout == ETNA_LAYOUT_LINEAR ||
(resource_priv->layout == ETNA_LAYOUT_TILED && util_format_is_compressed(resource->format));
ptrans->base.resource = resource;
ptrans->base.level = level;
ptrans->base.usage = usage;
ptrans->base.box = *box;
struct etna_resource_level *res_level = &resource_priv->levels[level];
/* map buffer object */
void *mapped = etna_bo_map(resource_priv->bo) + res_level->offset;
if(likely(ptrans->in_place))
{
ptrans->base.stride = res_level->stride;
ptrans->base.layer_stride = res_level->layer_stride;
ptrans->buffer = mapped + etna_compute_offset(resource->format, box, res_level->stride, res_level->layer_stride);
} else {
unsigned divSizeX = util_format_get_blockwidth(format);
unsigned divSizeY = util_format_get_blockheight(format);
if(usage & PIPE_TRANSFER_MAP_DIRECTLY)
{
/* No in-place transfer possible */
util_slab_free(&priv->transfer_pool, ptrans);
return NULL;
}
ptrans->base.stride = align(box->width, divSizeX) * util_format_get_blocksize(format); /* row stride in bytes */
ptrans->base.layer_stride = align(box->height, divSizeY) * ptrans->base.stride;
size_t size = ptrans->base.layer_stride * box->depth;
ptrans->buffer = MALLOC(size);
if(usage & PIPE_TRANSFER_READ)
{
/* untile or copy resource for reading */
if(resource_priv->layout == ETNA_LAYOUT_LINEAR || resource_priv->layout == ETNA_LAYOUT_TILED)
{
if(resource_priv->layout == ETNA_LAYOUT_TILED && !util_format_is_compressed(resource_priv->base.format))
{
etna_texture_untile(ptrans->buffer, mapped + ptrans->base.box.z * res_level->layer_stride,
ptrans->base.box.x, ptrans->base.box.y, res_level->stride,
ptrans->base.box.width, ptrans->base.box.height, ptrans->base.stride,
util_format_get_blocksize(resource_priv->base.format));
} else { /* non-tiled or compressed format */
util_copy_box(ptrans->buffer,
resource_priv->base.format,
ptrans->base.stride, ptrans->base.layer_stride,
0, 0, 0, /* dst x,y,z */
ptrans->base.box.width, ptrans->base.box.height, ptrans->base.box.depth,
mapped,
res_level->stride, res_level->layer_stride,
ptrans->base.box.x, ptrans->base.box.y, ptrans->base.box.z);
}
} else /* TODO supertiling */
{
BUG("unsupported tiling %i for reading", resource_priv->layout);
}
}
}
*out_transfer = &ptrans->base;
return ptrans->buffer;
}
