From: Eric Anholt Date: Tue, 19 May 2020 22:23:54 +0000 (-0700) Subject: freedreno/a5xx: Move resource layout to fdl. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=a1a739995bae4f2ad2b075416e9a310957e1a146;p=mesa.git freedreno/a5xx: Move resource layout to fdl. I'm working on fixing the 3D layouts in CI so we can stabilize it, but I wanted unit tests using the texturator scripts to make sure I don't break things. This also makes a5xx and a6xx layout easily comparable again. This is a straightforward move of the code with prsc references replaced by arguments in the style of fdl6. Part-of: --- diff --git a/src/freedreno/fdl/fd5_layout.c b/src/freedreno/fdl/fd5_layout.c new file mode 100644 index 00000000000..da74b18fe59 --- /dev/null +++ b/src/freedreno/fdl/fd5_layout.c @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2018 Rob Clark + * Copyright © 2018-2019 Google, 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 (including the next + * paragraph) 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: + * Rob Clark + */ + +#include + +#include "freedreno_layout.h" + +/* indexed by cpp: */ +static const struct { + unsigned pitchalign; + unsigned heightalign; +} tile_alignment[] = { + [1] = { 128, 32 }, + [2] = { 128, 16 }, + [3] = { 128, 16 }, + [4] = { 64, 16 }, + [8] = { 64, 16 }, + [12] = { 64, 16 }, + [16] = { 64, 16 }, +}; + +void +fdl5_layout(struct fdl_layout *layout, + enum pipe_format format, uint32_t nr_samples, + uint32_t width0, uint32_t height0, uint32_t depth0, + uint32_t mip_levels, uint32_t array_size, bool is_3d) +{ + const struct util_format_description *format_desc = + util_format_description(format); + + assert(nr_samples > 0); + layout->width0 = width0; + layout->height0 = height0; + layout->depth0 = depth0; + + layout->cpp = util_format_get_blocksize(format); + layout->cpp *= nr_samples; + layout->cpp_shift = ffs(layout->cpp) - 1; + + layout->format = format; + layout->nr_samples = nr_samples; + layout->layer_first = !is_3d; + + uint32_t pitchalign; + uint32_t heightalign; + uint32_t width = width0; + uint32_t height = height0; + uint32_t depth = depth0; + /* in layer_first layout, the level (slice) contains just one + * layer (since in fact the layer contains the slices) + */ + uint32_t layers_in_level = layout->layer_first ? 1 : array_size; + + heightalign = tile_alignment[layout->cpp].heightalign; + + for (uint32_t level = 0; level < mip_levels; level++) { + struct fdl_slice *slice = &layout->slices[level]; + uint32_t tile_mode = fdl_tile_mode(layout, level); + uint32_t aligned_height = height; + uint32_t blocks; + + if (tile_mode) { + pitchalign = tile_alignment[layout->cpp].pitchalign; + aligned_height = align(aligned_height, heightalign); + } else { + pitchalign = 64; + + /* The blits used for mem<->gmem work at a granularity of + * 32x32, which can cause faults due to over-fetch on the + * last level. The simple solution is to over-allocate a + * bit the last level to ensure any over-fetch is harmless. + * The pitch is already sufficiently aligned, but height + * may not be: + */ + if (level == mip_levels - 1) + aligned_height = align(aligned_height, 32); + } + + unsigned pitch_pixels; + if (format_desc->layout == UTIL_FORMAT_LAYOUT_ASTC) + pitch_pixels = + util_align_npot(width, pitchalign * util_format_get_blockwidth(format)); + else + pitch_pixels = align(width, pitchalign); + + slice->offset = layout->size; + blocks = util_format_get_nblocks(format, pitch_pixels, aligned_height); + slice->pitch = util_format_get_nblocksx(format, pitch_pixels) * + layout->cpp; + + const int alignment = is_3d ? 4096 : 1; + + /* 1d array and 2d array textures must all have the same layer size + * for each miplevel on a3xx. 3d textures can have different layer + * sizes for high levels, but the hw auto-sizer is buggy (or at least + * different than what this code does), so as soon as the layer size + * range gets into range, we stop reducing it. + */ + if (is_3d && ( + level == 1 || + (level > 1 && layout->slices[level - 1].size0 > 0xf000))) + slice->size0 = align(blocks * layout->cpp, alignment); + else if (level == 0 || layout->layer_first || alignment == 1) + slice->size0 = align(blocks * layout->cpp, alignment); + else + slice->size0 = layout->slices[level - 1].size0; + + layout->size += slice->size0 * depth * layers_in_level; + + width = u_minify(width, 1); + height = u_minify(height, 1); + depth = u_minify(depth, 1); + } +} + diff --git a/src/freedreno/fdl/freedreno_layout.h b/src/freedreno/fdl/freedreno_layout.h index a6a12ba2333..6753890bf4a 100644 --- a/src/freedreno/fdl/freedreno_layout.h +++ b/src/freedreno/fdl/freedreno_layout.h @@ -184,6 +184,12 @@ fdl_ubwc_enabled(const struct fdl_layout *layout, int level) void fdl_layout_buffer(struct fdl_layout *layout, uint32_t size); +void +fdl5_layout(struct fdl_layout *layout, + enum pipe_format format, uint32_t nr_samples, + uint32_t width0, uint32_t height0, uint32_t depth0, + uint32_t mip_levels, uint32_t array_size, bool is_3d); + void fdl6_layout(struct fdl_layout *layout, enum pipe_format format, uint32_t nr_samples, diff --git a/src/freedreno/fdl/meson.build b/src/freedreno/fdl/meson.build index 0bbe1b257a5..6ed83b50172 100644 --- a/src/freedreno/fdl/meson.build +++ b/src/freedreno/fdl/meson.build @@ -21,6 +21,7 @@ libfreedreno_layout = static_library( 'freedreno_layout', [ + 'fd5_layout.c', 'fd6_layout.c', 'freedreno_layout.c', ], diff --git a/src/gallium/drivers/freedreno/a5xx/fd5_resource.c b/src/gallium/drivers/freedreno/a5xx/fd5_resource.c index e879b360963..0a156d377b4 100644 --- a/src/gallium/drivers/freedreno/a5xx/fd5_resource.c +++ b/src/gallium/drivers/freedreno/a5xx/fd5_resource.c @@ -26,100 +26,6 @@ #include "fd5_resource.h" -/* indexed by cpp: */ -static const struct { - unsigned pitchalign; - unsigned heightalign; -} tile_alignment[] = { - [1] = { 128, 32 }, - [2] = { 128, 16 }, - [3] = { 128, 16 }, - [4] = { 64, 16 }, - [8] = { 64, 16 }, - [12] = { 64, 16 }, - [16] = { 64, 16 }, -}; - -/* NOTE: good way to test this is: (for example) - * piglit/bin/texelFetch fs sampler2D 100x100x1-100x300x1 - */ -static uint32_t -setup_slices(struct fd_resource *rsc, uint32_t alignment, enum pipe_format format) -{ - struct pipe_resource *prsc = &rsc->base; - enum util_format_layout layout = util_format_description(format)->layout; - uint32_t pitchalign; - uint32_t heightalign; - uint32_t level, size = 0; - uint32_t width = prsc->width0; - uint32_t height = prsc->height0; - uint32_t depth = prsc->depth0; - /* in layer_first layout, the level (slice) contains just one - * layer (since in fact the layer contains the slices) - */ - uint32_t layers_in_level = rsc->layout.layer_first ? 1 : prsc->array_size; - - heightalign = tile_alignment[rsc->layout.cpp].heightalign; - - for (level = 0; level <= prsc->last_level; level++) { - struct fdl_slice *slice = fd_resource_slice(rsc, level); - uint32_t aligned_height = height; - uint32_t blocks; - - if (fd_resource_tile_mode(prsc, level)) { - pitchalign = tile_alignment[rsc->layout.cpp].pitchalign; - aligned_height = align(aligned_height, heightalign); - } else { - pitchalign = 64; - - /* The blits used for mem<->gmem work at a granularity of - * 32x32, which can cause faults due to over-fetch on the - * last level. The simple solution is to over-allocate a - * bit the last level to ensure any over-fetch is harmless. - * The pitch is already sufficiently aligned, but height - * may not be: - */ - if ((level == prsc->last_level) && (prsc->target != PIPE_BUFFER)) - aligned_height = align(aligned_height, 32); - } - - unsigned pitch_pixels; - if (layout == UTIL_FORMAT_LAYOUT_ASTC) - pitch_pixels = - util_align_npot(width, pitchalign * util_format_get_blockwidth(format)); - else - pitch_pixels = align(width, pitchalign); - - slice->offset = size; - blocks = util_format_get_nblocks(format, pitch_pixels, aligned_height); - slice->pitch = util_format_get_nblocksx(format, pitch_pixels) * - rsc->layout.cpp; - - /* 1d array and 2d array textures must all have the same layer size - * for each miplevel on a3xx. 3d textures can have different layer - * sizes for high levels, but the hw auto-sizer is buggy (or at least - * different than what this code does), so as soon as the layer size - * range gets into range, we stop reducing it. - */ - if (prsc->target == PIPE_TEXTURE_3D && ( - level == 1 || - (level > 1 && fd_resource_slice(rsc, level - 1)->size0 > 0xf000))) - slice->size0 = align(blocks * rsc->layout.cpp, alignment); - else if (level == 0 || rsc->layout.layer_first || alignment == 1) - slice->size0 = align(blocks * rsc->layout.cpp, alignment); - else - slice->size0 = fd_resource_slice(rsc, level - 1)->size0; - - size += slice->size0 * depth * layers_in_level; - - width = u_minify(width, 1); - height = u_minify(height, 1); - depth = u_minify(depth, 1); - } - - return size; -} - static void setup_lrz(struct fd_resource *rsc) { @@ -151,21 +57,15 @@ setup_lrz(struct fd_resource *rsc) uint32_t fd5_setup_slices(struct fd_resource *rsc) { - uint32_t alignment; + struct pipe_resource *prsc = &rsc->base; if ((fd_mesa_debug & FD_DBG_LRZ) && has_depth(rsc->base.format)) setup_lrz(rsc); - switch (rsc->base.target) { - case PIPE_TEXTURE_3D: - rsc->layout.layer_first = false; - alignment = 4096; - break; - default: - rsc->layout.layer_first = true; - alignment = 1; - break; - } + fdl5_layout(&rsc->layout, prsc->format, fd_resource_nr_samples(prsc), + prsc->width0, prsc->height0, prsc->depth0, + prsc->last_level + 1, prsc->array_size, + prsc->target == PIPE_TEXTURE_3D); - return setup_slices(rsc, alignment, rsc->base.format); + return rsc->layout.size; }