Eigen  5.0.1-dev+master
 
Loading...
Searching...
No Matches
PacketMathFP16.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2025 Kseniya Zaytseva <kseniya.zaytseva@syntacore.com>
5//
6// This Source Code Form is subject to the terms of the Mozilla
7// Public License v. 2.0. If a copy of the MPL was not distributed
8// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9// SPDX-License-Identifier: MPL-2.0
10
11#ifndef EIGEN_PACKET_MATH_FP16_RVV10_H
12#define EIGEN_PACKET_MATH_FP16_RVV10_H
13
14// IWYU pragma: private
15#include "../../InternalHeaderCheck.h"
16
17namespace Eigen {
18namespace internal {
19
20using Packet1Xh = eigen_packet_wrapper<vfloat16m1_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL))), 24>;
21using Packet2Xh =
22 eigen_packet_wrapper<vfloat16m2_t __attribute__((riscv_rvv_vector_bits(EIGEN_RISCV64_RVV_VL * 2))), 25>;
23
24template <>
25struct rvv_half_packet<Packet2Xh> {
26 using type = Packet1Xh;
27};
28
29template <>
30struct unpacket_traits<Packet1Xh> : rvv_default_unpacket_traits<Eigen::half, Packet1Xh, 1> {
31 using integer_packet = Packet1Xs;
32 using packet_mask = PacketMask16;
33};
34
35template <>
36struct unpacket_traits<Packet2Xh> : rvv_default_unpacket_traits<Eigen::half, Packet2Xh, 2> {
37 using integer_packet = Packet2Xs;
38 using packet_mask = PacketMask8;
39};
40
41#if EIGEN_RISCV64_DEFAULT_LMUL == 1
42using PacketXh = Packet1Xh;
43#else
44using PacketXh = Packet2Xh;
45#endif
46
47template <>
48struct packet_traits<Eigen::half> : rvv_default_packet_traits<Eigen::half, PacketXh> {
49 enum {
50 HasAdd = 1,
51 HasSub = 1,
52 HasShift = 1,
53 HasMul = 1,
54 HasNegate = 1,
55 HasAbs = 1,
56 HasArg = 0,
57 HasAbs2 = 1,
58 HasMin = 1,
59 HasMax = 1,
60 HasConj = 1,
61 HasSetLinear = 0,
62 HasBlend = 0,
63 HasReduxp = 0,
64 HasSign = 0,
65
66 HasCmp = 1,
67 HasDiv = 1,
68 HasRound = 1,
69
70 HasSin = EIGEN_FAST_MATH,
71 HasCos = EIGEN_FAST_MATH,
72 HasLog = 0,
73 HasExp = 0,
74 HasSqrt = 1,
75 HasTanh = EIGEN_FAST_MATH,
76 HasErf = 0
77 };
78};
79
80/********************************* Packet1Xh ************************************/
81
82EIGEN_STRONG_INLINE Packet1Xh __riscv_vreinterpret_v_u32m1_f16m1(const Packet1Xu& a) {
83 return __riscv_vreinterpret_v_u16m1_f16m1(__riscv_vreinterpret_v_u32m1_u16m1(a));
84}
85
86template <>
87EIGEN_STRONG_INLINE Packet1Xh ptrue<Packet1Xh>(const Packet1Xh& /*a*/) {
88 Packet1Xh r = __riscv_vreinterpret_f16m1(__riscv_vmv_v_x_u16m1(0xffffu, unpacket_traits<Packet1Xh>::size));
89 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
90 return r;
91}
92
93template <>
94EIGEN_STRONG_INLINE Packet1Xh pzero<Packet1Xh>(const Packet1Xh& /*a*/) {
95 return __riscv_vfmv_v_f_f16m1(static_cast<_Float16>(0.0), unpacket_traits<Packet1Xh>::size);
96}
97
98template <>
99EIGEN_STRONG_INLINE Packet1Xh pabs(const Packet1Xh& a) {
100 return __riscv_vfabs_v_f16m1(a, unpacket_traits<Packet1Xh>::size);
101}
102
103template <>
104EIGEN_STRONG_INLINE Packet1Xh pabsdiff(const Packet1Xh& a, const Packet1Xh& b) {
105 return __riscv_vfabs_v_f16m1(__riscv_vfsub_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size),
106 unpacket_traits<Packet1Xh>::size);
107}
108
109template <>
110EIGEN_STRONG_INLINE Packet1Xh pset1<Packet1Xh>(const Eigen::half& from) {
111 return __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(from), unpacket_traits<Packet1Xh>::size);
112}
113
114template <>
115EIGEN_STRONG_INLINE Packet1Xh pset1frombits<Packet1Xh>(numext::uint16_t from) {
116 return __riscv_vreinterpret_f16m1(__riscv_vmv_v_x_u16m1(from, unpacket_traits<Packet1Xh>::size));
117}
118
119template <>
120EIGEN_STRONG_INLINE Packet1Xh plset<Packet1Xh>(const Eigen::half& a) {
121 Packet1Xh idx = __riscv_vfcvt_f_x_v_f16m1(
122 __riscv_vreinterpret_v_u16m1_i16m1(__riscv_vid_v_u16m1(unpacket_traits<Packet1Xs>::size)),
123 unpacket_traits<Packet1Xh>::size);
124 return __riscv_vfadd_vf_f16m1(idx, numext::bit_cast<_Float16>(a), unpacket_traits<Packet1Xh>::size);
125}
126
127template <>
128EIGEN_STRONG_INLINE void pbroadcast4<Packet1Xh>(const Eigen::half* a, Packet1Xh& a0, Packet1Xh& a1, Packet1Xh& a2,
129 Packet1Xh& a3) {
130 vfloat16m1_t aa = __riscv_vle16_v_f16m1(reinterpret_cast<const _Float16*>(a), 4);
131 a0 = __riscv_vrgather_vx_f16m1(aa, 0, unpacket_traits<Packet1Xh>::size);
132 a1 = __riscv_vrgather_vx_f16m1(aa, 1, unpacket_traits<Packet1Xh>::size);
133 a2 = __riscv_vrgather_vx_f16m1(aa, 2, unpacket_traits<Packet1Xh>::size);
134 a3 = __riscv_vrgather_vx_f16m1(aa, 3, unpacket_traits<Packet1Xh>::size);
135}
136
137template <>
138EIGEN_STRONG_INLINE Packet1Xh padd<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
139 return __riscv_vfadd_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
140}
141
142template <>
143EIGEN_STRONG_INLINE Packet1Xh psub<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
144 return __riscv_vfsub_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
145}
146
147template <>
148EIGEN_STRONG_INLINE Packet1Xh pnegate(const Packet1Xh& a) {
149 return __riscv_vfneg_v_f16m1(a, unpacket_traits<Packet1Xh>::size);
150}
151
152template <>
153EIGEN_STRONG_INLINE Packet1Xh psignbit(const Packet1Xh& a) {
154 return __riscv_vreinterpret_v_i16m1_f16m1(
155 __riscv_vsra_vx_i16m1(__riscv_vreinterpret_v_f16m1_i16m1(a), 15, unpacket_traits<Packet1Xs>::size));
156}
157
158template <>
159EIGEN_STRONG_INLINE Packet1Xh pmul<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
160 return __riscv_vfmul_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
161}
162
163template <>
164EIGEN_STRONG_INLINE Packet1Xh pdiv<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
165 return __riscv_vfdiv_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
166}
167
168template <>
169struct is_fused_madd<Packet1Xh> : true_type {};
170template <>
171EIGEN_STRONG_INLINE Packet1Xh pmadd(const Packet1Xh& a, const Packet1Xh& b, const Packet1Xh& c) {
172 return __riscv_vfmadd_vv_f16m1(a, b, c, unpacket_traits<Packet1Xh>::size);
173}
174
175template <>
176EIGEN_STRONG_INLINE Packet1Xh pmsub(const Packet1Xh& a, const Packet1Xh& b, const Packet1Xh& c) {
177 return __riscv_vfmsub_vv_f16m1(a, b, c, unpacket_traits<Packet1Xh>::size);
178}
179
180template <>
181EIGEN_STRONG_INLINE Packet1Xh pnmadd(const Packet1Xh& a, const Packet1Xh& b, const Packet1Xh& c) {
182 return __riscv_vfnmsub_vv_f16m1(a, b, c, unpacket_traits<Packet1Xh>::size);
183}
184
185template <>
186EIGEN_STRONG_INLINE Packet1Xh pnmsub(const Packet1Xh& a, const Packet1Xh& b, const Packet1Xh& c) {
187 return __riscv_vfnmadd_vv_f16m1(a, b, c, unpacket_traits<Packet1Xh>::size);
188}
189
190template <>
191struct pminmax_propagates_nan<Packet1Xh> : bool_constant<true> {};
192
193template <>
194EIGEN_STRONG_INLINE Packet1Xh pmin<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
195 const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
196 Packet1Xh nans = __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet1Xh>::size);
197 PacketMask16 mask = __riscv_vmfeq_vv_f16m1_b16(a, a, unpacket_traits<Packet1Xh>::size);
198 PacketMask16 mask2 = __riscv_vmfeq_vv_f16m1_b16(b, b, unpacket_traits<Packet1Xh>::size);
199 mask = __riscv_vmand_mm_b16(mask, mask2, unpacket_traits<Packet1Xh>::size);
200
201 return __riscv_vfmin_vv_f16m1_tumu(mask, nans, a, b, unpacket_traits<Packet1Xh>::size);
202}
203
204template <>
205EIGEN_STRONG_INLINE Packet1Xh pmin<PropagateNumbers, Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
206 return __riscv_vfmin_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
207}
208
209template <>
210EIGEN_STRONG_INLINE Packet1Xh pmax<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
211 const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
212 Packet1Xh nans = __riscv_vfmv_v_f_f16m1(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet1Xh>::size);
213 PacketMask16 mask = __riscv_vmfeq_vv_f16m1_b16(a, a, unpacket_traits<Packet1Xh>::size);
214 PacketMask16 mask2 = __riscv_vmfeq_vv_f16m1_b16(b, b, unpacket_traits<Packet1Xh>::size);
215 mask = __riscv_vmand_mm_b16(mask, mask2, unpacket_traits<Packet1Xh>::size);
216
217 return __riscv_vfmax_vv_f16m1_tumu(mask, nans, a, b, unpacket_traits<Packet1Xh>::size);
218}
219
220template <>
221EIGEN_STRONG_INLINE Packet1Xh pmax<PropagateNumbers, Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
222 return __riscv_vfmax_vv_f16m1(a, b, unpacket_traits<Packet1Xh>::size);
223}
224
225template <>
226EIGEN_STRONG_INLINE Packet1Xh pcmp_le<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
227 PacketMask16 mask = __riscv_vmfle_vv_f16m1_b16(a, b, unpacket_traits<Packet1Xh>::size);
228 return __riscv_vmerge_vvm_f16m1(pzero<Packet1Xh>(a), ptrue<Packet1Xh>(a), mask, unpacket_traits<Packet1Xh>::size);
229}
230
231template <>
232EIGEN_STRONG_INLINE Packet1Xh pcmp_lt<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
233 PacketMask16 mask = __riscv_vmflt_vv_f16m1_b16(a, b, unpacket_traits<Packet1Xh>::size);
234 return __riscv_vmerge_vvm_f16m1(pzero<Packet1Xh>(a), ptrue<Packet1Xh>(a), mask, unpacket_traits<Packet1Xh>::size);
235}
236
237template <>
238EIGEN_STRONG_INLINE Packet1Xh pcmp_eq<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
239 PacketMask16 mask = __riscv_vmfeq_vv_f16m1_b16(a, b, unpacket_traits<Packet1Xh>::size);
240 return __riscv_vmerge_vvm_f16m1(pzero<Packet1Xh>(a), ptrue<Packet1Xh>(a), mask, unpacket_traits<Packet1Xh>::size);
241}
242
243template <>
244EIGEN_STRONG_INLINE Packet1Xh pcmp_lt_or_nan<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
245 PacketMask16 mask = __riscv_vmfge_vv_f16m1_b16(a, b, unpacket_traits<Packet1Xh>::size);
246 return __riscv_vfmerge_vfm_f16m1(ptrue<Packet1Xh>(a), static_cast<_Float16>(0.0), mask,
247 unpacket_traits<Packet1Xh>::size);
248}
249
250EIGEN_STRONG_INLINE Packet1Xh pselect(const PacketMask16& mask, const Packet1Xh& a, const Packet1Xh& b) {
251 return __riscv_vmerge_vvm_f16m1(b, a, mask, unpacket_traits<Packet1Xh>::size);
252}
253
254EIGEN_STRONG_INLINE Packet1Xh pselect(const Packet1Xh& mask, const Packet1Xh& a, const Packet1Xh& b) {
255 PacketMask16 mask2 =
256 __riscv_vmsne_vx_i16m1_b16(__riscv_vreinterpret_v_f16m1_i16m1(mask), 0, unpacket_traits<Packet1Xh>::size);
257 return __riscv_vreinterpret_v_i16m1_f16m1(__riscv_vmerge_vvm_i16m1(__riscv_vreinterpret_v_f16m1_i16m1(b),
258 __riscv_vreinterpret_v_f16m1_i16m1(a), mask2,
259 unpacket_traits<Packet1Xh>::size));
260}
261
262// Logical Operations are not supported for half, so reinterpret casts
263template <>
264EIGEN_STRONG_INLINE Packet1Xh pand<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
265 return __riscv_vreinterpret_v_u16m1_f16m1(__riscv_vand_vv_u16m1(
266 __riscv_vreinterpret_v_f16m1_u16m1(a), __riscv_vreinterpret_v_f16m1_u16m1(b), unpacket_traits<Packet1Xh>::size));
267}
268
269template <>
270EIGEN_STRONG_INLINE Packet1Xh por<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
271 return __riscv_vreinterpret_v_u16m1_f16m1(__riscv_vor_vv_u16m1(
272 __riscv_vreinterpret_v_f16m1_u16m1(a), __riscv_vreinterpret_v_f16m1_u16m1(b), unpacket_traits<Packet1Xh>::size));
273}
274
275template <>
276EIGEN_STRONG_INLINE Packet1Xh pxor<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
277 return __riscv_vreinterpret_v_u16m1_f16m1(__riscv_vxor_vv_u16m1(
278 __riscv_vreinterpret_v_f16m1_u16m1(a), __riscv_vreinterpret_v_f16m1_u16m1(b), unpacket_traits<Packet1Xh>::size));
279}
280
281template <>
282EIGEN_STRONG_INLINE Packet1Xh pnot<Packet1Xh>(const Packet1Xh& a) {
283 return __riscv_vreinterpret_v_u16m1_f16m1(
284 __riscv_vnot_v_u16m1(__riscv_vreinterpret_v_f16m1_u16m1(a), unpacket_traits<Packet1Xh>::size));
285}
286
287template <>
288EIGEN_STRONG_INLINE Packet1Xh pandnot<Packet1Xh>(const Packet1Xh& a, const Packet1Xh& b) {
289 return __riscv_vreinterpret_v_i16m1_f16m1(
290 pandnot<Packet1Xs>(__riscv_vreinterpret_v_f16m1_i16m1(a), __riscv_vreinterpret_v_f16m1_i16m1(b)));
291}
292
293template <>
294EIGEN_STRONG_INLINE Packet1Xh pload<Packet1Xh>(const Eigen::half* from) {
295 EIGEN_DEBUG_ALIGNED_LOAD return __riscv_vle16_v_f16m1(reinterpret_cast<const _Float16*>(from),
296 unpacket_traits<Packet1Xh>::size);
297}
298
299template <>
300EIGEN_STRONG_INLINE Packet1Xh ploadu<Packet1Xh>(const Eigen::half* from) {
301 EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle16_v_f16m1(reinterpret_cast<const _Float16*>(from),
302 unpacket_traits<Packet1Xh>::size);
303}
304
305template <>
306EIGEN_STRONG_INLINE Packet1Xh ploaddup<Packet1Xh>(const Eigen::half* from) {
307 return __riscv_vreinterpret_v_i16m1_f16m1(ploaddup<Packet1Xs>(reinterpret_cast<const numext::int16_t*>(from)));
308}
309
310template <>
311EIGEN_STRONG_INLINE Packet1Xh ploadquad<Packet1Xh>(const Eigen::half* from) {
312 return __riscv_vreinterpret_v_i16m1_f16m1(ploadquad<Packet1Xs>(reinterpret_cast<const numext::int16_t*>(from)));
313}
314
315template <>
316EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet1Xh& from) {
317 EIGEN_DEBUG_ALIGNED_STORE __riscv_vse16_v_f16m1(reinterpret_cast<_Float16*>(to), from,
318 unpacket_traits<Packet1Xh>::size);
319}
320
321template <>
322EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet1Xh& from) {
323 EIGEN_DEBUG_UNALIGNED_STORE __riscv_vse16_v_f16m1(reinterpret_cast<_Float16*>(to), from,
324 unpacket_traits<Packet1Xh>::size);
325}
326
327template <>
328EIGEN_DEVICE_FUNC inline Packet1Xh pgather<Eigen::half, Packet1Xh>(const Eigen::half* from, Index stride) {
329 return __riscv_vlse16_v_f16m1(reinterpret_cast<const _Float16*>(from), stride * sizeof(Eigen::half),
330 unpacket_traits<Packet1Xh>::size);
331}
332
333template <>
334EIGEN_DEVICE_FUNC inline void pscatter<Eigen::half, Packet1Xh>(Eigen::half* to, const Packet1Xh& from, Index stride) {
335 __riscv_vsse16(reinterpret_cast<_Float16*>(to), stride * sizeof(Eigen::half), from, unpacket_traits<Packet1Xh>::size);
336}
337
338template <>
339EIGEN_STRONG_INLINE Eigen::half pfirst<Packet1Xh>(const Packet1Xh& a) {
340 return static_cast<Eigen::half>(__riscv_vfmv_f_s_f16m1_f16(a));
341}
342
343template <>
344EIGEN_STRONG_INLINE Packet1Xh psqrt(const Packet1Xh& a) {
345 return __riscv_vfsqrt_v_f16m1(a, unpacket_traits<Packet1Xh>::size);
346}
347
348template <>
349EIGEN_STRONG_INLINE Packet1Xh print<Packet1Xh>(const Packet1Xh& a) {
350 const Packet1Xh limit = pset1<Packet1Xh>(static_cast<Eigen::half>(1 << 10));
351 const Packet1Xh abs_a = pabs(a);
352
353 PacketMask16 mask = __riscv_vmfne_vv_f16m1_b16(a, a, unpacket_traits<Packet1Xh>::size);
354 const Packet1Xh x = __riscv_vfadd_vv_f16m1_tumu(mask, a, a, a, unpacket_traits<Packet1Xh>::size);
355 const Packet1Xh new_x = __riscv_vfcvt_f_x_v_f16m1(__riscv_vfcvt_x_f_v_i16m1(a, unpacket_traits<Packet1Xh>::size),
356 unpacket_traits<Packet1Xh>::size);
357
358 mask = __riscv_vmflt_vv_f16m1_b16(abs_a, limit, unpacket_traits<Packet1Xh>::size);
359 Packet1Xh signed_x = __riscv_vfsgnj_vv_f16m1(new_x, x, unpacket_traits<Packet1Xh>::size);
360 return __riscv_vmerge_vvm_f16m1(x, signed_x, mask, unpacket_traits<Packet1Xh>::size);
361}
362
363template <>
364EIGEN_STRONG_INLINE Packet1Xh pfloor<Packet1Xh>(const Packet1Xh& a) {
365 Packet1Xh tmp = print<Packet1Xh>(a);
366 // If greater, subtract one.
367 PacketMask16 mask = __riscv_vmflt_vv_f16m1_b16(a, tmp, unpacket_traits<Packet1Xh>::size);
368 return __riscv_vfsub_vf_f16m1_tumu(mask, tmp, tmp, static_cast<_Float16>(1.0), unpacket_traits<Packet1Xh>::size);
369}
370
371template <>
372EIGEN_STRONG_INLINE Packet1Xh preverse(const Packet1Xh& a) {
373 Packet1Xsu idx = __riscv_vrsub_vx_u16m1(__riscv_vid_v_u16m1(unpacket_traits<Packet1Xh>::size),
374 unpacket_traits<Packet1Xh>::size - 1, unpacket_traits<Packet1Xh>::size);
375 return __riscv_vrgather_vv_f16m1(a, idx, unpacket_traits<Packet1Xh>::size);
376}
377
378template <>
379EIGEN_STRONG_INLINE Eigen::half predux<Packet1Xh>(const Packet1Xh& a) {
380 return static_cast<Eigen::half>(__riscv_vfmv_f(__riscv_vfredusum_vs_f16m1_f16m1(
381 a, __riscv_vfmv_v_f_f16m1(static_cast<_Float16>(0.0), unpacket_traits<Packet1Xh>::size),
382 unpacket_traits<Packet1Xh>::size)));
383}
384
385template <>
386EIGEN_STRONG_INLINE bool predux_any(const Packet1Xh& a) {
387 const PacketMask16 mask =
388 __riscv_vmsne_vx_u16m1_b16(__riscv_vreinterpret_v_f16m1_u16m1(a), 0, unpacket_traits<Packet1Xh>::size);
389 return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet1Xh>::size) != 0;
390}
391
392template <>
393EIGEN_STRONG_INLINE bool predux_all(const Packet1Xh& a) {
394 const PacketMask16 mask = __riscv_vmfeq_vf_f16m1_b16(a, static_cast<_Float16>(0.0), unpacket_traits<Packet1Xh>::size);
395 return __riscv_vcpop_m_b16(mask, unpacket_traits<Packet1Xh>::size) == 0;
396}
397
398template <>
399EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet1Xh>(const Packet1Xh& a) {
400 // Multiply the vector by its reverse
401 Packet1Xh prod = __riscv_vfmul_vv_f16m1(preverse(a), a, unpacket_traits<Packet1Xh>::size);
402 Packet1Xh half_prod;
403
404 EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 1024) {
405 half_prod = __riscv_vslidedown_vx_f16m1(prod, 16, unpacket_traits<Packet1Xh>::size);
406 prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
407 }
408 EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 512) {
409 half_prod = __riscv_vslidedown_vx_f16m1(prod, 8, unpacket_traits<Packet1Xh>::size);
410 prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
411 }
412 EIGEN_IF_CONSTEXPR (EIGEN_RISCV64_RVV_VL >= 256) {
413 half_prod = __riscv_vslidedown_vx_f16m1(prod, 4, unpacket_traits<Packet1Xh>::size);
414 prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
415 }
416 // Last reduction
417 half_prod = __riscv_vslidedown_vx_f16m1(prod, 2, unpacket_traits<Packet1Xh>::size);
418 prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
419
420 half_prod = __riscv_vslidedown_vx_f16m1(prod, 1, unpacket_traits<Packet1Xh>::size);
421 prod = __riscv_vfmul_vv_f16m1(prod, half_prod, unpacket_traits<Packet1Xh>::size);
422
423 // The reduction is done to the first element.
424 return pfirst(prod);
425}
426
427// Reusing the first lane is exact for an idempotent reduction and avoids a NaN seed that becomes poison under
428// finite fast-math.
429template <>
430EIGEN_STRONG_INLINE Eigen::half predux_min<Packet1Xh>(const Packet1Xh& a) {
431 return static_cast<Eigen::half>(
432 __riscv_vfmv_f(__riscv_vfredmin_vs_f16m1_f16m1(a, a, unpacket_traits<Packet1Xh>::size)));
433}
434
435template <>
436EIGEN_STRONG_INLINE Eigen::half predux_max<Packet1Xh>(const Packet1Xh& a) {
437 return static_cast<Eigen::half>(
438 __riscv_vfmv_f(__riscv_vfredmax_vs_f16m1_f16m1(a, a, unpacket_traits<Packet1Xh>::size)));
439}
440
441template <int N>
442EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xh, N>& kernel) {
443 Eigen::half buffer[unpacket_traits<Packet1Xh>::size * N];
444 int i = 0;
445
446 for (i = 0; i < N; i++) {
447 __riscv_vsse16(reinterpret_cast<_Float16*>(&buffer[i]), N * sizeof(Eigen::half), kernel.packet[i],
448 unpacket_traits<Packet1Xh>::size);
449 }
450
451 for (i = 0; i < N; i++) {
452 kernel.packet[i] = __riscv_vle16_v_f16m1(reinterpret_cast<_Float16*>(&buffer[i * unpacket_traits<Packet1Xh>::size]),
453 unpacket_traits<Packet1Xh>::size);
454 }
455}
456
457EIGEN_STRONG_INLINE Packet2Xf half2float(const Packet1Xh& a) {
458 return __riscv_vfwcvt_f_f_v_f32m2(a, unpacket_traits<Packet2Xf>::size);
459}
460
461EIGEN_STRONG_INLINE Packet1Xh float2half(const Packet2Xf& a) {
462 return __riscv_vfncvt_f_f_w_f16m1(a, unpacket_traits<Packet1Xh>::size);
463}
464
465/********************************* Packet2Xh ************************************/
466
467EIGEN_STRONG_INLINE Packet2Xh __riscv_vreinterpret_v_u32m2_f16m2(const Packet2Xu& a) {
468 return __riscv_vreinterpret_v_u16m2_f16m2(__riscv_vreinterpret_v_u32m2_u16m2(a));
469}
470
471template <>
472EIGEN_STRONG_INLINE Packet2Xh ptrue<Packet2Xh>(const Packet2Xh& /*a*/) {
473 Packet2Xh r = __riscv_vreinterpret_f16m2(__riscv_vmv_v_x_u16m2(0xffffu, unpacket_traits<Packet2Xh>::size));
474 EIGEN_FAST_MATH_CONSTANT_BARRIER(r);
475 return r;
476}
477
478template <>
479EIGEN_STRONG_INLINE Packet2Xh pzero<Packet2Xh>(const Packet2Xh& /*a*/) {
480 return __riscv_vfmv_v_f_f16m2(static_cast<_Float16>(0.0), unpacket_traits<Packet2Xh>::size);
481}
482
483template <>
484EIGEN_STRONG_INLINE Packet2Xh pabs(const Packet2Xh& a) {
485 return __riscv_vfabs_v_f16m2(a, unpacket_traits<Packet2Xh>::size);
486}
487
488template <>
489EIGEN_STRONG_INLINE Packet2Xh pabsdiff(const Packet2Xh& a, const Packet2Xh& b) {
490 return __riscv_vfabs_v_f16m2(__riscv_vfsub_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size),
491 unpacket_traits<Packet2Xh>::size);
492}
493
494template <>
495EIGEN_STRONG_INLINE Packet2Xh pset1<Packet2Xh>(const Eigen::half& from) {
496 return __riscv_vfmv_v_f_f16m2(numext::bit_cast<_Float16>(from), unpacket_traits<Packet2Xh>::size);
497}
498
499template <>
500EIGEN_STRONG_INLINE Packet2Xh pset1frombits<Packet2Xh>(numext::uint16_t from) {
501 return __riscv_vreinterpret_f16m2(__riscv_vmv_v_x_u16m2(from, unpacket_traits<Packet2Xh>::size));
502}
503
504template <>
505EIGEN_STRONG_INLINE Packet2Xh plset<Packet2Xh>(const Eigen::half& a) {
506 Packet2Xh idx = __riscv_vfcvt_f_x_v_f16m2(
507 __riscv_vreinterpret_v_u16m2_i16m2(__riscv_vid_v_u16m2(unpacket_traits<Packet4Xs>::size)),
508 unpacket_traits<Packet2Xh>::size);
509 return __riscv_vfadd_vf_f16m2(idx, numext::bit_cast<_Float16>(a), unpacket_traits<Packet2Xh>::size);
510}
511
512template <>
513EIGEN_STRONG_INLINE void pbroadcast4<Packet2Xh>(const Eigen::half* a, Packet2Xh& a0, Packet2Xh& a1, Packet2Xh& a2,
514 Packet2Xh& a3) {
515 vfloat16m2_t aa = __riscv_vle16_v_f16m2(reinterpret_cast<const _Float16*>(a), 4);
516 a0 = __riscv_vrgather_vx_f16m2(aa, 0, unpacket_traits<Packet2Xh>::size);
517 a1 = __riscv_vrgather_vx_f16m2(aa, 1, unpacket_traits<Packet2Xh>::size);
518 a2 = __riscv_vrgather_vx_f16m2(aa, 2, unpacket_traits<Packet2Xh>::size);
519 a3 = __riscv_vrgather_vx_f16m2(aa, 3, unpacket_traits<Packet2Xh>::size);
520}
521
522template <>
523EIGEN_STRONG_INLINE Packet2Xh padd<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
524 return __riscv_vfadd_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
525}
526
527template <>
528EIGEN_STRONG_INLINE Packet2Xh psub<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
529 return __riscv_vfsub_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
530}
531
532template <>
533EIGEN_STRONG_INLINE Packet2Xh pnegate(const Packet2Xh& a) {
534 return __riscv_vfneg_v_f16m2(a, unpacket_traits<Packet2Xh>::size);
535}
536
537template <>
538EIGEN_STRONG_INLINE Packet2Xh psignbit(const Packet2Xh& a) {
539 return __riscv_vreinterpret_v_i16m2_f16m2(
540 __riscv_vsra_vx_i16m2(__riscv_vreinterpret_v_f16m2_i16m2(a), 15, unpacket_traits<Packet2Xs>::size));
541}
542
543template <>
544EIGEN_STRONG_INLINE Packet2Xh pmul<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
545 return __riscv_vfmul_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
546}
547
548template <>
549EIGEN_STRONG_INLINE Packet2Xh pdiv<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
550 return __riscv_vfdiv_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
551}
552
553template <>
554struct is_fused_madd<Packet2Xh> : true_type {};
555template <>
556EIGEN_STRONG_INLINE Packet2Xh pmadd(const Packet2Xh& a, const Packet2Xh& b, const Packet2Xh& c) {
557 return __riscv_vfmadd_vv_f16m2(a, b, c, unpacket_traits<Packet2Xh>::size);
558}
559
560template <>
561EIGEN_STRONG_INLINE Packet2Xh pmsub(const Packet2Xh& a, const Packet2Xh& b, const Packet2Xh& c) {
562 return __riscv_vfmsub_vv_f16m2(a, b, c, unpacket_traits<Packet2Xh>::size);
563}
564
565template <>
566EIGEN_STRONG_INLINE Packet2Xh pnmadd(const Packet2Xh& a, const Packet2Xh& b, const Packet2Xh& c) {
567 return __riscv_vfnmsub_vv_f16m2(a, b, c, unpacket_traits<Packet2Xh>::size);
568}
569
570template <>
571EIGEN_STRONG_INLINE Packet2Xh pnmsub(const Packet2Xh& a, const Packet2Xh& b, const Packet2Xh& c) {
572 return __riscv_vfnmadd_vv_f16m2(a, b, c, unpacket_traits<Packet2Xh>::size);
573}
574
575template <>
576struct pminmax_propagates_nan<Packet2Xh> : bool_constant<true> {};
577
578template <>
579EIGEN_STRONG_INLINE Packet2Xh pmin<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
580 const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
581 Packet2Xh nans = __riscv_vfmv_v_f_f16m2(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet2Xh>::size);
582 PacketMask8 mask = __riscv_vmfeq_vv_f16m2_b8(a, a, unpacket_traits<Packet2Xh>::size);
583 PacketMask8 mask2 = __riscv_vmfeq_vv_f16m2_b8(b, b, unpacket_traits<Packet2Xh>::size);
584 mask = __riscv_vmand_mm_b8(mask, mask2, unpacket_traits<Packet2Xh>::size);
585
586 return __riscv_vfmin_vv_f16m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xh>::size);
587}
588
589template <>
590EIGEN_STRONG_INLINE Packet2Xh pmin<PropagateNumbers, Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
591 return __riscv_vfmin_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
592}
593
594template <>
595EIGEN_STRONG_INLINE Packet2Xh pmax<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
596 const Eigen::half nan = (std::numeric_limits<Eigen::half>::quiet_NaN)();
597 Packet2Xh nans = __riscv_vfmv_v_f_f16m2(numext::bit_cast<_Float16>(nan), unpacket_traits<Packet2Xh>::size);
598 PacketMask8 mask = __riscv_vmfeq_vv_f16m2_b8(a, a, unpacket_traits<Packet2Xh>::size);
599 PacketMask8 mask2 = __riscv_vmfeq_vv_f16m2_b8(b, b, unpacket_traits<Packet2Xh>::size);
600 mask = __riscv_vmand_mm_b8(mask, mask2, unpacket_traits<Packet2Xh>::size);
601
602 return __riscv_vfmax_vv_f16m2_tumu(mask, nans, a, b, unpacket_traits<Packet2Xh>::size);
603}
604
605template <>
606EIGEN_STRONG_INLINE Packet2Xh pmax<PropagateNumbers, Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
607 return __riscv_vfmax_vv_f16m2(a, b, unpacket_traits<Packet2Xh>::size);
608}
609
610template <>
611EIGEN_STRONG_INLINE Packet2Xh pcmp_le<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
612 PacketMask8 mask = __riscv_vmfle_vv_f16m2_b8(a, b, unpacket_traits<Packet2Xh>::size);
613 return __riscv_vmerge_vvm_f16m2(pzero<Packet2Xh>(a), ptrue<Packet2Xh>(a), mask, unpacket_traits<Packet2Xh>::size);
614}
615
616template <>
617EIGEN_STRONG_INLINE Packet2Xh pcmp_lt<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
618 PacketMask8 mask = __riscv_vmflt_vv_f16m2_b8(a, b, unpacket_traits<Packet2Xh>::size);
619 return __riscv_vmerge_vvm_f16m2(pzero<Packet2Xh>(a), ptrue<Packet2Xh>(a), mask, unpacket_traits<Packet2Xh>::size);
620}
621
622template <>
623EIGEN_STRONG_INLINE Packet2Xh pcmp_eq<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
624 PacketMask8 mask = __riscv_vmfeq_vv_f16m2_b8(a, b, unpacket_traits<Packet2Xh>::size);
625 return __riscv_vmerge_vvm_f16m2(pzero<Packet2Xh>(a), ptrue<Packet2Xh>(a), mask, unpacket_traits<Packet2Xh>::size);
626}
627
628template <>
629EIGEN_STRONG_INLINE Packet2Xh pcmp_lt_or_nan<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
630 PacketMask8 mask = __riscv_vmfge_vv_f16m2_b8(a, b, unpacket_traits<Packet2Xh>::size);
631 return __riscv_vfmerge_vfm_f16m2(ptrue<Packet2Xh>(a), static_cast<_Float16>(0.0), mask,
632 unpacket_traits<Packet2Xh>::size);
633}
634
635EIGEN_STRONG_INLINE Packet2Xh pselect(const PacketMask8& mask, const Packet2Xh& a, const Packet2Xh& b) {
636 return __riscv_vmerge_vvm_f16m2(b, a, mask, unpacket_traits<Packet2Xh>::size);
637}
638
639EIGEN_STRONG_INLINE Packet2Xh pselect(const Packet2Xh& mask, const Packet2Xh& a, const Packet2Xh& b) {
640 PacketMask8 mask2 =
641 __riscv_vmsne_vx_i16m2_b8(__riscv_vreinterpret_v_f16m2_i16m2(mask), 0, unpacket_traits<Packet2Xh>::size);
642 return __riscv_vreinterpret_v_i16m2_f16m2(__riscv_vmerge_vvm_i16m2(__riscv_vreinterpret_v_f16m2_i16m2(b),
643 __riscv_vreinterpret_v_f16m2_i16m2(a), mask2,
644 unpacket_traits<Packet2Xh>::size));
645}
646
647// Logical Operations are not supported for half, so reinterpret casts
648template <>
649EIGEN_STRONG_INLINE Packet2Xh pand<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
650 return __riscv_vreinterpret_v_u16m2_f16m2(__riscv_vand_vv_u16m2(
651 __riscv_vreinterpret_v_f16m2_u16m2(a), __riscv_vreinterpret_v_f16m2_u16m2(b), unpacket_traits<Packet2Xh>::size));
652}
653
654template <>
655EIGEN_STRONG_INLINE Packet2Xh por<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
656 return __riscv_vreinterpret_v_u16m2_f16m2(__riscv_vor_vv_u16m2(
657 __riscv_vreinterpret_v_f16m2_u16m2(a), __riscv_vreinterpret_v_f16m2_u16m2(b), unpacket_traits<Packet2Xh>::size));
658}
659
660template <>
661EIGEN_STRONG_INLINE Packet2Xh pxor<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
662 return __riscv_vreinterpret_v_u16m2_f16m2(__riscv_vxor_vv_u16m2(
663 __riscv_vreinterpret_v_f16m2_u16m2(a), __riscv_vreinterpret_v_f16m2_u16m2(b), unpacket_traits<Packet2Xh>::size));
664}
665
666template <>
667EIGEN_STRONG_INLINE Packet2Xh pandnot<Packet2Xh>(const Packet2Xh& a, const Packet2Xh& b) {
668 return __riscv_vreinterpret_v_i16m2_f16m2(
669 pandnot<Packet2Xs>(__riscv_vreinterpret_v_f16m2_i16m2(a), __riscv_vreinterpret_v_f16m2_i16m2(b)));
670}
671
672template <>
673EIGEN_STRONG_INLINE Packet2Xh pnot<Packet2Xh>(const Packet2Xh& a) {
674 return __riscv_vreinterpret_v_u16m2_f16m2(
675 __riscv_vnot_v_u16m2(__riscv_vreinterpret_v_f16m2_u16m2(a), unpacket_traits<Packet2Xh>::size));
676}
677
678template <>
679EIGEN_STRONG_INLINE Packet2Xh pload<Packet2Xh>(const Eigen::half* from) {
680 EIGEN_DEBUG_ALIGNED_LOAD return __riscv_vle16_v_f16m2(reinterpret_cast<const _Float16*>(from),
681 unpacket_traits<Packet2Xh>::size);
682}
683
684template <>
685EIGEN_STRONG_INLINE Packet2Xh ploadu<Packet2Xh>(const Eigen::half* from) {
686 EIGEN_DEBUG_UNALIGNED_LOAD return __riscv_vle16_v_f16m2(reinterpret_cast<const _Float16*>(from),
687 unpacket_traits<Packet2Xh>::size);
688}
689
690template <>
691EIGEN_STRONG_INLINE Packet2Xh ploaddup<Packet2Xh>(const Eigen::half* from) {
692 return __riscv_vreinterpret_v_i16m2_f16m2(ploaddup<Packet2Xs>(reinterpret_cast<const numext::int16_t*>(from)));
693}
694
695template <>
696EIGEN_STRONG_INLINE Packet2Xh ploadquad<Packet2Xh>(const Eigen::half* from) {
697 return __riscv_vreinterpret_v_i16m2_f16m2(ploadquad<Packet2Xs>(reinterpret_cast<const numext::int16_t*>(from)));
698}
699
700template <>
701EIGEN_STRONG_INLINE void pstore<Eigen::half>(Eigen::half* to, const Packet2Xh& from) {
702 EIGEN_DEBUG_ALIGNED_STORE __riscv_vse16_v_f16m2(reinterpret_cast<_Float16*>(to), from,
703 unpacket_traits<Packet2Xh>::size);
704}
705
706template <>
707EIGEN_STRONG_INLINE void pstoreu<Eigen::half>(Eigen::half* to, const Packet2Xh& from) {
708 EIGEN_DEBUG_UNALIGNED_STORE __riscv_vse16_v_f16m2(reinterpret_cast<_Float16*>(to), from,
709 unpacket_traits<Packet2Xh>::size);
710}
711
712template <>
713EIGEN_DEVICE_FUNC inline Packet2Xh pgather<Eigen::half, Packet2Xh>(const Eigen::half* from, Index stride) {
714 return __riscv_vlse16_v_f16m2(reinterpret_cast<const _Float16*>(from), stride * sizeof(Eigen::half),
715 unpacket_traits<Packet2Xh>::size);
716}
717
718template <>
719EIGEN_DEVICE_FUNC inline void pscatter<Eigen::half, Packet2Xh>(Eigen::half* to, const Packet2Xh& from, Index stride) {
720 __riscv_vsse16(reinterpret_cast<_Float16*>(to), stride * sizeof(Eigen::half), from, unpacket_traits<Packet2Xh>::size);
721}
722
723template <>
724EIGEN_STRONG_INLINE Eigen::half pfirst<Packet2Xh>(const Packet2Xh& a) {
725 return numext::bit_cast<Eigen::half>(__riscv_vfmv_f_s_f16m2_f16(a));
726}
727
728template <>
729EIGEN_STRONG_INLINE Packet2Xh psqrt(const Packet2Xh& a) {
730 return __riscv_vfsqrt_v_f16m2(a, unpacket_traits<Packet2Xh>::size);
731}
732
733template <>
734EIGEN_STRONG_INLINE Packet2Xh print<Packet2Xh>(const Packet2Xh& a) {
735 const Packet2Xh limit = pset1<Packet2Xh>(static_cast<Eigen::half>(1 << 10));
736 const Packet2Xh abs_a = pabs(a);
737
738 PacketMask8 mask = __riscv_vmfne_vv_f16m2_b8(a, a, unpacket_traits<Packet2Xh>::size);
739 const Packet2Xh x = __riscv_vfadd_vv_f16m2_tumu(mask, a, a, a, unpacket_traits<Packet2Xh>::size);
740 const Packet2Xh new_x = __riscv_vfcvt_f_x_v_f16m2(__riscv_vfcvt_x_f_v_i16m2(a, unpacket_traits<Packet2Xh>::size),
741 unpacket_traits<Packet2Xh>::size);
742
743 mask = __riscv_vmflt_vv_f16m2_b8(abs_a, limit, unpacket_traits<Packet2Xh>::size);
744 Packet2Xh signed_x = __riscv_vfsgnj_vv_f16m2(new_x, x, unpacket_traits<Packet2Xh>::size);
745 return __riscv_vmerge_vvm_f16m2(x, signed_x, mask, unpacket_traits<Packet2Xh>::size);
746}
747
748template <>
749EIGEN_STRONG_INLINE Packet2Xh pfloor<Packet2Xh>(const Packet2Xh& a) {
750 Packet2Xh tmp = print<Packet2Xh>(a);
751 // If greater, subtract one.
752 PacketMask8 mask = __riscv_vmflt_vv_f16m2_b8(a, tmp, unpacket_traits<Packet2Xh>::size);
753 return __riscv_vfsub_vf_f16m2_tumu(mask, tmp, tmp, static_cast<_Float16>(1.0), unpacket_traits<Packet2Xh>::size);
754}
755
756template <>
757EIGEN_STRONG_INLINE Packet2Xh preverse(const Packet2Xh& a) {
758 Packet2Xsu idx = __riscv_vrsub_vx_u16m2(__riscv_vid_v_u16m2(unpacket_traits<Packet2Xh>::size),
759 unpacket_traits<Packet2Xh>::size - 1, unpacket_traits<Packet2Xh>::size);
760 return __riscv_vrgather_vv_f16m2(a, idx, unpacket_traits<Packet2Xh>::size);
761}
762
763template <>
764EIGEN_STRONG_INLINE Eigen::half predux<Packet2Xh>(const Packet2Xh& a) {
765 return static_cast<Eigen::half>(__riscv_vfmv_f(__riscv_vfredusum_vs_f16m2_f16m1(
766 a, __riscv_vfmv_v_f_f16m1(static_cast<_Float16>(0.0), unpacket_traits<Packet2Xh>::size / 2),
767 unpacket_traits<Packet2Xh>::size)));
768}
769
770template <>
771EIGEN_STRONG_INLINE bool predux_any(const Packet2Xh& a) {
772 const PacketMask8 mask =
773 __riscv_vmsne_vx_u16m2_b8(__riscv_vreinterpret_v_f16m2_u16m2(a), 0, unpacket_traits<Packet2Xh>::size);
774 return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xh>::size) != 0;
775}
776
777template <>
778EIGEN_STRONG_INLINE bool predux_all(const Packet2Xh& a) {
779 const PacketMask8 mask = __riscv_vmfeq_vf_f16m2_b8(a, static_cast<_Float16>(0.0), unpacket_traits<Packet2Xh>::size);
780 return __riscv_vcpop_m_b8(mask, unpacket_traits<Packet2Xh>::size) == 0;
781}
782
783template <>
784EIGEN_STRONG_INLINE Eigen::half predux_mul<Packet2Xh>(const Packet2Xh& a) {
785 return predux_mul<Packet1Xh>(__riscv_vfmul_vv_f16m1(
786 __riscv_vget_v_f16m2_f16m1(a, 0), __riscv_vget_v_f16m2_f16m1(a, 1), unpacket_traits<Packet1Xh>::size));
787}
788
789template <>
790EIGEN_STRONG_INLINE Eigen::half predux_min<Packet2Xh>(const Packet2Xh& a) {
791 return static_cast<Eigen::half>(__riscv_vfmv_f(
792 __riscv_vfredmin_vs_f16m2_f16m1(a, __riscv_vget_v_f16m2_f16m1(a, 0), unpacket_traits<Packet2Xh>::size)));
793}
794
795template <>
796EIGEN_STRONG_INLINE Eigen::half predux_max<Packet2Xh>(const Packet2Xh& a) {
797 return static_cast<Eigen::half>(__riscv_vfmv_f(
798 __riscv_vfredmax_vs_f16m2_f16m1(a, __riscv_vget_v_f16m2_f16m1(a, 0), unpacket_traits<Packet2Xh>::size)));
799}
800
801template <int N>
802EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet2Xh, N>& kernel) {
803 Eigen::half buffer[unpacket_traits<Packet2Xh>::size * N];
804 int i = 0;
805
806 for (i = 0; i < N; i++) {
807 __riscv_vsse16(reinterpret_cast<_Float16*>(&buffer[i]), N * sizeof(Eigen::half), kernel.packet[i],
808 unpacket_traits<Packet2Xh>::size);
809 }
810
811 for (i = 0; i < N; i++) {
812 kernel.packet[i] = __riscv_vle16_v_f16m2(reinterpret_cast<_Float16*>(&buffer[i * unpacket_traits<Packet2Xh>::size]),
813 unpacket_traits<Packet2Xh>::size);
814 }
815}
816
817EIGEN_STRONG_INLINE Packet4Xf half2float(const Packet2Xh& a) {
818 return __riscv_vfwcvt_f_f_v_f32m4(a, unpacket_traits<Packet4Xf>::size);
819}
820
821EIGEN_STRONG_INLINE Packet2Xh float2half(const Packet4Xf& a) {
822 return __riscv_vfncvt_f_f_w_f16m2(a, unpacket_traits<Packet2Xh>::size);
823}
824
825template <typename Packet = Packet2Xh>
826EIGEN_STRONG_INLINE
827 std::enable_if_t<std::is_same<Packet, Packet2Xh>::value && (unpacket_traits<Packet2Xh>::size % 8) == 0, Packet1Xh>
828 predux_half(const Packet2Xh& a) {
829 return __riscv_vfadd_vv_f16m1(__riscv_vget_v_f16m2_f16m1(a, 0), __riscv_vget_v_f16m2_f16m1(a, 1),
830 unpacket_traits<Packet1Xh>::size);
831}
832
833F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, pcos)
834F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, pexp)
835F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, pexpm1)
836F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, plog)
837F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, plog1p)
838F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, plog2)
839F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, preciprocal)
840F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, prsqrt)
841F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, psin)
842F16_PACKET_FUNCTION(Packet2Xf, Packet1Xh, ptanh)
843
844F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, pcos)
845F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, pexp)
846F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, pexpm1)
847F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, plog)
848F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, plog1p)
849F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, plog2)
850F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, preciprocal)
851F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, prsqrt)
852F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, psin)
853F16_PACKET_FUNCTION(Packet4Xf, Packet2Xh, ptanh)
854
855/********************************* casting ************************************/
856
857template <>
858struct type_casting_traits<_Float16, numext::int16_t> {
859 enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
860};
861
862template <>
863struct type_casting_traits<numext::int16_t, _Float16> {
864 enum { VectorizedCast = 1, SrcCoeffRatio = 1, TgtCoeffRatio = 1 };
865};
866
867template <>
868EIGEN_STRONG_INLINE Packet1Xh pcast<Packet1Xs, Packet1Xh>(const Packet1Xs& a) {
869 return __riscv_vfcvt_f_x_v_f16m1(a, unpacket_traits<Packet1Xs>::size);
870}
871
872template <>
873EIGEN_STRONG_INLINE Packet1Xs pcast<Packet1Xh, Packet1Xs>(const Packet1Xh& a) {
874 return __riscv_vfcvt_rtz_x_f_v_i16m1(a, unpacket_traits<Packet1Xh>::size);
875}
876
877template <>
878EIGEN_STRONG_INLINE Packet1Xh preinterpret<Packet1Xh, Packet1Xs>(const Packet1Xs& a) {
879 return __riscv_vreinterpret_v_i16m1_f16m1(a);
880}
881
882template <>
883EIGEN_STRONG_INLINE Packet1Xs preinterpret<Packet1Xs, Packet1Xh>(const Packet1Xh& a) {
884 return __riscv_vreinterpret_v_f16m1_i16m1(a);
885}
886
887template <>
888EIGEN_STRONG_INLINE Packet2Xh pcast<Packet2Xs, Packet2Xh>(const Packet2Xs& a) {
889 return __riscv_vfcvt_f_x_v_f16m2(a, unpacket_traits<Packet2Xs>::size);
890}
891
892template <>
893EIGEN_STRONG_INLINE Packet2Xs pcast<Packet2Xh, Packet2Xs>(const Packet2Xh& a) {
894 return __riscv_vfcvt_rtz_x_f_v_i16m2(a, unpacket_traits<Packet2Xh>::size);
895}
896
897template <>
898EIGEN_STRONG_INLINE Packet2Xh preinterpret<Packet2Xh, Packet2Xs>(const Packet2Xs& a) {
899 return __riscv_vreinterpret_v_i16m2_f16m2(a);
900}
901
902template <>
903EIGEN_STRONG_INLINE Packet2Xs preinterpret<Packet2Xs, Packet2Xh>(const Packet2Xh& a) {
904 return __riscv_vreinterpret_v_f16m2_i16m2(a);
905}
906
907template <>
908EIGEN_STRONG_INLINE Packet4Xs pcast<Packet1Xh, Packet4Xs>(const Packet1Xh& a, const Packet1Xh& b, const Packet1Xh& c,
909 const Packet1Xh& d) {
910 return __riscv_vcreate_v_i16m1_i16m4(__riscv_vfcvt_rtz_x_f_v_i16m1(a, unpacket_traits<Packet1Xh>::size),
911 __riscv_vfcvt_rtz_x_f_v_i16m1(b, unpacket_traits<Packet1Xh>::size),
912 __riscv_vfcvt_rtz_x_f_v_i16m1(c, unpacket_traits<Packet1Xh>::size),
913 __riscv_vfcvt_rtz_x_f_v_i16m1(d, unpacket_traits<Packet1Xh>::size));
914}
915
916template <>
917EIGEN_STRONG_INLINE Packet2Xh pcast<Packet1Xs, Packet2Xh>(const Packet1Xs& a, const Packet1Xs& b) {
918 return __riscv_vcreate_v_f16m1_f16m2(__riscv_vfcvt_f_x_v_f16m1(a, unpacket_traits<Packet1Xs>::size),
919 __riscv_vfcvt_f_x_v_f16m1(b, unpacket_traits<Packet1Xs>::size));
920}
921
922template <>
923EIGEN_STRONG_INLINE Packet2Xh pcast<Packet1Xh, Packet2Xh>(const Packet1Xh& a, const Packet1Xh& b) {
924 return __riscv_vcreate_v_f16m1_f16m2(a, b);
925}
926
927template <>
928EIGEN_STRONG_INLINE Packet2Xs pcast<Packet1Xh, Packet2Xs>(const Packet1Xh& a, const Packet1Xh& b) {
929 return __riscv_vcreate_v_i16m1_i16m2(__riscv_vfcvt_rtz_x_f_v_i16m1(a, unpacket_traits<Packet1Xh>::size),
930 __riscv_vfcvt_rtz_x_f_v_i16m1(b, unpacket_traits<Packet1Xh>::size));
931}
932
933} // namespace internal
934} // namespace Eigen
935
936#endif // EIGEN_PACKET_MATH_FP16_RVV10_H