usearch 2.10.3 → 2.10.5

package/fp16/bench/ieee-element.cc

@@ -0,0 +1,272 @@
+#include <benchmark/benchmark.h>
+
+#include <fp16.h>
+#ifndef EMSCRIPTEN
+	#include <fp16/psimd.h>
+#endif
+
+#if (defined(__i386__) || defined(__x86_64__)) && defined(__F16C__)
+	#include <immintrin.h>
+#endif
+
+#ifdef FP16_COMPARATIVE_BENCHMARKS
+	#include <third-party/THHalf.h>
+	#include <third-party/npy-halffloat.h>
+	#include <third-party/eigen-half.h>
+	#include <third-party/float16-compressor.h>
+	#include <third-party/half.hpp>
+#endif
+
+static inline uint16_t next_xorshift16(uint16_t x) {
+	x ^= x >> 8;
+	x ^= x << 9;
+	x ^= x >> 5;
+	return x;
+}
+
+static inline uint32_t next_xorshift32(uint32_t x) {
+	x ^= x >> 13;
+	x ^= x << 17;
+	x ^= x >> 5;
+	return x;
+}
+#ifndef EMSCRIPTEN
+	PSIMD_INTRINSIC psimd_u16 next_xorshift16_psimd(psimd_u16 x) {
+		x ^= x >> psimd_splat_u16(8);
+		x ^= x << psimd_splat_u16(9);
+		x ^= x >> psimd_splat_u16(5);
+		return x;
+	}
+#endif
+
+
+/* Conversion from IEEE FP16 to IEEE FP32 */
+
+static void fp16_ieee_to_fp32_bits(benchmark::State& state) {
+	uint16_t fp16 = UINT16_C(0x7C00);
+	while (state.KeepRunning()) {
+		const uint32_t fp32 = fp16_ieee_to_fp32_bits(fp16);
+
+		fp16 = next_xorshift16(fp16);
+		benchmark::DoNotOptimize(fp32);
+	}
+}
+BENCHMARK(fp16_ieee_to_fp32_bits);
+
+static void fp16_ieee_to_fp32_value(benchmark::State& state) {
+	uint16_t fp16 = UINT16_C(0x7C00);
+	while (state.KeepRunning()) {
+		const float fp32 = fp16_ieee_to_fp32_value(fp16);
+
+		fp16 = next_xorshift16(fp16);
+		benchmark::DoNotOptimize(fp32);
+	}
+}
+BENCHMARK(fp16_ieee_to_fp32_value);
+
+#ifndef EMSCRIPTEN
+	static void fp16_ieee_to_fp32_psimd(benchmark::State& state) {
+		psimd_u16 fp16 = (psimd_u16) { 0x7C00, 0x7C01, 0x7C02, 0x7C03 };
+		while (state.KeepRunning()) {
+			const psimd_f32 fp32 = fp16_ieee_to_fp32_psimd(fp16);
+
+			fp16 = next_xorshift16_psimd(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(fp16_ieee_to_fp32_psimd);
+
+	static void fp16_ieee_to_fp32x2_psimd(benchmark::State& state) {
+		psimd_u16 fp16 =
+			(psimd_u16) { 0x7C00, 0x7C01, 0x7C02, 0x7C03, 0x7C04, 0x7C05, 0x7C06, 0x7C07 };
+		while (state.KeepRunning()) {
+			const psimd_f32x2 fp32 = fp16_ieee_to_fp32x2_psimd(fp16);
+
+			fp16 = next_xorshift16_psimd(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(fp16_ieee_to_fp32x2_psimd);
+#endif
+
+#ifdef FP16_COMPARATIVE_BENCHMARKS
+	static void TH_halfbits2float(benchmark::State& state) {
+		uint16_t fp16 = UINT16_C(0x7C00);
+		while (state.KeepRunning()) {
+			float fp32;
+			TH_halfbits2float(&fp16, &fp32);
+
+			fp16 = next_xorshift16(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(TH_halfbits2float);
+
+	static void npy_halfbits_to_floatbits(benchmark::State& state) {
+		uint16_t fp16 = UINT16_C(0x7C00);
+		while (state.KeepRunning()) {
+			const uint32_t fp32 = npy_halfbits_to_floatbits(fp16);
+
+			fp16 = next_xorshift16(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(npy_halfbits_to_floatbits);
+
+	static void Eigen_half_to_float(benchmark::State& state) {
+		uint16_t fp16 = UINT16_C(0x7C00);
+		while (state.KeepRunning()) {
+			const float fp32 =
+				Eigen::half_impl::half_to_float(
+					Eigen::half_impl::raw_uint16_to_half(fp16));
+
+			fp16 = next_xorshift16(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(Eigen_half_to_float);
+
+	static void Float16Compressor_decompress(benchmark::State& state) {
+		uint16_t fp16 = UINT16_C(0x7C00);
+		while (state.KeepRunning()) {
+			const float fp32 = Float16Compressor::decompress(fp16);
+
+			fp16 = next_xorshift16(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(Float16Compressor_decompress);
+
+	static void half_float_detail_half2float_table(benchmark::State& state) {
+		uint16_t fp16 = UINT16_C(0x7C00);
+		while (state.KeepRunning()) {
+			const float fp32 =
+				half_float::detail::half2float_impl(fp16,
+					half_float::detail::true_type());
+
+			fp16 = next_xorshift16(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(half_float_detail_half2float_table);
+
+	static void half_float_detail_half2float_branch(benchmark::State& state) {
+		uint16_t fp16 = UINT16_C(0x7C00);
+		while (state.KeepRunning()) {
+			const float fp32 =
+				half_float::detail::half2float_impl(fp16,
+					half_float::detail::false_type());
+
+			fp16 = next_xorshift16(fp16);
+			benchmark::DoNotOptimize(fp32);
+		}
+	}
+	BENCHMARK(half_float_detail_half2float_branch);
+#endif
+
+/* Conversion from IEEE FP32 to IEEE FP16 */
+
+static void fp16_ieee_from_fp32_value(benchmark::State& state) {
+	uint32_t fp32 = UINT32_C(0x7F800000);
+	while (state.KeepRunning()) {
+		const uint16_t fp16 = fp16_ieee_from_fp32_value(fp32_from_bits(fp32));
+
+		fp32 = next_xorshift32(fp32);
+		benchmark::DoNotOptimize(fp16);
+	}
+}
+BENCHMARK(fp16_ieee_from_fp32_value);
+
+#if (defined(__i386__) || defined(__x86_64__)) && defined(__F16C__)
+	static void fp16_ieee_from_fp32_hardware(benchmark::State& state) {
+		uint32_t fp32 = UINT32_C(0x7F800000);
+		while (state.KeepRunning()) {
+			const uint16_t fp16 = static_cast<uint16_t>(
+				_mm_cvtsi128_si32(_mm_cvtps_ph(_mm_set_ss(fp32), _MM_FROUND_CUR_DIRECTION)));
+
+			fp32 = next_xorshift32(fp32);
+			benchmark::DoNotOptimize(fp16);
+		}
+	}
+	BENCHMARK(fp16_ieee_from_fp32_hardware);
+#endif
+
+#ifdef FP16_COMPARATIVE_BENCHMARKS
+	static void TH_float2halfbits(benchmark::State& state) {
+		uint32_t fp32 = UINT32_C(0x7F800000);
+		while (state.KeepRunning()) {
+			uint16_t fp16;
+			float fp32_value = fp32_from_bits(fp32);
+			TH_float2halfbits(&fp32_value, &fp16);
+
+			fp32 = next_xorshift32(fp32);
+			benchmark::DoNotOptimize(fp16);
+		}
+	}
+	BENCHMARK(TH_float2halfbits);
+
+	static void npy_floatbits_to_halfbits(benchmark::State& state) {
+		uint32_t fp32 = UINT32_C(0x7F800000);
+		while (state.KeepRunning()) {
+			const uint16_t fp16 = npy_floatbits_to_halfbits(fp32);
+
+			fp32 = next_xorshift32(fp32);
+			benchmark::DoNotOptimize(fp16);
+		}
+	}
+	BENCHMARK(npy_floatbits_to_halfbits);
+
+	static void Eigen_float_to_half_rtne(benchmark::State& state) {
+		uint32_t fp32 = UINT32_C(0x7F800000);
+		while (state.KeepRunning()) {
+			const Eigen::half_impl::__half fp16 =
+				Eigen::half_impl::float_to_half_rtne(
+					fp32_from_bits(fp32));
+
+			fp32 = next_xorshift32(fp32);
+			benchmark::DoNotOptimize(fp16);
+		}
+	}
+	BENCHMARK(Eigen_float_to_half_rtne);
+
+	static void Float16Compressor_compress(benchmark::State& state) {
+		uint32_t fp32 = UINT32_C(0x7F800000);
+		while (state.KeepRunning()) {
+			const uint16_t fp16 = Float16Compressor::compress(fp32_from_bits(fp32));
+
+			fp32 = next_xorshift32(fp32);
+			benchmark::DoNotOptimize(fp16);
+		}
+	}
+	BENCHMARK(Float16Compressor_compress);
+
+	static void half_float_detail_float2half_table(benchmark::State& state) {
+		uint32_t fp32 = UINT32_C(0x7F800000);
+		while (state.KeepRunning()) {
+			const uint16_t fp16 =
+				half_float::detail::float2half_impl<std::round_to_nearest>(
+					fp32_from_bits(fp32),
+						half_float::detail::true_type());
+
+			fp32 = next_xorshift32(fp32);
+			benchmark::DoNotOptimize(fp16);
+		}
+	}
+	BENCHMARK(half_float_detail_float2half_table);
+
+	static void half_float_detail_float2half_branch(benchmark::State& state) {
+		uint32_t fp32 = UINT32_C(0x7F800000);
+		while (state.KeepRunning()) {
+			const uint16_t fp16 =
+				half_float::detail::float2half_impl<std::round_to_nearest>(
+					fp32_from_bits(fp32),
+						half_float::detail::false_type());
+
+			fp32 = next_xorshift32(fp32);
+			benchmark::DoNotOptimize(fp16);
+		}
+	}
+	BENCHMARK(half_float_detail_float2half_branch);
+#endif
+
+BENCHMARK_MAIN();

package/fp16/bench/to-alt-array.cc

@@ -0,0 +1,91 @@
+#include <benchmark/benchmark.h>
+
+#include <fp16.h>
+#ifndef EMSCRIPTEN
+	#include <fp16/psimd.h>
+#endif
+
+#include <vector>
+#include <random>
+#include <chrono>
+#include <functional>
+#include <algorithm>
+
+#if (defined(__i386__) || defined(__x86_64__)) && defined(__F16C__)
+	#include <immintrin.h>
+#endif
+
+#if defined(__ARM_NEON__) || defined(__aarch64__)
+	#include <arm_neon.h>
+#endif
+
+
+static void fp16_alt_from_fp32_value(benchmark::State& state) {
+	const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+	auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+	std::vector<float> fp32(state.range(0));
+	std::vector<uint16_t> fp16(state.range(0));
+	std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+	while (state.KeepRunning()) {
+		float* input = fp32.data();
+		benchmark::DoNotOptimize(input);
+
+		uint16_t* output = fp16.data();
+		const size_t n = state.range(0);
+		for (size_t i = 0; i < n; i++) {
+			output[i] = fp16_alt_from_fp32_value(input[i]);
+		}
+
+		benchmark::DoNotOptimize(output);
+	}
+	state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+}
+BENCHMARK(fp16_alt_from_fp32_value)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+#if defined(__ARM_NEON_FP) && (__ARM_NEON_FP & 0x2) || defined(__aarch64__)
+	static void hardware_vcvt_f16_f32(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			#if defined(__aarch64__)
+				const unsigned int fpcr = __builtin_aarch64_get_fpcr();
+				/* Disable flush-to-zero (bit 24) and enable Alternative FP16 format (bit 26) */
+				__builtin_aarch64_set_fpcr((fpcr & 0xFEFFFFFFu) | 0x08000000u);
+			#else
+				unsigned int fpscr;
+				__asm__ __volatile__ ("VMRS %[fpscr], fpscr" : [fpscr] "=r" (fpscr));
+				/* Disable flush-to-zero (bit 24) and enable Alternative FP16 format (bit 26) */
+				__asm__ __volatile__ ("VMSR fpscr, %[fpscr]" :
+					: [fpscr] "r" ((fpscr & 0xFEFFFFFFu) | 0x08000000u));
+			#endif
+			for (size_t i = 0; i < n; i += 4) {
+				vst1_u16(&output[i],
+					(uint16x4_t) vcvt_f16_f32(
+						vld1q_f32(&input[i])));
+			}
+			#if defined(__aarch64__)
+				__builtin_aarch64_set_fpcr(fpcr);
+			#else
+				__asm__ __volatile__ ("VMSR fpscr, %[fpscr]" :: [fpscr] "r" (fpscr));
+			#endif
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(hardware_vcvt_f16_f32)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+#endif
+
+BENCHMARK_MAIN();

package/fp16/bench/to-ieee-array.cc

@@ -0,0 +1,303 @@
+#include <benchmark/benchmark.h>
+
+#include <fp16.h>
+#ifndef EMSCRIPTEN
+	#include <fp16/psimd.h>
+#endif
+
+#include <vector>
+#include <random>
+#include <chrono>
+#include <functional>
+#include <algorithm>
+
+#if (defined(__i386__) || defined(__x86_64__)) && defined(__F16C__)
+	#include <immintrin.h>
+#endif
+
+#if defined(__ARM_NEON__) || defined(__aarch64__)
+	#include <arm_neon.h>
+#endif
+
+#ifdef FP16_COMPARATIVE_BENCHMARKS
+	#include <third-party/THHalf.h>
+	#include <third-party/npy-halffloat.h>
+	#include <third-party/eigen-half.h>
+	#include <third-party/float16-compressor.h>
+	#include <third-party/half.hpp>
+#endif
+
+
+static void fp16_ieee_from_fp32_value(benchmark::State& state) {
+	const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+	auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+	std::vector<float> fp32(state.range(0));
+	std::vector<uint16_t> fp16(state.range(0));
+	std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+	while (state.KeepRunning()) {
+		float* input = fp32.data();
+		benchmark::DoNotOptimize(input);
+
+		uint16_t* output = fp16.data();
+		const size_t n = state.range(0);
+		for (size_t i = 0; i < n; i++) {
+			output[i] = fp16_ieee_from_fp32_value(input[i]);
+		}
+
+		benchmark::DoNotOptimize(output);
+	}
+	state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+}
+BENCHMARK(fp16_ieee_from_fp32_value)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+#if (defined(__i386__) || defined(__x86_64__)) && defined(__F16C__)
+	static void hardware_mm_cvtps_ph(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i += 4) {
+				_mm_storel_epi64(
+					static_cast<__m128i*>(static_cast<void*>(&output[i])),
+					_mm_cvtps_ph(_mm_loadu_ps(&input[i]), _MM_FROUND_CUR_DIRECTION));
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(hardware_mm_cvtps_ph)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+	static void hardware_mm256_cvtps_ph(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i += 8) {
+				_mm_storeu_si128(
+					static_cast<__m128i*>(static_cast<void*>(&output[i])),
+					_mm256_cvtps_ph(_mm256_loadu_ps(&input[i]), _MM_FROUND_CUR_DIRECTION));
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(hardware_mm256_cvtps_ph)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+#endif
+
+#if defined(__ARM_NEON_FP) && (__ARM_NEON_FP & 0x2) || defined(__aarch64__)
+	static void hardware_vcvt_f16_f32(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			#if defined(__aarch64__)
+				const unsigned int fpcr = __builtin_aarch64_get_fpcr();
+				/* Disable flush-to-zero (bit 24) and Alternative FP16 format (bit 26) */
+				__builtin_aarch64_set_fpcr(fpcr & 0xF6FFFFFFu);
+			#else
+				unsigned int fpscr;
+				__asm__ __volatile__ ("VMRS %[fpscr], fpscr" : [fpscr] "=r" (fpscr));
+				/* Disable flush-to-zero (bit 24) and Alternative FP16 format (bit 26) */
+				__asm__ __volatile__ ("VMSR fpscr, %[fpscr]" :
+					: [fpscr] "r" (fpscr & 0xF6FFFFFFu));
+			#endif
+			for (size_t i = 0; i < n; i += 4) {
+				vst1_u16(&output[i],
+					(uint16x4_t) vcvt_f16_f32(
+						vld1q_f32(&input[i])));
+			}
+			#if defined(__aarch64__)
+				__builtin_aarch64_set_fpcr(fpcr);
+			#else
+				__asm__ __volatile__ ("VMSR fpscr, %[fpscr]" :: [fpscr] "r" (fpscr));
+			#endif
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(hardware_vcvt_f16_f32)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+#endif
+
+#ifdef FP16_COMPARATIVE_BENCHMARKS
+	static void TH_float2halfbits(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i++) {
+				TH_float2halfbits(&input[i], &output[i]);
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(TH_float2halfbits)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+	static void npy_floatbits_to_halfbits(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i++) {
+				output[i] = npy_floatbits_to_halfbits(fp32_to_bits(input[i]));
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(npy_floatbits_to_halfbits)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+	static void Eigen_float_to_half_rtne(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i++) {
+				output[i] = Eigen::half_impl::float_to_half_rtne(input[i]).x;
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(Eigen_float_to_half_rtne)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+	static void Float16Compressor_compress(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i++) {
+				output[i] = Float16Compressor::compress(input[i]);
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(Float16Compressor_compress)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+	static void half_float_detail_float2half_table(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i++) {
+				output[i] =
+					half_float::detail::float2half_impl<std::round_to_nearest>(
+						input[i], half_float::detail::true_type());
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(half_float_detail_float2half_table)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+
+	static void half_float_detail_float2half_branch(benchmark::State& state) {
+		const uint_fast32_t seed = std::chrono::system_clock::now().time_since_epoch().count();
+		auto rng = std::bind(std::uniform_real_distribution<float>(-1.0f, 1.0f), std::mt19937(seed));
+
+		std::vector<float> fp32(state.range(0));
+		std::vector<uint16_t> fp16(state.range(0));
+		std::generate(fp32.begin(), fp32.end(), std::ref(rng));
+
+		while (state.KeepRunning()) {
+			float* input = fp32.data();
+			benchmark::DoNotOptimize(input);
+
+			uint16_t* output = fp16.data();
+			const size_t n = state.range(0);
+			for (size_t i = 0; i < n; i++) {
+				output[i] =
+					half_float::detail::float2half_impl<std::round_to_nearest>(
+						input[i], half_float::detail::false_type());
+			}
+
+			benchmark::DoNotOptimize(output);
+		}
+		state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+	}
+	BENCHMARK(half_float_detail_float2half_branch)->RangeMultiplier(2)->Range(1<<10, 64<<20);
+#endif
+
+BENCHMARK_MAIN();

package/fp16/cmake/DownloadGoogleBenchmark.cmake

@@ -0,0 +1,15 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12 FATAL_ERROR)
+
+PROJECT(googlebenchmark-download NONE)
+
+INCLUDE(ExternalProject)
+ExternalProject_Add(googlebenchmark
+	URL https://github.com/google/benchmark/archive/v1.2.0.zip
+	URL_HASH SHA256=cc463b28cb3701a35c0855fbcefb75b29068443f1952b64dd5f4f669272e95ea
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/googlebenchmark-source"
+	BINARY_DIR "${CMAKE_BINARY_DIR}/googlebenchmark"
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+)

package/fp16/cmake/DownloadGoogleTest.cmake

@@ -0,0 +1,15 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12 FATAL_ERROR)
+
+PROJECT(googletest-download NONE)
+
+INCLUDE(ExternalProject)
+ExternalProject_Add(googletest
+	URL https://github.com/google/googletest/archive/release-1.8.0.zip
+	URL_HASH SHA256=f3ed3b58511efd272eb074a3a6d6fb79d7c2e6a0e374323d1e6bcbcc1ef141bf
+	SOURCE_DIR "${CMAKE_BINARY_DIR}/googletest-source"
+	BINARY_DIR "${CMAKE_BINARY_DIR}/googletest"
+	CONFIGURE_COMMAND ""
+	BUILD_COMMAND ""
+	INSTALL_COMMAND ""
+	TEST_COMMAND ""
+)