aboutsummaryrefslogtreecommitdiff
path: root/libffwd/dtype.h
blob: 7a7a2ad82c75f84a26295ab8c9918d5da1bda280 (plain) (blame)
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
#ifndef FFWD_DTYPE_H
#define FFWD_DTYPE_H

#include <stdint.h>
#include <string.h>

/* BF16 is the upper 16 bits of an IEEE-754 binary32, so widening one value is a
 * left shift reinterpreted as a float. Shared by every host-side caller (the
 * CPU loader, the safetensors reader); the CUDA backend keeps its own
 * __nv_bfloat16 device kernels, and kernels.c keeps the SIMD buffer variant
 * bf16_to_f32_buf for hot, contiguous conversions. */
static inline float ffwd_bf16_to_f32(uint16_t bf16) {
    uint32_t bits = (uint32_t)bf16 << 16;
    float f;
    memcpy(&f, &bits, sizeof(f));
    return f;
}

/* IEEE-754 binary16 -> binary32. Unlike BF16, F16 has a 5-bit exponent and a
 * 10-bit mantissa, so widening is a field re-pack, not a shift: rebias the
 * exponent (15 -> 127), shift the mantissa up by 13, and special-case zeros,
 * subnormals, and inf/NaN. Used by the loaders to accept F16 safetensors
 * snapshots (e.g. the public multilingual-e5 weights); there is no fused F16
 * kernel, so weights are widened to F32 once at load. */
static inline float ffwd_f16_to_f32(uint16_t f16) {
    uint32_t sign = (uint32_t)(f16 & 0x8000u) << 16;
    uint32_t exp = (f16 >> 10) & 0x1fu;
    uint32_t mant = f16 & 0x3ffu;
    uint32_t bits;
    if (exp == 0) {
        if (mant == 0) {
            bits = sign; /* signed zero */
        } else {
            /* Subnormal half: renormalize into a normal float. Shift the
             * mantissa left until its leading 1 reaches the hidden-bit
             * position, decrementing the exponent for each shift. */
            exp = 127 - 15 + 1;
            while ((mant & 0x400u) == 0) {
                mant <<= 1;
                exp--;
            }
            mant &= 0x3ffu;
            bits = sign | (exp << 23) | (mant << 13);
        }
    } else if (exp == 0x1fu) {
        bits = sign | 0x7f800000u | (mant << 13); /* inf or NaN */
    } else {
        bits = sign | ((exp + (127 - 15)) << 23) | (mant << 13);
    }
    float f;
    memcpy(&f, &bits, sizeof(f));
    return f;
}

#endif /* FFWD_DTYPE_H */