| Message ID | 20220810204712.3123-9-timo@rothenpieler.org |
|---|---|
| State | New |
| Headers | show |
| Series | [FFmpeg-devel,01/11] lavu/pixfmt: add packed RGBA float16 format | expand |
| Context | Check | Description |
|---|---|---|
| andriy/make_x86 | success | Make finished |
| andriy/make_fate_x86 | success | Make fate finished |
Timo Rothenpieler: > _Float16 support was available on arm/aarch64 for a while, and with gcc > 12 was enabled on x86 as long as SSE2 is supported. > > If the target arch supports f16c, gcc emits fairly efficient assembly, > taking advantage of it. This is the case on x86-64-v3 or higher. > Without f16c, it emulates it in software using sse2 instructions. How is the performance of this emulation compared to our current code? And how is the native _Float16 performance compared to the current code? > --- > configure | 4 ++++ > libavutil/float2half.c | 2 ++ > libavutil/float2half.h | 16 ++++++++++++++++ > libavutil/half2float.c | 4 ++++ > libavutil/half2float.h | 16 ++++++++++++++++ > 5 files changed, 42 insertions(+) > > diff --git a/configure b/configure > index 6761d0cb32..2536ae012d 100755 > --- a/configure > +++ b/configure > @@ -2143,6 +2143,7 @@ ARCH_FEATURES=" > fast_64bit > fast_clz > fast_cmov > + float16 > local_aligned > simd_align_16 > simd_align_32 > @@ -5125,6 +5126,8 @@ elif enabled arm; then > ;; > esac > > + test_cflags -mfp16-format=ieee && add_cflags -mfp16-format=ieee > + > elif enabled avr32; then > > case $cpu in > @@ -6228,6 +6231,7 @@ check_builtin MemoryBarrier windows.h "MemoryBarrier()" > check_builtin sync_val_compare_and_swap "" "int *ptr; int oldval, newval; __sync_val_compare_and_swap(ptr, oldval, newval)" > check_builtin gmtime_r time.h "time_t *time; struct tm *tm; gmtime_r(time, tm)" > check_builtin localtime_r time.h "time_t *time; struct tm *tm; localtime_r(time, tm)" > +check_builtin float16 "" "_Float16 f16var" > > case "$custom_allocator" in > jemalloc) > diff --git a/libavutil/float2half.c b/libavutil/float2half.c > index dba14cef5d..1390d3acc0 100644 > --- a/libavutil/float2half.c > +++ b/libavutil/float2half.c > @@ -20,6 +20,7 @@ > > void ff_init_float2half_tables(float2half_tables *t) > { > +#if !HAVE_FLOAT16 > for (int i = 0; i < 256; i++) { > int e = i - 127; > > @@ -50,4 +51,5 @@ void ff_init_float2half_tables(float2half_tables *t) > t->shifttable[i|0x100] = 13; > } > } > +#endif > } > diff --git a/libavutil/float2half.h b/libavutil/float2half.h > index b8c9cdfc4f..8c1fb804b7 100644 > --- a/libavutil/float2half.h > +++ b/libavutil/float2half.h > @@ -20,21 +20,37 @@ > #define AVUTIL_FLOAT2HALF_H > > #include <stdint.h> > +#include "intfloat.h" > + > +#include "config.h" > > typedef struct float2half_tables { > +#if HAVE_FLOAT16 > + uint8_t dummy; > +#else > uint16_t basetable[512]; > uint8_t shifttable[512]; > +#endif > } float2half_tables; > > void ff_init_float2half_tables(float2half_tables *t); > > static inline uint16_t float2half(uint32_t f, const float2half_tables *t) > { > +#if HAVE_FLOAT16 > + union { > + _Float16 f; > + uint16_t i; > + } u; > + u.f = av_int2float(f); > + return u.i; > +#else > uint16_t h; > > h = t->basetable[(f >> 23) & 0x1ff] + ((f & 0x007fffff) >> t->shifttable[(f >> 23) & 0x1ff]); > > return h; > +#endif > } > > #endif /* AVUTIL_FLOAT2HALF_H */ > diff --git a/libavutil/half2float.c b/libavutil/half2float.c > index baac8e4093..873226d3a0 100644 > --- a/libavutil/half2float.c > +++ b/libavutil/half2float.c > @@ -18,6 +18,7 @@ > > #include "libavutil/half2float.h" > > +#if !HAVE_FLOAT16 > static uint32_t convertmantissa(uint32_t i) > { > int32_t m = i << 13; // Zero pad mantissa bits > @@ -33,9 +34,11 @@ static uint32_t convertmantissa(uint32_t i) > > return m | e; // Return combined number > } > +#endif > > void ff_init_half2float_tables(half2float_tables *t) > { > +#if !HAVE_FLOAT16 > t->mantissatable[0] = 0; > for (int i = 1; i < 1024; i++) > t->mantissatable[i] = convertmantissa(i); > @@ -60,4 +63,5 @@ void ff_init_half2float_tables(half2float_tables *t) > t->offsettable[31] = 2048; > t->offsettable[32] = 0; > t->offsettable[63] = 2048; > +#endif > } > diff --git a/libavutil/half2float.h b/libavutil/half2float.h > index cb58e44a1c..b2a7c934a6 100644 > --- a/libavutil/half2float.h > +++ b/libavutil/half2float.h > @@ -20,22 +20,38 @@ > #define AVUTIL_HALF2FLOAT_H > > #include <stdint.h> > +#include "intfloat.h" > + > +#include "config.h" > > typedef struct half2float_tables { > +#if HAVE_FLOAT16 > + uint8_t dummy; > +#else > uint32_t mantissatable[3072]; > uint32_t exponenttable[64]; > uint16_t offsettable[64]; > +#endif > } half2float_tables; > > void ff_init_half2float_tables(half2float_tables *t); > > static inline uint32_t half2float(uint16_t h, const half2float_tables *t) > { > +#if HAVE_FLOAT16 > + union { > + _Float16 f; > + uint16_t i; > + } u; > + u.i = h; > + return av_float2int(u.f); > +#else > uint32_t f; > > f = t->mantissatable[t->offsettable[h >> 10] + (h & 0x3ff)] + t->exponenttable[h >> 10]; > > return f; > +#endif > } > > #endif /* AVUTIL_HALF2FLOAT_H */
On 10.08.2022 23:03, Andreas Rheinhardt wrote: > Timo Rothenpieler: >> _Float16 support was available on arm/aarch64 for a while, and with gcc >> 12 was enabled on x86 as long as SSE2 is supported. >> >> If the target arch supports f16c, gcc emits fairly efficient assembly, >> taking advantage of it. This is the case on x86-64-v3 or higher. >> Without f16c, it emulates it in software using sse2 instructions. > > How is the performance of this emulation compared to our current code? > And how is the native _Float16 performance compared to the current code? The performance of the sse2 emulation is actually surprisingly poor, in a quick test: ./ffmpeg -s 512x512 -f rawvideo -pix_fmt rgbaf16 -i /dev/zero -vf format=yuv444p -f null - _Float16 full SSE2 emulation: frame=50074 fps=848 q=-0.0 size=N/A time=00:33:22.96 bitrate=N/A speed=33.9x _Float16 f16c accelerated (Zen2, --cpu=znver2): frame=50636 fps=1965 q=-0.0 Lsize=N/A time=00:33:45.40 bitrate=N/A speed=78.6x classic half2float full software implementation: frame=49926 fps=1605 q=-0.0 Lsize=N/A time=00:33:17.00 bitrate=N/A speed=64.2x Unfortunately I don't see a good way to runtime-detect the presence of f16c without going full self-written assembly, which would diminish the compilers ability to take advantage of f16c only ever operating on 4 or 8 values at a time. But the HAVE_FLOAT16 checks could be paired with a check for __F16C__, which seems to universally be the established define for "the code is being built f16c optimizations". That at least avoids the case of the apparently quite slow sse2 emulation.
On 8/10/2022 6:58 PM, Timo Rothenpieler wrote: > On 10.08.2022 23:03, Andreas Rheinhardt wrote: >> Timo Rothenpieler: >>> _Float16 support was available on arm/aarch64 for a while, and with gcc >>> 12 was enabled on x86 as long as SSE2 is supported. >>> >>> If the target arch supports f16c, gcc emits fairly efficient assembly, >>> taking advantage of it. This is the case on x86-64-v3 or higher. >>> Without f16c, it emulates it in software using sse2 instructions. >> >> How is the performance of this emulation compared to our current code? >> And how is the native _Float16 performance compared to the current code? > > The performance of the sse2 emulation is actually surprisingly poor, in > a quick test: > > ./ffmpeg -s 512x512 -f rawvideo -pix_fmt rgbaf16 -i /dev/zero -vf > format=yuv444p -f null - > > _Float16 full SSE2 emulation: > frame=50074 fps=848 q=-0.0 size=N/A time=00:33:22.96 bitrate=N/A > speed=33.9x > > _Float16 f16c accelerated (Zen2, --cpu=znver2): > frame=50636 fps=1965 q=-0.0 Lsize=N/A time=00:33:45.40 bitrate=N/A > speed=78.6x > > classic half2float full software implementation: > frame=49926 fps=1605 q=-0.0 Lsize=N/A time=00:33:17.00 bitrate=N/A > speed=64.2x > > Unfortunately I don't see a good way to runtime-detect the presence of > f16c without going full self-written assembly, which would diminish the > compilers ability to take advantage of f16c only ever operating on 4 or > 8 values at a time. > But the HAVE_FLOAT16 checks could be paired with a check for __F16C__, > which seems to universally be the established define for "the code is > being built f16c optimizations". That should do it, yes. We do check for __SSE__ and similar for some other lavu functions after all. > > That at least avoids the case of the apparently quite slow sse2 emulation. > _______________________________________________ > ffmpeg-devel mailing list > ffmpeg-devel@ffmpeg.org > https://ffmpeg.org/mailman/listinfo/ffmpeg-devel > > To unsubscribe, visit link above, or email > ffmpeg-devel-request@ffmpeg.org with subject "unsubscribe".
diff --git a/configure b/configure index 6761d0cb32..2536ae012d 100755 --- a/configure +++ b/configure @@ -2143,6 +2143,7 @@ ARCH_FEATURES=" fast_64bit fast_clz fast_cmov + float16 local_aligned simd_align_16 simd_align_32 @@ -5125,6 +5126,8 @@ elif enabled arm; then ;; esac + test_cflags -mfp16-format=ieee && add_cflags -mfp16-format=ieee + elif enabled avr32; then case $cpu in @@ -6228,6 +6231,7 @@ check_builtin MemoryBarrier windows.h "MemoryBarrier()" check_builtin sync_val_compare_and_swap "" "int *ptr; int oldval, newval; __sync_val_compare_and_swap(ptr, oldval, newval)" check_builtin gmtime_r time.h "time_t *time; struct tm *tm; gmtime_r(time, tm)" check_builtin localtime_r time.h "time_t *time; struct tm *tm; localtime_r(time, tm)" +check_builtin float16 "" "_Float16 f16var" case "$custom_allocator" in jemalloc) diff --git a/libavutil/float2half.c b/libavutil/float2half.c index dba14cef5d..1390d3acc0 100644 --- a/libavutil/float2half.c +++ b/libavutil/float2half.c @@ -20,6 +20,7 @@ void ff_init_float2half_tables(float2half_tables *t) { +#if !HAVE_FLOAT16 for (int i = 0; i < 256; i++) { int e = i - 127; @@ -50,4 +51,5 @@ void ff_init_float2half_tables(float2half_tables *t) t->shifttable[i|0x100] = 13; } } +#endif } diff --git a/libavutil/float2half.h b/libavutil/float2half.h index b8c9cdfc4f..8c1fb804b7 100644 --- a/libavutil/float2half.h +++ b/libavutil/float2half.h @@ -20,21 +20,37 @@ #define AVUTIL_FLOAT2HALF_H #include <stdint.h> +#include "intfloat.h" + +#include "config.h" typedef struct float2half_tables { +#if HAVE_FLOAT16 + uint8_t dummy; +#else uint16_t basetable[512]; uint8_t shifttable[512]; +#endif } float2half_tables; void ff_init_float2half_tables(float2half_tables *t); static inline uint16_t float2half(uint32_t f, const float2half_tables *t) { +#if HAVE_FLOAT16 + union { + _Float16 f; + uint16_t i; + } u; + u.f = av_int2float(f); + return u.i; +#else uint16_t h; h = t->basetable[(f >> 23) & 0x1ff] + ((f & 0x007fffff) >> t->shifttable[(f >> 23) & 0x1ff]); return h; +#endif } #endif /* AVUTIL_FLOAT2HALF_H */ diff --git a/libavutil/half2float.c b/libavutil/half2float.c index baac8e4093..873226d3a0 100644 --- a/libavutil/half2float.c +++ b/libavutil/half2float.c @@ -18,6 +18,7 @@ #include "libavutil/half2float.h" +#if !HAVE_FLOAT16 static uint32_t convertmantissa(uint32_t i) { int32_t m = i << 13; // Zero pad mantissa bits @@ -33,9 +34,11 @@ static uint32_t convertmantissa(uint32_t i) return m | e; // Return combined number } +#endif void ff_init_half2float_tables(half2float_tables *t) { +#if !HAVE_FLOAT16 t->mantissatable[0] = 0; for (int i = 1; i < 1024; i++) t->mantissatable[i] = convertmantissa(i); @@ -60,4 +63,5 @@ void ff_init_half2float_tables(half2float_tables *t) t->offsettable[31] = 2048; t->offsettable[32] = 0; t->offsettable[63] = 2048; +#endif } diff --git a/libavutil/half2float.h b/libavutil/half2float.h index cb58e44a1c..b2a7c934a6 100644 --- a/libavutil/half2float.h +++ b/libavutil/half2float.h @@ -20,22 +20,38 @@ #define AVUTIL_HALF2FLOAT_H #include <stdint.h> +#include "intfloat.h" + +#include "config.h" typedef struct half2float_tables { +#if HAVE_FLOAT16 + uint8_t dummy; +#else uint32_t mantissatable[3072]; uint32_t exponenttable[64]; uint16_t offsettable[64]; +#endif } half2float_tables; void ff_init_half2float_tables(half2float_tables *t); static inline uint32_t half2float(uint16_t h, const half2float_tables *t) { +#if HAVE_FLOAT16 + union { + _Float16 f; + uint16_t i; + } u; + u.i = h; + return av_float2int(u.f); +#else uint32_t f; f = t->mantissatable[t->offsettable[h >> 10] + (h & 0x3ff)] + t->exponenttable[h >> 10]; return f; +#endif } #endif /* AVUTIL_HALF2FLOAT_H */