OpenCL中的half与float的转换

在kernel中使用half类型可以在牺牲一定精度的代价下来提升运算速度. 在kernel中, 可以比较方便的对half数据进行计算, 但在host上的, 对half的使用就没那么方便了. 查看cl_float的定义:typedef uint16_t cl_half __attribute__((aligned(2)));可知其本质是一个uint16_t. 所以, 如果直接拿cl_float的内存的值来使用的话, 系统会把它当做一个uint16_t来解析. 一般来说, 我们遇到最多的情况可能是在kernel中保为half, 然后把该内存数据复制到host, 然后在host中使用. 关于half和float的转换, 主要有如下几个方面值得注意.

使用vstore_half和vload_half

在OpenCL 1.1文档中是这么说的:

Loads from a pointer to a half and stores to a pointer to a half can be performed using the **vload_half, vload_halfn, vloada_halfn and vstore_half, vstore_halfn, vstorea_halfn **functions

respectively as described in section 6.11.7. The load functions read scalar or vector half values

from memory and convert them to a scalar or vector float value. The store functions take a

scalar or vector float value as input, convert it to a half scalar or vector value (with appropriate

rounding mode) and write the half scalar or vector value to memory

函数申明如下: vector类型类似

float vload_half (size_t offset, const __global half *p);
void vstore_half (float data, size_t offset, __global half *p);

可以知道, load时接受的half的内存数据, 然后vload_half会自动把他们变成float. store时接手的float数据, 然后vstore_half会自动把float数据变成half类型数据写入内存.

使用read_imageh和write_imageh

来看定义:

half4 read_imageh (image2d_t image, sampler_t sampler, int2 coord);
half4 read_imageh (image2d_t image, sampler_t sampler, float2 coord);

void write_imageh (image2d_t image, int2 coord, half4 color);

其中, 对于read_iamgeh, 其返回值与image2d_t的image_channel_data_type类型有关:

image_channel_data_type	返回值
CL_UNORM_INT8,or CL_UNORM_INT16	[0.0 , 1.0]
CL_SNORM_INT8, or CL_SNORM_INT16	[-1.0, 1.0]
CL_HALF_FLOAT	half精度的值

如果image2d_t的类型定义不是表格中所表示的类型, 那么read的返回值将是undefined. 同理, write写入的iamge对象也只能是定义为表格中类型.

在host中进行float和half的转换

我们前面说到在host中, half实际是按照一个unit16_t来存储, 所以我们肯定需要一个算法或者规则来解析其内存数据, 得到我们想要的half-float值. 幸好, 我在高通的opencl sdk中找到了转换方法, 大家可去下载, 贴出代码如下:

//--------------------------------------------------------------------------------------
// File: half_float.cpp
// Desc:
//
// Author:      QUALCOMM
//
//               Copyright (c) 2018 QUALCOMM Technologies, Inc.
//                         All Rights Reserved.
//                      QUALCOMM Proprietary/GTDR
//--------------------------------------------------------------------------------------

#include "half_float.h"
#include <cmath>
#include <limits>

