[Piglit] [PATCH 2/4] arb_shader_precision: add framework for calculating tolerances for complex functions
Micah Fedke
micah.fedke at collabora.co.uk
Thu Feb 19 13:13:58 PST 2015
On 02/19/2015 11:59 AM, Dylan Baker wrote:
> On Thu, Feb 19, 2015 at 12:06:32AM -0600, Micah Fedke wrote:
>> ---
>> generated_tests/gen_shader_precision_tests.py | 148
>> ++++++++++++++++++++++++--
>> 1 file changed, 137 insertions(+), 11 deletions(-)
>>
>> diff --git a/generated_tests/gen_shader_precision_tests.py
>> b/generated_tests/gen_shader_precision_tests.py
>> index cfa5065..0bda05a 100644
>> --- a/generated_tests/gen_shader_precision_tests.py
>> +++ b/generated_tests/gen_shader_precision_tests.py
>> @@ -49,29 +49,155 @@
>> from builtin_function import * import mako.template import os
>> +import struct
>> +import bigfloat
>
> What does bigfloat buy us that numpy doesn't? That should be part of
> yoru commit message.
>
> You'll also need to add a cmake check for bigfloat in this patch. Also,
> looking at bigfloat it seems to be a wrapper around GNU MPFR, can it be
> used on windows?
Its package page at python.org lists it as OS Independent:
https://pypi.python.org/pypi/bigfloat/
Is this the proper authority on these types of things?
>
>> from templates import template_file
>> -tolerances = {'pow': 16.0, - 'exp': 3.0,
>> - 'exp2': 3.0,
>> - 'log': 3.0,
>> - 'log2': 3.0,
>> - 'sqrt': 3.0,
>> - 'inversesqrt': 2.0,
>> - 'op-div': 2.5,
>> - 'op-assign-div': 2.5,
>> - }
>> +
>> +allowed_error_scale = 4.0
>> trig_builtins = ('sin', 'cos', 'tan', 'asin',
>> 'acos', 'atan', 'sinh', 'cosh', 'tanh',
>> 'asinh', 'acosh', 'atanh')
>> +high_precision = bigfloat.precision(113)
>> +low_precision = bigfloat.precision(23)
>> +
>> def _is_sequence(arg):
>> return (not hasattr(arg, "strip") and
>> hasattr(arg, "__iter__"))
>> +def _len_any(a):
>> + """ a version of len that returns 1 if passed a non-sequence type
>> + """
>> + return len(a) if _is_sequence(a) else 1
>
> I'm not sure how I feel about this. I have a feeling that passing
> different data types around for long periods is going to result in lots
> of hard to find bugs. Is it possible to just put non-sequence items into
> a list of one elements?
>
>> +
>> +def _floatToBits(f):
>> + s = struct.pack('>f', f)
>> + return struct.unpack('>l', s)[0]
>> +
>> +def _bitsToFloat(b):
>> + s = struct.pack('>l', b)
>> + return struct.unpack('>f', s)[0]
>> +
>> +def _ulpsize(f):
>> + """ determine _ulpsize in the direction of nearest infinity
>> + which gives the worst case scenario for edge cases
>> + """
>> + return bigfloat.next_up(f)-f if f >= 0.0 \
>> + else f-bigfloat.next_down(f)
>> +
>> +def _capture_error(precise, imprecise):
>> + """Perform the legwork of calculating the difference in error of
>> the high
>> + precision and low precision runs. Decide whether this difference
>> in error
>> + is within allowable tolerances. The range of allowable tolerances is
>> + subjective, as ARB_shader_precision (and GLSL spec as of v4.5) gives no
>> + direct guidance for complex functions. Toronto, et. al. use
>> quadrupled
>> + error as a limit in "Practically Accurate Floating-Point Math,"
>> Computing
>> + Now, Oct. 2014. Also use the difference in error and the value of
>> one ulp
>> + at the output to calculate the tolerance range in ulps for use by the
>> + shader test, should this vector pass the badlands check.
>> + """
>> +
>> + ers = []
>> + bls = []
>> + cts = []
>> + with high_precision:
>> + error = bigfloat.abs(precise - imprecise)
>> + ers.append(error)
>> + with low_precision:
>> + ulpsz = _ulpsize(imprecise)
>> + with high_precision:
>> + bls.append(error > ulpsz*allowed_error_scale)
>> + cts.append(bigfloat.round(error/ulpsz))
>> + return {'errors':ers, 'badlands':bls, 'component_tolerances':cts}
>> +
>> +def _analyze_ref_fn(fn, args):
>> + """Many functions contain ill-conditioned regions referred to as
>> "badlands"
>> + (see Toronto, et. al., "Practically Accurate Floating-Point Math,"
>> + Computing Now, Oct. 2014). Within these regions errors in the
>> inputs are
>> + magnified significantly, making the function impossible to test
>> with any
>> + reasonable accuracy. A complex function that operates on floating
>> point
>> + numbers has the potential to generate such error propagation even
>> if the
>> + inputs are exact floating point numbers, since intermediate results
>> can be
>> + generated with error. In order to identify and avoid these areas,
>> we run
>> + the function once at a lower precision and once at a higher
>> precision, and
>> + compare the outputs. Propagating errors will be greater at lower
>> precision
>> + and less at higher precision for a given set of function inputs,
>> allowing
>> + us to identify the badlands of the function.
>> + """
>> +
>> + ret = {'errors':[], 'badlands':[], 'component_tolerances':[]}
>> + with high_precision:
>> + precise = fn(args)
>> + with low_precision:
>> + imprecise = fn(args)
>> + if _len_any(imprecise) == 1:
>> + ret = _capture_error(precise, imprecise)
>> + else:
>> + for i, arg in enumerate(imprecise):
>> + rettmp = _capture_error(precise[i], arg)
>> + ret['errors'].extend(rettmp['errors'])
>> + ret['badlands'].extend(rettmp['badlands'])
>> +
>> ret['component_tolerances'].extend(rettmp['component_tolerances'])
>> + return ret
>> +
>> +simple_fns = {'op-mult': 0.0,
>> + 'op-assign-mult': 0.0,
>> + 'op-div': 2.5,
>> + 'op-assign-div': 2.5,
>> + 'pow': 16.0, + 'exp': 3.0,
>> + 'exp2': 3.0,
>> + 'log': 3.0,
>> + 'log2': 3.0,
>> + 'sqrt': 3.0,
>> + 'inversesqrt': 2.0}
>> + +complex_fns = {}
>> +
>> +componentwise_fns = ('mod', 'mix', 'smoothstep' )
>> +
>> +def _gen_tolerance(name, rettype, args):
>> + """Return the tolerance that should be allowed for a function for the
>> + test vector passed in. Return -1 for any vectors that would push the
>> + tolerance outside of acceptable bounds + """
>> + if name in simple_fns:
>> + if name == 'op-mult' or name == 'op-assign-mult':
>
> if name in ['op-mult', 'op-assign-mult']:
>
>> + x_type = glsl_type_of(args[0])
>> + y_type = glsl_type_of(args[1])
>> + if x_type.is_vector and y_type.is_matrix:
>> + mult_func = _vec_times_mat_ref
>> + elif x_type.is_matrix and y_type.is_vector:
>> + mult_func = _mat_times_vec_ref
>> + elif x_type.is_matrix and y_type.is_matrix:
>> + mult_func = _mat_times_mat_ref
>> + else:
>> + return simple_fns[name] + ret =
>> _analyze_ref_fn(mult_func, args)
>> + return -1.0 if any(ret['badlands']) else map(float,
>> ret['component_tolerances'])
>
> Generally at this point python (both upstream and community) discourage
> the use of map and filter, with a preference for comprehensions.
> [float(x) for x in ret['component_tolerances']] should be what you want.
>
> I'm also assuming that you are aware that any() will find any truthy
> value: so any number that isn't 0, any non-empty string, any non-empty
> container, etc.
>
>> + else:
>> + return simple_fns[name] + elif name in complex_fns:
>> + if name in componentwise_fns:
>> + ret = {'errors':[], 'badlands':[], 'component_tolerances':[]}
>> + for component in range(rettype.num_cols*rettype.num_rows):
>> + current_args = []
>> + for i, arg in enumerate(args):
>> + current_args.append(arg[component%len(arg)] if
>> _len_any(arg) > 1 else arg)
>> + rettmp = _analyze_ref_fn(complex_fns[name], current_args)
>> + ret['errors'].extend(rettmp['errors'])
>> + ret['badlands'].extend(rettmp['badlands'])
>> +
>> ret['component_tolerances'].extend(rettmp['component_tolerances'])
>> + else:
>> + ret = _analyze_ref_fn(complex_fns[name], args)
>> + return -1.0 if any(ret['badlands']) else map(float,
>> ret['component_tolerances'])
>> + else:
>> + return 0.0
>> +
>> def make_indexers(signature):
>> """Build a list of strings which index into every possible
>> value of the result. For example, if the result is a vec2,
>> @@ -160,7 +286,7 @@ def main():
>> with open(output_filename, 'w') as f:
>> f.write(template.render_unicode(
>> signature=signature,
>> test_vectors=test_vectors,
>> - tolerances=tolerances,
>> + tolerances=simple_fns,
>>
>> invocation=invocation,
>>
>> num_elements=num_elements,
>> indexers=indexers,
>> --
>> 2.2.2
>>
>> _______________________________________________
>> Piglit mailing list
>> Piglit at lists.freedesktop.org
>> http://lists.freedesktop.org/mailman/listinfo/piglit
--
Micah Fedke
Collabora Ltd.
+44 1223 362967
https://www.collabora.com/
https://twitter.com/collaboraltd
More information about the Piglit
mailing list