virtual uint32_t get_wm_prog(struct brw_context *brw,
brw_blorp_prog_data **prog_data) const;
-protected:
brw_blorp_const_color_prog_key wm_prog_key;
};
struct gl_framebuffer *fb,
struct gl_renderbuffer *rb,
GLubyte *color_mask,
- bool partial_clear);
+ bool partial_clear,
+ unsigned layer);
};
*/
static bool
is_color_fast_clear_compatible(struct brw_context *brw,
- gl_format format,
+ mesa_format format,
const union gl_color_union *color)
{
if (_mesa_is_format_integer_color(format))
return false;
for (int i = 0; i < 4; i++) {
- if (color->f[i] != 0.0 && color->f[i] != 1.0) {
- perf_debug("Clear color unsupported by fast color clear. "
- "Falling back to slow clear.\n");
+ if (color->f[i] != 0.0 && color->f[i] != 1.0 &&
+ _mesa_format_has_color_component(format, i)) {
return false;
}
}
struct gl_framebuffer *fb,
struct gl_renderbuffer *rb,
GLubyte *color_mask,
- bool partial_clear)
+ bool partial_clear,
+ unsigned layer)
{
struct gl_context *ctx = &brw->ctx;
struct intel_renderbuffer *irb = intel_renderbuffer(rb);
- dst.set(brw, irb->mt, irb->mt_level, irb->mt_layer);
+ dst.set(brw, irb->mt, irb->mt_level, layer, true);
/* Override the surface format according to the context's sRGB rules. */
- gl_format format = _mesa_get_render_format(ctx, irb->mt->format);
+ mesa_format format = _mesa_get_render_format(ctx, irb->mt->format);
dst.brw_surfaceformat = brw->render_target_format[format];
x0 = fb->_Xmin;
* accessing tiled memory. Using this Message Type to access linear
* (untiled) memory is UNDEFINED."
*/
- if (irb->mt->region->tiling == I915_TILING_NONE)
+ if (irb->mt->tiling == I915_TILING_NONE)
wm_prog_key.use_simd16_replicated_data = false;
/* Constant color writes ignore everyting in blend and color calculator
* state. This is not documented.
*/
for (int i = 0; i < 4; i++) {
- if (!color_mask[i]) {
+ if (_mesa_format_has_color_component(irb->mt->format, i) &&
+ !color_mask[i]) {
color_write_disable[i] = true;
wm_prog_key.use_simd16_replicated_data = false;
}
}
- /* If we can do this as a fast color clear, do so. */
- if (irb->mt->mcs_state != INTEL_MCS_STATE_NONE && !partial_clear &&
- wm_prog_key.use_simd16_replicated_data &&
+ /* If we can do this as a fast color clear, do so.
+ *
+ * Note that the condition "!partial_clear" means we only try to do full
+ * buffer clears using fast color clear logic. This is necessary because
+ * the fast color clear alignment requirements mean that we typically have
+ * to clear a larger rectangle than (x0, y0) to (x1, y1). Restricting fast
+ * color clears to the full-buffer condition guarantees that the extra
+ * memory locations that get written to are outside the image boundary (and
+ * hence irrelevant). Note that the rectangle alignment requirements are
+ * never larger than the size of a tile, so there is no danger of
+ * overflowing beyond the memory belonging to the region.
+ */
+ if (irb->mt->fast_clear_state != INTEL_FAST_CLEAR_STATE_NO_MCS &&
+ !partial_clear && wm_prog_key.use_simd16_replicated_data &&
is_color_fast_clear_compatible(brw, format, &ctx->Color.ClearColor)) {
memset(push_consts, 0xff, 4*sizeof(float));
fast_clear_op = GEN7_FAST_CLEAR_OP_FAST_CLEAR;
- /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
- * Target(s)", beneath the "Fast Color Clear" bullet (p327):
- *
- * Clear pass must have a clear rectangle that must follow alignment
- * rules in terms of pixels and lines as shown in the table
- * below. Further, the clear-rectangle height and width must be
- * multiple of the following dimensions. If the height and width of
- * the render target being cleared do not meet these requirements,
- * an MCS buffer can be created such that it follows the requirement
- * and covers the RT.
- *
- * The alignment size in the table that follows is related to the
- * alignment size returned by intel_get_non_msrt_mcs_alignment(), but
- * with X alignment multiplied by 16 and Y alignment multiplied by 32.
+ /* Figure out what the clear rectangle needs to be aligned to, and how
+ * much it needs to be scaled down.
*/
- unsigned x_align, y_align;
- intel_get_non_msrt_mcs_alignment(brw, irb->mt, &x_align, &y_align);
- x_align *= 16;
- y_align *= 32;
+ unsigned x_align, y_align, x_scaledown, y_scaledown;
+
+ if (irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_NONE) {
+ /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
+ * Target(s)", beneath the "Fast Color Clear" bullet (p327):
+ *
+ * Clear pass must have a clear rectangle that must follow
+ * alignment rules in terms of pixels and lines as shown in the
+ * table below. Further, the clear-rectangle height and width
+ * must be multiple of the following dimensions. If the height
+ * and width of the render target being cleared do not meet these
+ * requirements, an MCS buffer can be created such that it
+ * follows the requirement and covers the RT.
+ *
+ * The alignment size in the table that follows is related to the
+ * alignment size returned by intel_get_non_msrt_mcs_alignment(), but
+ * with X alignment multiplied by 16 and Y alignment multiplied by 32.
+ */
+ intel_get_non_msrt_mcs_alignment(brw, irb->mt, &x_align, &y_align);
+ x_align *= 16;
+ y_align *= 32;
+
+ /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
+ * Target(s)", beneath the "Fast Color Clear" bullet (p327):
+ *
+ * In order to optimize the performance MCS buffer (when bound to
+ * 1X RT) clear similarly to MCS buffer clear for MSRT case,
+ * clear rect is required to be scaled by the following factors
+ * in the horizontal and vertical directions:
+ *
+ * The X and Y scale down factors in the table that follows are each
+ * equal to half the alignment value computed above.
+ */
+ x_scaledown = x_align / 2;
+ y_scaledown = y_align / 2;
- if (brw->is_haswell && brw->gt == 3) {
/* From BSpec: 3D-Media-GPGPU Engine > 3D Pipeline > Pixel > Pixel
- * Backend > MCS Buffer for Render Target(s) [DevIVB+]:
- * [DevHSW:GT3]: Clear rectangle must be aligned to two times the
- * number of pixels in the table shown below...
- * x_align, y_align values computed above are the relevant entries
- * in the referred table.
+ * Backend > MCS Buffer for Render Target(s) [DevIVB+] > Table "Color
+ * Clear of Non-MultiSampled Render Target Restrictions":
+ *
+ * Clear rectangle must be aligned to two times the number of
+ * pixels in the table shown below due to 16x16 hashing across the
+ * slice.
*/
- x0 = ROUND_DOWN_TO(x0, 2 * x_align);
- y0 = ROUND_DOWN_TO(y0, 2 * y_align);
- x1 = ALIGN(x1, 2 * x_align);
- y1 = ALIGN(y1, 2 * y_align);
+ x_align *= 2;
+ y_align *= 2;
} else {
- x0 = ROUND_DOWN_TO(x0, x_align);
- y0 = ROUND_DOWN_TO(y0, y_align);
- x1 = ALIGN(x1, x_align);
- y1 = ALIGN(y1, y_align);
+ /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
+ * Target(s)", beneath the "MSAA Compression" bullet (p326):
+ *
+ * Clear pass for this case requires that scaled down primitive
+ * is sent down with upper left co-ordinate to coincide with
+ * actual rectangle being cleared. For MSAA, clear rectangle’s
+ * height and width need to as show in the following table in
+ * terms of (width,height) of the RT.
+ *
+ * MSAA Width of Clear Rect Height of Clear Rect
+ * 4X Ceil(1/8*width) Ceil(1/2*height)
+ * 8X Ceil(1/2*width) Ceil(1/2*height)
+ *
+ * The text "with upper left co-ordinate to coincide with actual
+ * rectangle being cleared" is a little confusing--it seems to imply
+ * that to clear a rectangle from (x,y) to (x+w,y+h), one needs to
+ * feed the pipeline using the rectangle (x,y) to
+ * (x+Ceil(w/N),y+Ceil(h/2)), where N is either 2 or 8 depending on
+ * the number of samples. Experiments indicate that this is not
+ * quite correct; actually, what the hardware appears to do is to
+ * align whatever rectangle is sent down the pipeline to the nearest
+ * multiple of 2x2 blocks, and then scale it up by a factor of N
+ * horizontally and 2 vertically. So the resulting alignment is 4
+ * vertically and either 4 or 16 horizontally, and the scaledown
+ * factor is 2 vertically and either 2 or 8 horizontally.
+ */
+ switch (irb->mt->num_samples) {
+ case 4:
+ x_scaledown = 8;
+ break;
+ case 8:
+ x_scaledown = 2;
+ break;
+ default:
+ assert(!"Unexpected sample count for fast clear");
+ break;
+ }
+ y_scaledown = 2;
+ x_align = x_scaledown * 2;
+ y_align = y_scaledown * 2;
}
- /* From the Ivy Bridge PRM, Vol2 Part1 11.7 "MCS Buffer for Render
- * Target(s)", beneath the "Fast Color Clear" bullet (p327):
- *
- * In order to optimize the performance MCS buffer (when bound to 1X
- * RT) clear similarly to MCS buffer clear for MSRT case, clear rect
- * is required to be scaled by the following factors in the
- * horizontal and vertical directions:
- *
- * The X and Y scale down factors in the table that follows are each
- * equal to half the alignment value computed above.
- */
- unsigned x_scaledown = x_align / 2;
- unsigned y_scaledown = y_align / 2;
- x0 /= x_scaledown;
- y0 /= y_scaledown;
- x1 /= x_scaledown;
- y1 /= y_scaledown;
+ /* Do the alignment and scaledown. */
+ x0 = ROUND_DOWN_TO(x0, x_align) / x_scaledown;
+ y0 = ROUND_DOWN_TO(y0, y_align) / y_scaledown;
+ x1 = ALIGN(x1, x_align) / x_scaledown;
+ y1 = ALIGN(y1, y_align) / y_scaledown;
}
}
struct brw_context *brw,
struct intel_mipmap_tree *mt)
{
- dst.set(brw, mt, 0 /* level */, 0 /* layer */);
+ dst.set(brw, mt, 0 /* level */, 0 /* layer */, true);
/* From the Ivy Bridge PRM, Vol2 Part1 11.9 "Render Target Resolve":
*
false /* header present */);
if (unlikely(INTEL_DEBUG & DEBUG_BLORP)) {
- printf("Native code for BLORP clear:\n");
- brw_dump_compile(&func, stdout, 0, func.next_insn_offset);
- printf("\n");
+ fprintf(stderr, "Native code for BLORP clear:\n");
+ brw_dump_compile(brw, &func.store, 0, func.next_insn_offset, stderr);
+ fprintf(stderr, "\n");
}
+
+ brw_compact_instructions(&func);
return brw_get_program(&func, program_size);
}
-extern "C" {
+
bool
-brw_blorp_clear_color(struct brw_context *brw, struct gl_framebuffer *fb,
- bool partial_clear)
+do_single_blorp_clear(struct brw_context *brw, struct gl_framebuffer *fb,
+ struct gl_renderbuffer *rb, unsigned buf,
+ bool partial_clear, unsigned layer)
{
struct gl_context *ctx = &brw->ctx;
+ struct intel_renderbuffer *irb = intel_renderbuffer(rb);
- /* The constant color clear code doesn't work for multisampled surfaces, so
- * we need to support falling back to other clear mechanisms.
- * Unfortunately, our clear code is based on a bitmask that doesn't
- * distinguish individual color attachments, so we walk the attachments to
- * see if any require fallback, and fall back for all if any of them need
- * to.
- */
- for (unsigned buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
- struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
- struct intel_renderbuffer *irb = intel_renderbuffer(rb);
+ brw_blorp_clear_params params(brw, fb, rb, ctx->Color.ColorMask[buf],
+ partial_clear, layer);
- if (irb && irb->mt->msaa_layout != INTEL_MSAA_LAYOUT_NONE)
- return false;
+ bool is_fast_clear =
+ (params.fast_clear_op == GEN7_FAST_CLEAR_OP_FAST_CLEAR);
+ if (is_fast_clear) {
+ /* Record the clear color in the miptree so that it will be
+ * programmed in SURFACE_STATE by later rendering and resolve
+ * operations.
+ */
+ uint32_t new_color_value =
+ compute_fast_clear_color_bits(&ctx->Color.ClearColor);
+ if (irb->mt->fast_clear_color_value != new_color_value) {
+ irb->mt->fast_clear_color_value = new_color_value;
+ brw->state.dirty.brw |= BRW_NEW_SURFACES;
+ }
+
+ /* If the buffer is already in INTEL_FAST_CLEAR_STATE_CLEAR, the clear
+ * is redundant and can be skipped.
+ */
+ if (irb->mt->fast_clear_state == INTEL_FAST_CLEAR_STATE_CLEAR)
+ return true;
+
+ /* If the MCS buffer hasn't been allocated yet, we need to allocate
+ * it now.
+ */
+ if (!irb->mt->mcs_mt) {
+ if (!intel_miptree_alloc_non_msrt_mcs(brw, irb->mt)) {
+ /* MCS allocation failed--probably this will only happen in
+ * out-of-memory conditions. But in any case, try to recover
+ * by falling back to a non-blorp clear technique.
+ */
+ return false;
+ }
+ brw->state.dirty.brw |= BRW_NEW_SURFACES;
+ }
+ }
+
+ const char *clear_type;
+ if (is_fast_clear)
+ clear_type = "fast";
+ else if (params.wm_prog_key.use_simd16_replicated_data)
+ clear_type = "replicated";
+ else
+ clear_type = "slow";
+
+ DBG("%s (%s) to mt %p level %d layer %d\n", __FUNCTION__, clear_type,
+ irb->mt, irb->mt_level, irb->mt_layer);
+
+ brw_blorp_exec(brw, ¶ms);
+
+ if (is_fast_clear) {
+ /* Now that the fast clear has occurred, put the buffer in
+ * INTEL_FAST_CLEAR_STATE_CLEAR so that we won't waste time doing
+ * redundant clears.
+ */
+ irb->mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_CLEAR;
}
+ return true;
+}
+
+
+extern "C" {
+bool
+brw_blorp_clear_color(struct brw_context *brw, struct gl_framebuffer *fb,
+ GLbitfield mask, bool partial_clear)
+{
for (unsigned buf = 0; buf < fb->_NumColorDrawBuffers; buf++) {
struct gl_renderbuffer *rb = fb->_ColorDrawBuffers[buf];
struct intel_renderbuffer *irb = intel_renderbuffer(rb);
+ /* Only clear the buffers present in the provided mask */
+ if (((1 << fb->_ColorDrawBufferIndexes[buf]) & mask) == 0)
+ continue;
+
/* If this is an ES2 context or GL_ARB_ES2_compatibility is supported,
* the framebuffer can be complete with some attachments missing. In
* this case the _ColorDrawBuffers pointer will be NULL.
if (rb == NULL)
continue;
- brw_blorp_clear_params params(brw, fb, rb, ctx->Color.ColorMask[buf],
- partial_clear);
-
- bool is_fast_clear =
- (params.fast_clear_op == GEN7_FAST_CLEAR_OP_FAST_CLEAR);
- if (is_fast_clear) {
- /* Record the clear color in the miptree so that it will be
- * programmed in SURFACE_STATE by later rendering and resolve
- * operations.
- */
- uint32_t new_color_value =
- compute_fast_clear_color_bits(&ctx->Color.ClearColor);
- if (irb->mt->fast_clear_color_value != new_color_value) {
- irb->mt->fast_clear_color_value = new_color_value;
- brw->state.dirty.brw |= BRW_NEW_SURFACES;
- }
-
- /* If the buffer is already in INTEL_MCS_STATE_CLEAR, the clear is
- * redundant and can be skipped.
- */
- if (irb->mt->mcs_state == INTEL_MCS_STATE_CLEAR)
- continue;
-
- /* If the MCS buffer hasn't been allocated yet, we need to allocate
- * it now.
- */
- if (!irb->mt->mcs_mt) {
- if (!intel_miptree_alloc_non_msrt_mcs(brw, irb->mt)) {
- /* MCS allocation failed--probably this will only happen in
- * out-of-memory conditions. But in any case, try to recover
- * by falling back to a non-blorp clear technique.
- */
+ if (fb->MaxNumLayers > 0) {
+ unsigned layer_multiplier =
+ (irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_UMS ||
+ irb->mt->msaa_layout == INTEL_MSAA_LAYOUT_CMS) ?
+ irb->mt->num_samples : 1;
+ unsigned num_layers = irb->layer_count;
+ for (unsigned layer = 0; layer < num_layers; layer++) {
+ if (!do_single_blorp_clear(brw, fb, rb, buf, partial_clear,
+ irb->mt_layer + layer * layer_multiplier)) {
return false;
}
- brw->state.dirty.brw |= BRW_NEW_SURFACES;
}
+ } else {
+ unsigned layer = irb->mt_layer;
+ if (!do_single_blorp_clear(brw, fb, rb, buf, partial_clear, layer))
+ return false;
}
- DBG("%s to mt %p level %d layer %d\n", __FUNCTION__,
- irb->mt, irb->mt_level, irb->mt_layer);
-
- brw_blorp_exec(brw, ¶ms);
-
- if (is_fast_clear) {
- /* Now that the fast clear has occurred, put the buffer in
- * INTEL_MCS_STATE_CLEAR so that we won't waste time doing redundant
- * clears.
- */
- irb->mt->mcs_state = INTEL_MCS_STATE_CLEAR;
- }
+ irb->need_downsample = true;
}
return true;
brw_blorp_rt_resolve_params params(brw, mt);
brw_blorp_exec(brw, ¶ms);
- mt->mcs_state = INTEL_MCS_STATE_RESOLVED;
+ mt->fast_clear_state = INTEL_FAST_CLEAR_STATE_RESOLVED;
}
} /* extern "C" */
projects / mesa.git / blobdiff