<div dir="ltr">On 27 September 2013 14:18, Ian Romanick <<a href="mailto:idr@freedesktop.org" target="_blank">idr@freedesktop.org</a>> wrote: <div class="gmail_extra"><div class="gmail_quote"> <blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div>On 09/20/2013 10:15 AM, Paul Berry wrote: > Mesa/i965 currently (as of commit 1cc3b90) has an inaccurate > implementation of dFdy() which produces the same results for every > pixel in an aligned 2x2 block. This piglit test exposes the > inaccuracy. </div>Two questions: - How did you come up with the error metric values? - Why are the different? </blockquote><div> </div><div>Oops, I was experimenting with the tests while I was debugging and I forgot to restore the original error metrics. I intended for both error metrics to be 1.0e-3. </div><div>There's a huge amount of leeway for choosing the error metric, though, since the i965 driver is currently so bad--it has an error of 1.0 for dFdy. With my RFC patch "i965/fs: Improve accuracy of dFdy()." applied, the error is 0.0 for both dFdy and dFdx (the test does computations based on window coordinates, which are always exactly representable as floats on i965, so no numerical errors occur). So I don't particularly care what error bound we use; I just pulled 1.0e-3 out of the air. </div><div>Note: based on a conversation we had on Thursday, it sounded like you were going to recommend to Chia-I that we go ahead and use his less-accurate dFdx formula as the default, but switch back to the accurate version if GL_FRAGMENT_SHADER_DERIVATIVE_HINT is set to GL_NICEST or a driconf variable is set. (I haven't seen that email yet--did you forget or are you still weighing options?) If we decide to go ahead with that plan, then I should probably modify these tests so that they set GL_FRAGMENT_SHADER_DERIVATIVE_HINT to GL_NICEST. </div><div> </div><blockquote class="gmail_quote" style="margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"> <div><div> > --- > .../execution/fs-dfdx-accuracy.shader_test | 35 ++++++++++++++++++++++ > .../execution/fs-dfdy-accuracy.shader_test | 35 ++++++++++++++++++++++ > 2 files changed, 70 insertions(+) > create mode 100644 tests/spec/glsl-1.10/execution/fs-dfdx-accuracy.shader_test > create mode 100644 tests/spec/glsl-1.10/execution/fs-dfdy-accuracy.shader_test > > diff --git a/tests/spec/glsl-1.10/execution/fs-dfdx-accuracy.shader_test b/tests/spec/glsl-1.10/execution/fs-dfdx-accuracy.shader_test > new file mode 100644 > index 0000000..b8d471c > --- /dev/null > +++ b/tests/spec/glsl-1.10/execution/fs-dfdx-accuracy.shader_test > @@ -0,0 +1,35 @@ > +# The spec allows considerable leeway in how dFdx() is calculated, > +# however the expected implementation is via forward or backward > +# differencing. (Implementations are permitted, for instance, to use > +# forward differencing for some pixels and backward differencing for > +# other pixels). > +# > +# This test computes dFdx(x*y), which should exactly equal y at every > +# pixel, regardless of whether forward or backward differencing is > +# used. > + > +[require] > +GLSL >= 1.10 > + > +[vertex shader] > +void main() > +{ > + gl_Position = gl_Vertex; > +} > + > +[fragment shader] > +void main() > +{ > + float x = gl_FragCoord.x; > + float y = gl_FragCoord.y; > + float xy = x * y; > + float dxydx = dFdx(xy); > + if (distance(dxydx, y) > 1.0e-3) > + gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); > + else > + gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); > +} > + > +[test] > +draw rect -1 -1 2 2 > +probe all rgba 0.0 1.0 0.0 1.0 > diff --git a/tests/spec/glsl-1.10/execution/fs-dfdy-accuracy.shader_test b/tests/spec/glsl-1.10/execution/fs-dfdy-accuracy.shader_test > new file mode 100644 > index 0000000..5c02680 > --- /dev/null > +++ b/tests/spec/glsl-1.10/execution/fs-dfdy-accuracy.shader_test > @@ -0,0 +1,35 @@ > +# The spec allows considerable leeway in how dFdy() is calculated, > +# however the expected implementation is via forward or backward > +# differencing. (Implementations are permitted, for instance, to use > +# forward differencing for some pixels and backward differencing for > +# other pixels). > +# > +# This test computes dFdy(x*y), which should exactly equal x at every > +# pixel, regardless of whether forward or backward differencing is > +# used. > + > +[require] > +GLSL >= 1.10 > + > +[vertex shader] > +void main() > +{ > + gl_Position = gl_Vertex; > +} > + > +[fragment shader] > +void main() > +{ > + float x = gl_FragCoord.x; > + float y = gl_FragCoord.y; > + float xy = x * y; > + float dxydy = dFdy(xy); > + if (distance(dxydy, x) > 1.0e-1) > + gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); > + else > + gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); > +} > + > +[test] > +draw rect -1 -1 2 2 > +probe all rgba 0.0 1.0 0.0 1.0 > </div></div></blockquote></div> </div></div>