powerel7
/
gui
2
0
Fork 0
Code Issues Pull Requests Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
439 Commits
1 Branch
0 Tags
28 MiB
 
 
 
 
 
 
Tree: c5e2c65c68
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c5e2c65c68'
${ noResults }
gui/SOURCES/0003-blorp-Turn-anv_CmdCopy...

312 lines
10 KiB
Raw Blame History

From d9266ae66c9db12a9c2578a33bbd5ebd131b489f Mon Sep 17 00:00:00 2001
From: Kenneth Graunke <kenneth@whitecape.org>
Date: Mon, 28 Aug 2017 15:57:20 -0700
Subject: [PATCH 3/5] blorp: Turn anv_CmdCopyBuffer into a blorp_buffer_copy()
helper.
I want to be able to copy between buffer objects using BLORP in the i965
driver. Anvil already had code to do this, in a reasonably efficient
manner - first using large bpp copies, then smaller bpp copies.
This patch moves that logic into BLORP as blorp_buffer_copy(), so we
can use it in both drivers.
Reviewed-by: Jason Ekstrand <jason@jlekstrand.net>
Signed-off-by: Lyude <lyude@redhat.com>
---
src/intel/blorp/blorp.h | 6 +++
src/intel/blorp/blorp_blit.c | 119 +++++++++++++++++++++++++++++++++++++++++++
src/intel/vulkan/anv_blorp.c | 117 +++++++-----------------------------------
3 files changed, 143 insertions(+), 99 deletions(-)
diff --git a/src/intel/blorp/blorp.h b/src/intel/blorp/blorp.h
index d19920e87f..e712b4fbb3 100644
--- a/src/intel/blorp/blorp.h
+++ b/src/intel/blorp/blorp.h
@@ -133,6 +133,12 @@ blorp_copy(struct blorp_batch *batch,
uint32_t dst_x, uint32_t dst_y,
uint32_t src_width, uint32_t src_height);
+void
+blorp_buffer_copy(struct blorp_batch *batch,
+ struct blorp_address src,
+ struct blorp_address dst,
+ uint64_t size);
+
void
blorp_fast_clear(struct blorp_batch *batch,
const struct blorp_surf *surf, enum isl_format format,
diff --git a/src/intel/blorp/blorp_blit.c b/src/intel/blorp/blorp_blit.c
index 35008cbbb0..b012a0a0b3 100644
--- a/src/intel/blorp/blorp_blit.c
+++ b/src/intel/blorp/blorp_blit.c
@@ -2513,3 +2513,122 @@ blorp_copy(struct blorp_batch *batch,
do_blorp_blit(batch, &params, &wm_prog_key, &coords);
}
+
+static enum isl_format
+isl_format_for_size(unsigned size_B)
+{
+ switch (size_B) {
+ case 1: return ISL_FORMAT_R8_UINT;
+ case 2: return ISL_FORMAT_R8G8_UINT;
+ case 4: return ISL_FORMAT_R8G8B8A8_UINT;
+ case 8: return ISL_FORMAT_R16G16B16A16_UINT;
+ case 16: return ISL_FORMAT_R32G32B32A32_UINT;
+ default:
+ unreachable("Not a power-of-two format size");
+ }
+}
+
+/**
+ * Returns the greatest common divisor of a and b that is a power of two.
+ */
+static uint64_t
+gcd_pow2_u64(uint64_t a, uint64_t b)
+{
+ assert(a > 0 || b > 0);
+
+ unsigned a_log2 = ffsll(a) - 1;
+ unsigned b_log2 = ffsll(b) - 1;
+
+ /* If either a or b is 0, then a_log2 or b_log2 till be UINT_MAX in which
+ * case, the MIN2() will take the other one. If both are 0 then we will
+ * hit the assert above.
+ */
+ return 1 << MIN2(a_log2, b_log2);
+}
+
+static void
+do_buffer_copy(struct blorp_batch *batch,
+ struct blorp_address *src,
+ struct blorp_address *dst,
+ int width, int height, int block_size)
+{
+ /* The actual format we pick doesn't matter as blorp will throw it away.
+ * The only thing that actually matters is the size.
+ */
+ enum isl_format format = isl_format_for_size(block_size);
+
+ UNUSED bool ok;
+ struct isl_surf surf;
+ ok = isl_surf_init(batch->blorp->isl_dev, &surf,
+ .dim = ISL_SURF_DIM_2D,
+ .format = format,
+ .width = width,
+ .height = height,
+ .depth = 1,
+ .levels = 1,
+ .array_len = 1,
+ .samples = 1,
+ .row_pitch = width * block_size,
+ .usage = ISL_SURF_USAGE_TEXTURE_BIT |
+ ISL_SURF_USAGE_RENDER_TARGET_BIT,
+ .tiling_flags = ISL_TILING_LINEAR_BIT);
+ assert(ok);
+
+ struct blorp_surf src_blorp_surf = {
+ .surf = &surf,
+ .addr = *src,
+ };
+
+ struct blorp_surf dst_blorp_surf = {
+ .surf = &surf,
+ .addr = *dst,
+ };
+
+ blorp_copy(batch, &src_blorp_surf, 0, 0, &dst_blorp_surf, 0, 0,
+ 0, 0, 0, 0, width, height);
+}
+
+/* This is maximum possible width/height our HW can handle */
+#define MAX_SURFACE_DIM (1ull << 14)
+
+void
+blorp_buffer_copy(struct blorp_batch *batch,
+ struct blorp_address src,
+ struct blorp_address dst,
+ uint64_t size)
+{
+ uint64_t copy_size = size;
+
+ /* First, we compute the biggest format that can be used with the
+ * given offsets and size.
+ */
+ int bs = 16;
+ bs = gcd_pow2_u64(bs, src.offset);
+ bs = gcd_pow2_u64(bs, dst.offset);
+ bs = gcd_pow2_u64(bs, size);
+
+ /* First, we make a bunch of max-sized copies */
+ uint64_t max_copy_size = MAX_SURFACE_DIM * MAX_SURFACE_DIM * bs;
+ while (copy_size >= max_copy_size) {
+ do_buffer_copy(batch, &src, &dst, MAX_SURFACE_DIM, MAX_SURFACE_DIM, bs);
+ copy_size -= max_copy_size;
+ src.offset += max_copy_size;
+ dst.offset += max_copy_size;
+ }
+
+ /* Now make a max-width copy */
+ uint64_t height = copy_size / (MAX_SURFACE_DIM * bs);
+ assert(height < MAX_SURFACE_DIM);
+ if (height != 0) {
+ uint64_t rect_copy_size = height * MAX_SURFACE_DIM * bs;
+ do_buffer_copy(batch, &src, &dst, MAX_SURFACE_DIM, height, bs);
+ copy_size -= rect_copy_size;
+ src.offset += rect_copy_size;
+ dst.offset += rect_copy_size;
+ }
+
+ /* Finally, make a small copy to finish it off */
+ if (copy_size != 0) {
+ do_buffer_copy(batch, &src, &dst, copy_size / bs, 1, bs);
+ }
+}
diff --git a/src/intel/vulkan/anv_blorp.c b/src/intel/vulkan/anv_blorp.c
index c00d38b52c..3a64b60178 100644
--- a/src/intel/vulkan/anv_blorp.c
+++ b/src/intel/vulkan/anv_blorp.c
@@ -546,56 +546,6 @@ isl_format_for_size(unsigned size_B)
}
}
-static void
-do_buffer_copy(struct blorp_batch *batch,
- struct anv_bo *src, uint64_t src_offset,
- struct anv_bo *dst, uint64_t dst_offset,
- int width, int height, int block_size)
-{
- struct anv_device *device = batch->blorp->driver_ctx;
-
- /* The actual format we pick doesn't matter as blorp will throw it away.
- * The only thing that actually matters is the size.
- */
- enum isl_format format = isl_format_for_size(block_size);
-
- UNUSED bool ok;
- struct isl_surf surf;
- ok = isl_surf_init(&device->isl_dev, &surf,
- .dim = ISL_SURF_DIM_2D,
- .format = format,
- .width = width,
- .height = height,
- .depth = 1,
- .levels = 1,
- .array_len = 1,
- .samples = 1,
- .row_pitch = width * block_size,
- .usage = ISL_SURF_USAGE_TEXTURE_BIT |
- ISL_SURF_USAGE_RENDER_TARGET_BIT,
- .tiling_flags = ISL_TILING_LINEAR_BIT);
- assert(ok);
-
- struct blorp_surf src_blorp_surf = {
- .surf = &surf,
- .addr = {
- .buffer = src,
- .offset = src_offset,
- },
- };
-
- struct blorp_surf dst_blorp_surf = {
- .surf = &surf,
- .addr = {
- .buffer = dst,
- .offset = dst_offset,
- },
- };
-
- blorp_copy(batch, &src_blorp_surf, 0, 0, &dst_blorp_surf, 0, 0,
- 0, 0, 0, 0, width, height);
-}
-
/**
* Returns the greatest common divisor of a and b that is a power of two.
*/
@@ -632,48 +582,16 @@ void anv_CmdCopyBuffer(
blorp_batch_init(&cmd_buffer->device->blorp, &batch, cmd_buffer, 0);
for (unsigned r = 0; r < regionCount; r++) {
- uint64_t src_offset = src_buffer->offset + pRegions[r].srcOffset;
- uint64_t dst_offset = dst_buffer->offset + pRegions[r].dstOffset;
- uint64_t copy_size = pRegions[r].size;
-
- /* First, we compute the biggest format that can be used with the
- * given offsets and size.
- */
- int bs = 16;
- bs = gcd_pow2_u64(bs, src_offset);
- bs = gcd_pow2_u64(bs, dst_offset);
- bs = gcd_pow2_u64(bs, pRegions[r].size);
-
- /* First, we make a bunch of max-sized copies */
- uint64_t max_copy_size = MAX_SURFACE_DIM * MAX_SURFACE_DIM * bs;
- while (copy_size >= max_copy_size) {
- do_buffer_copy(&batch, src_buffer->bo, src_offset,
- dst_buffer->bo, dst_offset,
- MAX_SURFACE_DIM, MAX_SURFACE_DIM, bs);
- copy_size -= max_copy_size;
- src_offset += max_copy_size;
- dst_offset += max_copy_size;
- }
-
- /* Now make a max-width copy */
- uint64_t height = copy_size / (MAX_SURFACE_DIM * bs);
- assert(height < MAX_SURFACE_DIM);
- if (height != 0) {
- uint64_t rect_copy_size = height * MAX_SURFACE_DIM * bs;
- do_buffer_copy(&batch, src_buffer->bo, src_offset,
- dst_buffer->bo, dst_offset,
- MAX_SURFACE_DIM, height, bs);
- copy_size -= rect_copy_size;
- src_offset += rect_copy_size;
- dst_offset += rect_copy_size;
- }
+ struct blorp_address src = {
+ .buffer = src_buffer->bo,
+ .offset = src_buffer->offset + pRegions[r].srcOffset,
+ };
+ struct blorp_address dst = {
+ .buffer = dst_buffer->bo,
+ .offset = dst_buffer->offset + pRegions[r].dstOffset,
+ };
- /* Finally, make a small copy to finish it off */
- if (copy_size != 0) {
- do_buffer_copy(&batch, src_buffer->bo, src_offset,
- dst_buffer->bo, dst_offset,
- copy_size / bs, 1, bs);
- }
+ blorp_buffer_copy(&batch, src, dst, pRegions[r].size);
}
blorp_batch_finish(&batch);
@@ -715,15 +633,16 @@ void anv_CmdUpdateBuffer(
anv_state_flush(cmd_buffer->device, tmp_data);
- int bs = 16;
- bs = gcd_pow2_u64(bs, dstOffset);
- bs = gcd_pow2_u64(bs, copy_size);
+ struct blorp_address src = {
+ .buffer = &cmd_buffer->device->dynamic_state_pool.block_pool.bo,
+ .offset = tmp_data.offset,
+ };
+ struct blorp_address dst = {
+ .buffer = dst_buffer->bo,
+ .offset = dst_buffer->offset + dstOffset,
+ };
- do_buffer_copy(&batch,
- &cmd_buffer->device->dynamic_state_pool.block_pool.bo,
- tmp_data.offset,
- dst_buffer->bo, dst_buffer->offset + dstOffset,
- copy_size / bs, 1, bs);
+ blorp_buffer_copy(&batch, src, dst, copy_size);
dataSize -= copy_size;
dstOffset += copy_size;
--
2.14.3