From: Paul Berry Date: Sat, 7 Jul 2012 15:02:48 +0000 (-0700) Subject: i965/blorp: Modify manual_blend() to avoid unnecessary loss of precision. X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=b961d37e613b8b14927c42e09d16d09d70ebcb77;p=mesa.git i965/blorp: Modify manual_blend() to avoid unnecessary loss of precision. When downsampling from an MSAA image to a single-sampled image, it is inevitable that some loss of numerical precision will occur, since we have to use 32-bit floating point registers to hold the intermediate results while blending. However, it seems reasonable to expect that when all samples corresponding to a given pixel have the exact same color value, there will be no loss of precision. Previously, we averaged samples as follows: blend = (((sample[0] + sample[1]) + sample[2]) + sample[3]) / 4 This had the potential to lose numerical precision when all samples have the same color value, since ((sample[0] + sample[1]) + sample[2]) may not be precisely representable as a 32-bit float, even if the individual samples are. This patch changes the formula to: blend = ((sample[0] + sample[1]) + (sample[2] + sample[3])) / 4 This avoids any loss of precision in the event that all samples are the same, by ensuring that each addition operation adds two equal values. As a side benefit, this puts the formula in the form we will need in order to implement correct blending of integer formats. Reviewed-by: Anuj Phogat --- diff --git a/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp b/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp index 6954733a50a..74ae52d3d89 100644 --- a/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp +++ b/src/mesa/drivers/dri/i965/brw_blorp_blit.cpp @@ -434,6 +434,11 @@ private: const sampler_message_arg *args, int num_args); void render_target_write(); + /** + * Base-2 logarithm of the maximum number of samples that can be blended. + */ + static const unsigned LOG2_MAX_BLEND_SAMPLES = 2; + void *mem_ctx; struct brw_context *brw; const brw_blorp_blit_prog_key *key; @@ -455,13 +460,8 @@ private: struct brw_reg offset; } x_transform, y_transform; - /* Data to be written to render target (4 vec16's) */ - struct brw_reg result; - - /* Auxiliary storage for data returned by a sampling operation when - * blending (4 vec16's) - */ - struct brw_reg texture_data; + /* Data read from texture (4 vec16's per array element) */ + struct brw_reg texture_data[LOG2_MAX_BLEND_SAMPLES + 1]; /* Auxiliary storage for the contents of the MCS surface. * @@ -622,7 +622,7 @@ brw_blorp_blit_program::compile(struct brw_context *brw, if (brw->intel.gen == 6) { /* Gen6 hardware an automatically blend using the SAMPLE message */ single_to_blend(); - sample(result); + sample(texture_data[0]); } else { /* Gen7+ hardware doesn't automaticaly blend. */ manual_blend(); @@ -656,7 +656,7 @@ brw_blorp_blit_program::compile(struct brw_context *brw, */ if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) mcs_fetch(); - texel_fetch(result); + texel_fetch(texture_data[0]); } /* Finally, write the fetched (or blended) value to the render target and @@ -695,8 +695,9 @@ brw_blorp_blit_program::alloc_regs() prog_data.first_curbe_grf = reg; alloc_push_const_regs(reg); reg += BRW_BLORP_NUM_PUSH_CONST_REGS; - this->result = vec16(brw_vec8_grf(reg, 0)); reg += 8; - this->texture_data = vec16(brw_vec8_grf(reg, 0)); reg += 8; + for (unsigned i = 0; i < ARRAY_SIZE(texture_data); ++i) { + this->texture_data[i] = vec16(brw_vec8_grf(reg, 0)); reg += 8; + } this->mcs_data = retype(brw_vec8_grf(reg, 0), BRW_REGISTER_TYPE_UD); reg += 8; for (int i = 0; i < 2; ++i) { @@ -711,6 +712,9 @@ brw_blorp_blit_program::alloc_regs() this->t1 = vec16(retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW)); this->t2 = vec16(retype(brw_vec8_grf(reg++, 0), BRW_REGISTER_TYPE_UW)); + /* Make sure we didn't run out of registers */ + assert(reg <= GEN7_MRF_HACK_START); + int mrf = 2; this->base_mrf = mrf; } @@ -1061,6 +1065,24 @@ brw_blorp_blit_program::single_to_blend() SWAP_XY_AND_XPYP(); } + +/** + * Count the number of trailing 1 bits in the given value. For example: + * + * count_trailing_one_bits(0) == 0 + * count_trailing_one_bits(7) == 3 + * count_trailing_one_bits(11) == 2 + */ +inline int count_trailing_one_bits(unsigned value) +{ +#if defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 304) /* gcc 3.4 or later */ + return __builtin_ctz(~value); +#else + return _mesa_bitcount(value & ~(value + 1)); +#endif +} + + void brw_blorp_blit_program::manual_blend() { @@ -1070,27 +1092,68 @@ brw_blorp_blit_program::manual_blend() if (key->tex_layout == INTEL_MSAA_LAYOUT_CMS) mcs_fetch(); - /* Gather sample 0 data first */ - s_is_zero = true; - texel_fetch(result); - - /* Gather data for remaining samples and accumulate it into result. */ - s_is_zero = false; - for (int i = 1; i < num_samples; ++i) { - brw_MOV(&func, S, brw_imm_uw(i)); - texel_fetch(texture_data); - - /* TODO: should use a smaller loop bound for non-RGBA formats */ - for (int j = 0; j < 4; ++j) { - brw_ADD(&func, offset(result, 2*j), offset(vec8(result), 2*j), - offset(vec8(texture_data), 2*j)); + /* We add together samples using a binary tree structure, e.g. for 4x MSAA: + * + * result = ((sample[0] + sample[1]) + (sample[2] + sample[3])) / 4 + * + * This ensures that when all samples have the same value, no numerical + * precision is lost, since each addition operation always adds two equal + * values, and summing two equal floating point values does not lose + * precision. + * + * We perform this computation by treating the texture_data array as a + * stack and performing the following operations: + * + * - push sample 0 onto stack + * - push sample 1 onto stack + * - add top two stack entries + * - push sample 2 onto stack + * - push sample 3 onto stack + * - add top two stack entries + * - add top two stack entries + * - divide top stack entry by 4 + * + * Note that after pushing sample i onto the stack, the number of add + * operations we do is equal to the number of trailing 1 bits in i. This + * works provided the total number of samples is a power of two, which it + * always is for i965. + */ + unsigned stack_depth = 0; + for (int i = 0; i < num_samples; ++i) { + assert(stack_depth == _mesa_bitcount(i)); /* Loop invariant */ + + /* Push sample i onto the stack */ + assert(stack_depth < ARRAY_SIZE(texture_data)); + if (i == 0) { + s_is_zero = true; + } else { + s_is_zero = false; + brw_MOV(&func, S, brw_imm_uw(i)); + } + texel_fetch(texture_data[stack_depth++]); + + /* Do count_trailing_one_bits(i) times */ + for (int j = count_trailing_one_bits(i); j-- > 0; ) { + assert(stack_depth >= 2); + --stack_depth; + + /* TODO: should use a smaller loop bound for non_RGBA formats */ + for (int k = 0; k < 4; ++k) { + brw_ADD(&func, offset(texture_data[stack_depth - 1], 2*k), + offset(vec8(texture_data[stack_depth - 1]), 2*k), + offset(vec8(texture_data[stack_depth]), 2*k)); + } } } + /* We should have just 1 sample on the stack now. */ + assert(stack_depth == 1); + /* Scale the result down by a factor of num_samples */ /* TODO: should use a smaller loop bound for non-RGBA formats */ for (int j = 0; j < 4; ++j) { - brw_MUL(&func, offset(result, 2*j), offset(vec8(result), 2*j), + brw_MUL(&func, offset(texture_data[0], 2*j), + offset(vec8(texture_data[0]), 2*j), brw_imm_f(1.0/num_samples)); } } @@ -1274,7 +1337,7 @@ brw_blorp_blit_program::render_target_write() for (int i = 0; i < 4; ++i) { /* E.g. mov(16) m2.0<1>:f r2.0<8;8,1>:f { Align1, H1 } */ brw_MOV(&func, offset(mrf_rt_write, mrf_offset), - offset(vec8(result), 2*i)); + offset(vec8(texture_data[0]), 2*i)); mrf_offset += 2; }