cl_half to_half(float f)
{
    static const struct
    {
        unsigned int bit_size       = 16;                                                 // total number of bits in the representation
        unsigned int num_frac_bits  = 10;                                                 // number of fractional (mantissa) bits
        unsigned int num_exp_bits   = 5;                                                  // number of (biased) exponent bits
        unsigned int sign_bit       = 15;                                                 // position of the sign bit
        unsigned int sign_mask      = 1 << 15;                                            // mask to extract sign bit
        unsigned int frac_mask      = (1 << 10) - 1;                                      // mask to extract the fractional (mantissa) bits
        unsigned int exp_mask       = ((1 << 5) - 1) << 10;                               // mask to extract the exponent bits
        unsigned int e_max          = (1 << (5 - 1)) - 1;                                 // max value for the exponent
        int          e_min          = -((1 << (5 - 1)) - 1) + 1;                          // min value for the exponent
        unsigned int max_normal     = ((((1 << (5 - 1)) - 1) + 127) << 23) | 0x7FE000;    // max value that can be represented by the 16 bit float
        unsigned int min_normal     = ((-((1 << (5 - 1)) - 1) + 1) + 127) << 23;          // min value that can be represented by the 16 bit float
        unsigned int bias_diff      = ((unsigned int)(((1 << (5 - 1)) - 1) - 127) << 23); // difference in bias between the float16 and float32 exponent
        unsigned int frac_bits_diff = 23 - 10;                                            // difference in number of fractional bits between float16/float32
    } float16_params;

    static const struct
    {
        unsigned int abs_value_mask    = 0x7FFFFFFF; // ANDing with this value gives the abs value
        unsigned int sign_bit_mask     = 0x80000000; // ANDing with this value gives the sign
        unsigned int e_max             = 127;        // max value for the exponent
        unsigned int num_mantissa_bits = 23;         // 23 bit mantissa on single precision floats
        unsigned int mantissa_mask     = 0x007FFFFF; // 23 bit mantissa on single precision floats
    } float32_params;

    const union
    {
        float f;
        unsigned int bits;
    } value = {f};

    const unsigned int f_abs_bits = value.bits & float32_params.abs_value_mask;
    const bool         is_neg     = value.bits & float32_params.sign_bit_mask;
    const unsigned int sign       = (value.bits & float32_params.sign_bit_mask) >> (float16_params.num_frac_bits + float16_params.num_exp_bits + 1);
    cl_half            half       = 0;

    if (std::isnan(value.f))
    {
        half = float16_params.exp_mask | float16_params.frac_mask;
    }
    else if (std::isinf(value.f))
    {
        half = is_neg ? float16_params.sign_mask | float16_params.exp_mask : float16_params.exp_mask;
    }
    else if (f_abs_bits > float16_params.max_normal)
    {
        // Clamp to max float 16 value
        half = sign | (((1 << float16_params.num_exp_bits) - 1) << float16_params.num_frac_bits) | float16_params.frac_mask;
    }
    else if (f_abs_bits < float16_params.min_normal)
    {
        const unsigned int frac_bits    = (f_abs_bits & float32_params.mantissa_mask) | (1 << float32_params.num_mantissa_bits);
        const int          nshift       = float16_params.e_min + float32_params.e_max - (f_abs_bits >> float32_params.num_mantissa_bits);
        const unsigned int shifted_bits = nshift < 24 ? frac_bits >> nshift : 0;
        half                            = sign | (shifted_bits >> float16_params.frac_bits_diff);
    }
    else
    {
        half = sign | ((f_abs_bits + float16_params.bias_diff) >> float16_params.frac_bits_diff);
    }
    return half;
}

cl_float to_float(cl_half f)
{
    static const struct {
        uint16_t sign_mask                   = 0x8000;
        uint16_t exp_mask                    = 0x7C00;
        int      exp_bias                    = 15;
        int      exp_offset                  = 10;
        uint16_t biased_exp_max              = (1 << 5) - 1;
        uint16_t frac_mask                   = 0x03FF;
        float    smallest_subnormal_as_float = 5.96046448e-8f;
    } float16_params;

    static const struct {
        int sign_offset = 31;
        int exp_bias    = 127;
        int exp_offset  = 23;
    } float32_params;

    const bool     is_pos          = (f & float16_params.sign_mask) == 0;
    const uint32_t biased_exponent = (f & float16_params.exp_mask) >> float16_params.exp_offset;
    const uint32_t frac            = (f & float16_params.frac_mask);
    const bool     is_inf          = biased_exponent == float16_params.biased_exp_max
                                     && (frac == 0);

    if (is_inf)
    {
        return is_pos ? std::numeric_limits<float>::infinity() : -std::numeric_limits<float>::infinity();
    }

    const bool is_nan = biased_exponent == float16_params.biased_exp_max
                        && (frac != 0);
    if (is_nan)
    {
        return std::numeric_limits<float>::quiet_NaN();
    }

    const bool is_subnormal = biased_exponent == 0;
    if (is_subnormal)
    {
        return static_cast<float>(frac) * float16_params.smallest_subnormal_as_float * (is_pos ? 1.f : -1.f);
    }

    const int      unbiased_exp        = static_cast<int>(biased_exponent) - float16_params.exp_bias;
    const uint32_t biased_f32_exponent = static_cast<uint32_t>(unbiased_exp + float32_params.exp_bias);

    union
    {
        cl_float f;
        uint32_t ui;
    } res = {0};

    res.ui = (is_pos ? 0 : 1 << float32_params.sign_offset)
             | (biased_f32_exponent << float32_params.exp_offset)
             | (frac << (float32_params.exp_offset - float16_params.exp_offset));

    return res.f;
}

关于转换精度

贴出 一组数据给大家感受下:

//原始float数据
	11.15780, 	-128.9570, 	6.154780, 	0.9487320, 	-1327.1247, 	256.0, 		0.0, 		-127.597, 		917.0, 		-1.0047
//to_half然后在to_float的数据
11.156250 	-128.875000 	6.152344 	0.948730 	-1327.000000 	256.000000 	0.000000 	-127.562500 	917.000000 	-1.003906

根据文档, 在0~2048范围内的整数是可准确表示的. 然后对于浮点数, 精度大概可以形容为百分比的形式, 即如果数本身绝对值大, 那么相差的绝对值也大, 如果本身小, 相差的绝对值也小. 对于常用的图像处理来说, 精度一般是够了.