File size: 5,413 Bytes
8b7c501 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 |
// Auto-generated file. Do not edit!
// Template: src/f32-f16-vcvt/scalar-bitcast.c.in
// Generator: tools/xngen
//
// Copyright 2021 Google LLC
//
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree.
#include <assert.h>
#include <xnnpack/common.h>
#include <xnnpack/math.h>
#include <xnnpack/vcvt.h>
void xnn_f32_f16_vcvt_ukernel__scalar_bitcast_x4(
size_t batch,
const float* input,
void* output,
const union xnn_f32_f16_cvt_params params[restrict XNN_MIN_ELEMENTS(1)])
{
assert(batch != 0);
assert(batch % sizeof(float) == 0);
assert(input != NULL);
assert(output != NULL);
const uint32_t vnonsign_mask = params->scalar_bitcast.nonsign_mask;
const uint32_t vexp_bias = params->scalar_bitcast.exp_bias;
const float vscale_to_inf = params->scalar_bitcast.scale_to_inf;
const uint32_t vexpw_max = params->scalar_bitcast.expw_max;
const float vscale_to_zero = params->scalar_bitcast.scale_to_zero;
const uint32_t vbias_min = params->scalar_bitcast.bias_min;
const uint16_t vexph_mask = params->scalar_bitcast.exph_mask;
const uint16_t vmanth_mask = params->scalar_bitcast.manth_mask;
const uint16_t vnanh = params->scalar_bitcast.nanh;
const uint32_t* i = (const uint32_t*) input;
uint16_t* o = (uint16_t*) output;
for (; batch >= 4 * sizeof(float); batch -= 4 * sizeof(float)) {
const uint32_t vw0 = i[0];
const uint32_t vw1 = i[1];
const uint32_t vw2 = i[2];
const uint32_t vw3 = i[3];
i += 4;
const uint32_t vnonsignw0 = vw0 & vnonsign_mask;
const uint32_t vnonsignw1 = vw1 & vnonsign_mask;
const uint32_t vnonsignw2 = vw2 & vnonsign_mask;
const uint32_t vnonsignw3 = vw3 & vnonsign_mask;
float vf0 = uint32_as_float(vnonsignw0);
float vf1 = uint32_as_float(vnonsignw1);
float vf2 = uint32_as_float(vnonsignw2);
float vf3 = uint32_as_float(vnonsignw3);
const uint32_t vsignw0 = vw0 ^ vnonsignw0;
const uint32_t vsignw1 = vw1 ^ vnonsignw1;
const uint32_t vsignw2 = vw2 ^ vnonsignw2;
const uint32_t vsignw3 = vw3 ^ vnonsignw3;
uint32_t vbias0 = vnonsignw0 + vexp_bias;
uint32_t vbias1 = vnonsignw1 + vexp_bias;
uint32_t vbias2 = vnonsignw2 + vexp_bias;
uint32_t vbias3 = vnonsignw3 + vexp_bias;
vf0 *= vscale_to_inf;
vf1 *= vscale_to_inf;
vf2 *= vscale_to_inf;
vf3 *= vscale_to_inf;
vbias0 &= vexpw_max;
vbias1 &= vexpw_max;
vbias2 &= vexpw_max;
vbias3 &= vexpw_max;
vf0 *= vscale_to_zero;
vf1 *= vscale_to_zero;
vf2 *= vscale_to_zero;
vf3 *= vscale_to_zero;
vbias0 = math_max_u32(vbias0, vbias_min);
vbias1 = math_max_u32(vbias1, vbias_min);
vbias2 = math_max_u32(vbias2, vbias_min);
vbias3 = math_max_u32(vbias3, vbias_min);
vf0 += uint32_as_float(vbias0);
vf1 += uint32_as_float(vbias1);
vf2 += uint32_as_float(vbias2);
vf3 += uint32_as_float(vbias3);
const uint32_t vbits0 = float_as_uint32(vf0);
const uint32_t vbits1 = float_as_uint32(vf1);
const uint32_t vbits2 = float_as_uint32(vf2);
const uint32_t vbits3 = float_as_uint32(vf3);
const uint16_t vexph0 = (uint16_t) (vbits0 >> 13) & vexph_mask;
const uint16_t vexph1 = (uint16_t) (vbits1 >> 13) & vexph_mask;
const uint16_t vexph2 = (uint16_t) (vbits2 >> 13) & vexph_mask;
const uint16_t vexph3 = (uint16_t) (vbits3 >> 13) & vexph_mask;
const uint16_t vmanth0 = (uint16_t) vbits0 & vmanth_mask;
const uint16_t vmanth1 = (uint16_t) vbits1 & vmanth_mask;
const uint16_t vmanth2 = (uint16_t) vbits2 & vmanth_mask;
const uint16_t vmanth3 = (uint16_t) vbits3 & vmanth_mask;
const uint16_t vsignh0 = (uint16_t) (vsignw0 >> 16);
const uint16_t vsignh1 = (uint16_t) (vsignw1 >> 16);
const uint16_t vsignh2 = (uint16_t) (vsignw2 >> 16);
const uint16_t vsignh3 = (uint16_t) (vsignw3 >> 16);
uint16_t vh0 = vexph0 + vmanth0;
uint16_t vh1 = vexph1 + vmanth1;
uint16_t vh2 = vexph2 + vmanth2;
uint16_t vh3 = vexph3 + vmanth3;
if XNN_UNPREDICTABLE(vnonsignw0 > vexpw_max) {
vh0 = vnanh;
}
if XNN_UNPREDICTABLE(vnonsignw1 > vexpw_max) {
vh1 = vnanh;
}
if XNN_UNPREDICTABLE(vnonsignw2 > vexpw_max) {
vh2 = vnanh;
}
if XNN_UNPREDICTABLE(vnonsignw3 > vexpw_max) {
vh3 = vnanh;
}
vh0 |= vsignh0;
vh1 |= vsignh1;
vh2 |= vsignh2;
vh3 |= vsignh3;
o[0] = vh0;
o[1] = vh1;
o[2] = vh2;
o[3] = vh3;
o += 4;
}
if XNN_UNLIKELY(batch != 0) {
do {
const uint32_t vw = *i++;
const uint32_t vnonsignw = vw & vnonsign_mask;
float vf = uint32_as_float(vnonsignw);
const uint32_t vsignw = vw ^ vnonsignw;
uint32_t vbias = vnonsignw + vexp_bias;
vf *= vscale_to_inf;
vbias &= vexpw_max;
vf *= vscale_to_zero;
vbias = math_max_u32(vbias, vbias_min);
vf += uint32_as_float(vbias);
const uint32_t vbits = float_as_uint32(vf);
const uint16_t vexph = (uint16_t) (vbits >> 13) & vexph_mask;
const uint16_t vmanth = (uint16_t) vbits & vmanth_mask;
const uint16_t vsignh = (uint16_t) (vsignw >> 16);
uint16_t vh = vexph + vmanth;
if XNN_UNPREDICTABLE(vnonsignw > vexpw_max) {
vh = vnanh;
}
vh |= vsignh;
*o++ = vh;
batch -= sizeof(float);
} while (batch != 0);
}
}
|