Am 29.11.2012 16:50, schrieb Jose Fonseca:
> 
> 
> ----- Original Message -----
>> On 11/29/2012 08:32 AM, [email protected] wrote:
>>> From: José Fonseca<[email protected]>
>>>
>>> The current implementation was close by not fully correct: several
>>> operations that should be done in floating point were being done in
>>> integer.
>>>
>>> Fixes piglit fbo-clear-formats GL_ARB_texture_float
>>> ---
>>>   src/gallium/auxiliary/gallivm/lp_bld_conv.c |  103
>>>   +++++++++++++++++++--------
>>>   1 file changed, 73 insertions(+), 30 deletions(-)
>>>
>>> diff --git a/src/gallium/auxiliary/gallivm/lp_bld_conv.c
>>> b/src/gallium/auxiliary/gallivm/lp_bld_conv.c
>>> index cd18b0c..a48b053 100644
>>> --- a/src/gallium/auxiliary/gallivm/lp_bld_conv.c
>>> +++ b/src/gallium/auxiliary/gallivm/lp_bld_conv.c
>>> @@ -63,15 +63,18 @@
>>>
>>>   #include "util/u_debug.h"
>>>   #include "util/u_math.h"
>>> +#include "util/u_half.h"
>>>   #include "util/u_cpu_detect.h"
>>>
>>>   #include "lp_bld_type.h"
>>>   #include "lp_bld_const.h"
>>>   #include "lp_bld_arit.h"
>>> +#include "lp_bld_bitarit.h"
>>>   #include "lp_bld_pack.h"
>>>   #include "lp_bld_conv.h"
>>>   #include "lp_bld_logic.h"
>>>   #include "lp_bld_intr.h"
>>> +#include "lp_bld_printf.h"
>>>
>>>
>>>
>>> @@ -220,64 +223,104 @@ lp_build_half_to_float(struct gallivm_state
>>> *gallivm,
>>>    *
>>>    * ref
>>>    http://fgiesen.wordpress.com/2012/03/28/half-to-float-done-quic/
>>>    * ref https://gist.github.com/2156668
>>> + *
>>> + * XXX: This is approximation. It is is faster certain NaNs are
>>> converted to
>>> + * infinity, and rounding is not correct.
>>
>> I can't quite parse that comment.
> 
> Oops. Will correct.
> 
>>>    */
>>>   LLVMValueRef
>>>   lp_build_float_to_half(struct gallivm_state *gallivm,
>>>                          LLVMValueRef src)
>>>   {
>>> -   struct lp_type i32_type = lp_type_int_vec(32, 32 *
>>> LLVMGetVectorSize(LLVMTypeOf(src)));
>>> -
>>>      LLVMBuilderRef builder = gallivm->builder;
>>> -   LLVMTypeRef int_vec_type = lp_build_vec_type(gallivm,
>>> i32_type);
>>> -
>>> -   struct lp_build_context bld;
>>> -
>>> +   LLVMTypeRef f32_vec_type = LLVMTypeOf(src);
>>> +   unsigned length = LLVMGetTypeKind(f32_vec_type) ==
>>> LLVMVectorTypeKind
>>> +                   ? LLVMGetVectorSize(f32_vec_type) : 1;
>>> +   struct lp_type f32_type = lp_type_float_vec(32, 32 * length);
>>> +   struct lp_type u32_type = lp_type_uint_vec(32, 32 * length);
>>> +   struct lp_type i16_type = lp_type_int_vec(16, 16 * length);
>>> +   LLVMTypeRef u32_vec_type = lp_build_vec_type(gallivm,
>>> u32_type);
>>> +   LLVMTypeRef i16_vec_type = lp_build_vec_type(gallivm,
>>> i16_type);
>>> +   struct lp_build_context f32_bld;
>>> +   struct lp_build_context u32_bld;
>>>      LLVMValueRef result;
>>>
>>> -   lp_build_context_init(&bld, gallivm, i32_type);
>>> +   lp_build_context_init(&f32_bld, gallivm, f32_type);
>>> +   lp_build_context_init(&u32_bld, gallivm, u32_type);
>>>
>>> -   /* Extra scope because lp_build_min needs a build context, le
>>> sigh */
>>>      {
>>>         /* Constants */
>>> -      LLVMValueRef i32_13        = lp_build_const_int_vec(gallivm,
>>> i32_type, 13);
>>> -      LLVMValueRef i32_16        = lp_build_const_int_vec(gallivm,
>>> i32_type, 16);
>>> -      LLVMValueRef i32_mask_fabs = lp_build_const_int_vec(gallivm,
>>> i32_type, 0x7fffffff);
>>> -      LLVMValueRef i32_f32infty  = lp_build_const_int_vec(gallivm,
>>> i32_type, 0xff<<  23);
>>> -      LLVMValueRef i32_expinf    = lp_build_const_int_vec(gallivm,
>>> i32_type, 0xe0<<  23);
>>> -      LLVMValueRef i32_f16max    = lp_build_const_int_vec(gallivm,
>>> i32_type, 0x8f<<  23);
>>> -      LLVMValueRef i32_magic     = lp_build_const_int_vec(gallivm,
>>> i32_type, 0x0f<<  23);
>>> +      LLVMValueRef u32_f32inf    = lp_build_const_int_vec(gallivm,
>>> u32_type, 0xff<<  23);
>>> +      LLVMValueRef u32_expinf    = lp_build_const_int_vec(gallivm,
>>> u32_type, 0xe0<<  23);
>>> +      LLVMValueRef f32_f16max    = lp_build_const_vec(gallivm,
>>> f32_type, 65536.0); // 0x8f<<  23
>>> +      LLVMValueRef f32_magic     = lp_build_const_vec(gallivm,
>>> f32_type, 1.92592994e-34); // 0x0f<<  23
>>>
>>>         /* Cast from float32 to int32 */
>>> -      LLVMValueRef f             = LLVMBuildBitCast(builder, src,
>>> int_vec_type, "");
>>> +      LLVMValueRef f             = LLVMBuildBitCast(builder, src,
>>> u32_vec_type, "");
>>>
>>>         /* Remove sign */
>>> -      LLVMValueRef fabs          = LLVMBuildAnd(builder,
>>> i32_mask_fabs, f, "");
>>> +      LLVMValueRef srcabs         = lp_build_abs(&f32_bld, src);
>>> +      LLVMValueRef fabs           = LLVMBuildBitCast(builder,
>>> srcabs, u32_vec_type, "");
>>>
>>>         /* Magic conversion */
>>> -      LLVMValueRef clamped       = lp_build_min(&bld, i32_f16max,
>>> fabs);
>>> -      LLVMValueRef scaled        = LLVMBuildMul(builder, clamped,
>>> i32_magic, "");
>>> -
>>> +      LLVMValueRef clamped       = lp_build_min(&f32_bld,
>>> f32_f16max, srcabs);
>>> +      LLVMValueRef scaled        = LLVMBuildBitCast(builder,
>>> +
>>>                                                    LLVMBuildFMul(builder,
>>> +
>>>                                                                  clamped,
>>> +
>>>                                                                  f32_magic,
>>> +
>>>                                                                  ""),
>>> +                                                    u32_vec_type,
>>> +                                                    "");
>>>         /* Make sure Inf/NaN and unormalised survive */
>>> -      LLVMValueRef infnancase    = LLVMBuildXor(builder,
>>> i32_expinf, fabs, "");
>>> -      LLVMValueRef b_notnormal   = lp_build_compare(gallivm,
>>> i32_type, PIPE_FUNC_GREATER, fabs, i32_f32infty);
>>> +      LLVMValueRef infnancase    = LLVMBuildXor(builder,
>>> u32_expinf, fabs, "");
>>> +      LLVMValueRef b_notnormal   = lp_build_compare(gallivm,
>>> f32_type, PIPE_FUNC_GEQUAL,
>>> +                                                    srcabs,
>>> +
>>>                                                    LLVMBuildBitCast(builder,
>>> u32_f32inf, f32_vec_type, ""));
>>>
>>>         /* Merge normal / unnormal case */
>>> -      LLVMValueRef merge1        = LLVMBuildAnd(builder,
>>> infnancase, b_notnormal, "");
>>> -      LLVMValueRef merge2        = LLVMBuildNot(builder,
>>> LLVMBuildAnd(builder, b_notnormal, scaled, ""), "");
>>> -      LLVMValueRef merged        = LLVMBuildOr(builder, merge1,
>>> merge2, "");
>>> -      LLVMValueRef shifted       = LLVMBuildLShr(builder, merged,
>>> i32_13, "");
>>> +      LLVMValueRef merged        = lp_build_select(&u32_bld,
>>> b_notnormal, infnancase, scaled);
>>> +      LLVMValueRef shifted       = lp_build_shr_imm(&u32_bld,
>>> merged, 13);
>>>
>>>         /* Sign bit */
>>>         LLVMValueRef justsign      = LLVMBuildXor(builder, f, fabs,
>>>         "");
>>> -      LLVMValueRef signshifted   = LLVMBuildLShr(builder,
>>> justsign, i32_16, "");
>>> +      LLVMValueRef signshifted   = lp_build_shr_imm(&u32_bld,
>>> justsign, 16);
>>>
>>>         /* Combine result */
>>>         result                     = LLVMBuildOr(builder, shifted,
>>>         signshifted, "");
>>>      }
>>>
>>> -   /* Truncate from 32 bit to 16 bit */
>>> -   i32_type.width = 16;
>>> -   return LLVMBuildTrunc(builder, result,
>>> lp_build_vec_type(gallivm, i32_type), "");
>>> +   result = LLVMBuildTrunc(builder, result, i16_vec_type, "");
>>> +
>>
>> The following if (0) block is just debug code, right?  
> 
> Yes.
> 
>> It's a little
>> suspect because it manipulates the 'result' return value.  Maybe add
>> a
>> comment about what's going on.
> 
> I'm sure we'll need to revisit this code, due to the liberties it takes 
> converting, which is why I left the debug code here. I'll add a comment to 
> this effect.
> 
>>
>>> +   if (0) {
>>> +     LLVMTypeRef i32t = LLVMInt32TypeInContext(gallivm->context);
>>> +     LLVMTypeRef i16t = LLVMInt16TypeInContext(gallivm->context);
>>> +     LLVMTypeRef f32t = LLVMFloatTypeInContext(gallivm->context);
>>> +     unsigned i;
>>> +
>>> +     LLVMTypeRef func_type = LLVMFunctionType(i16t,&f32t, 1, 0);
>>> +     LLVMValueRef func = lp_build_const_int_pointer(gallivm,
>>> func_to_pointer((func_pointer)util_float_to_half));
>>> +     func = LLVMBuildBitCast(builder, func,
>>> LLVMPointerType(func_type, 0), "util_float_to_half");
>>> +
>>> +     lp_build_print_value(gallivm, "src  = ", src);
>>> +     lp_build_print_value(gallivm, "util = ", result);
>>> +     lp_build_print_value(gallivm, "llvm = ", result);
>>> +
>>> +     result = LLVMGetUndef(LLVMVectorType(i16t, length));
>>> +     for (i = 0; i<  length; ++i) {
>>> +        LLVMValueRef index = LLVMConstInt(i32t, i, 0);
>>> +        LLVMValueRef f32 = LLVMBuildExtractElement(builder, src,
>>> index, "");
>>> +#if 0
>>> +        /* XXX: not really supported by backends */
>>> +        LLVMValueRef f16 = lp_build_intrinsic_unary(builder,
>>> "llvm.convert.to.fp16", i16t, f32);
>>> +#else
>>> +        LLVMValueRef f16 = LLVMBuildCall(builder, func,&f32, 1,
>>> "");
>>> +#endif
>>> +        result = LLVMBuildInsertElement(builder, result, f16,
>>> index, "");
>>> +     }
>>> +
>>> +     lp_build_printf(gallivm, "\n");
>>> +  }
>>> +
>>> +   return result;
>>>   }
>>>
>>>
>>
>> I didn't study the code in detail (it's pretty dense), but it looks
>> OK
>> on the surface.  Roland?
>>
>> Reviewed-by: Brian Paul <[email protected]>
> 

Looks good to me as well.
There are llvm intrinisics for converting from/to half-floats
(llvm.convert.from.fp16, llvm.convert.to.fp16) which might be worth a
try - though from the specs it looks like they don't support vectors
which would be very unfortunate (and I don't know if they'd work on
backends which don't have hw support for it). Otherwise, we should
probably also add support for f16c/cvt16 CVTPS2PH/CVTPH2PS instructions
manually on supported cpus (Ivy Bridge, Bulldozer) which do exactly what
we want without any magic (and of course an order of magnitude faster).

Roland

_______________________________________________
mesa-dev mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/mesa-dev

Reply via email to