mirrors/dynarmic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

ir: Add opcodes for performing unsigned reciprocal square root estimates

Browse source
This commit is contained in:
Lioncash 2018-09-07 23:41:05 -04:00 committed by MerryMage
parent bd3582e811
commit b6e74fd17d
7 changed files with 71 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/backend/x64/emit_x64_vector.cpp
View file

@ -3337,6 +3337,22 @@ void EmitX64::EmitVectorUnsignedRecipEstimate(EmitContext& ctx, IR::Inst* inst)
});
}
void EmitX64::EmitVectorUnsignedRecipSqrtEstimate(EmitContext& ctx, IR::Inst* inst) {
EmitOneArgumentFallback(code, ctx, inst, [](VectorArray<u32>& result, const VectorArray<u32>& a) {
for (size_t i = 0; i < result.size(); i++) {
if ((a[i] & 0xC0000000) == 0) {
result[i] = 0xFFFFFFFF;
continue;
}
const u32 input = Common::Bits<23, 31>(a[i]);
const u32 estimate = Common::RecipSqrtEstimate(input);
result[i] = (0b100000000 | estimate) << 23;
}
});
}
void EmitX64::EmitVectorUnsignedSaturatedNarrow16(EmitContext& ctx, IR::Inst* inst) {
EmitOneArgumentFallbackWithSaturation(code, ctx, inst, [](VectorArray<u8>& result, const VectorArray<u16>& a) {
bool qc_flag = false;

40
src/common/fp/op/FPRSqrtEstimate.cpp
View file

@ -16,47 +16,11 @@
#include "common/fp/process_exception.h"
#include "common/fp/process_nan.h"
#include "common/fp/unpacked.h"
#include "common/math_util.h"
#include "common/safe_ops.h"
namespace Dynarmic::FP {
/// Input is a u0.9 fixed point number. Only values in [0.25, 1.0) are valid.
/// Output is a u0.8 fixed point number, with an implied 1 prefixed.
/// i.e.: The output is a value in [1.0, 2.0).
static u8 RecipSqrtEstimate(u64 a) {
using LUT = std::array<u8, 512>;
static const LUT lut = [] {
LUT result{};
for (u64 i = 128; i < result.size(); i++) {
u64 a = i;
// Convert to u.10 (with 8 significant bits), force to odd
if (a < 256) {
// [0.25, 0.5)
a = a * 2 + 1;
} else {
// [0.5, 1.0)
a = (a | 1) * 2;
}
// Calculate largest b which for which b < 1.0 / sqrt(a).
// Start from b = 1.0 (in u.9) since b cannot be smaller.
u64 b = 512;
// u.10 * u.9 * u.9 -> u.28
while (a * (b + 1) * (b + 1) < (1u << 28)) {
b++;
}
// Round to nearest u0.8 (with implied set integer bit).
result[i] = static_cast<u8>((b + 1) / 2);
}
return result;
}();
return lut[a & 0x1FF];
}
template<typename FPT>
FPT FPRSqrtEstimate(FPT op, FPCR fpcr, FPSR& fpsr) {
auto [type, sign, value] = FPUnpack<FPT>(op, fpcr, fpsr);
@ -83,7 +47,7 @@ FPT FPRSqrtEstimate(FPT op, FPCR fpcr, FPSR& fpsr) {
const bool was_exponent_odd = (value.exponent) % 2 == 0;
const u64 scaled = Safe::LogicalShiftRight(value.mantissa, normalized_point_position - (was_exponent_odd ? 7 : 8));
const u64 estimate = RecipSqrtEstimate(scaled);
const u64 estimate = Common::RecipSqrtEstimate(scaled);
const FPT bits_exponent = static_cast<FPT>(result_exponent + FPInfo<FPT>::exponent_bias);
const FPT bits_mantissa = static_cast<FPT>(estimate << (FPInfo<FPT>::explicit_mantissa_width - 8));

37
src/common/math_util.cpp
View file

@ -28,4 +28,41 @@ u8 RecipEstimate(u64 a) {
return lut[a - lut_offset];
}
/// Input is a u0.9 fixed point number. Only values in [0.25, 1.0) are valid.
/// Output is a u0.8 fixed point number, with an implied 1 prefixed.
/// i.e.: The output is a value in [1.0, 2.0).
u8 RecipSqrtEstimate(u64 a) {
using LUT = std::array<u8, 512>;
static const LUT lut = [] {
LUT result{};
for (u64 i = 128; i < result.size(); i++) {
u64 a = i;
// Convert to u.10 (with 8 significant bits), force to odd
if (a < 256) {
// [0.25, 0.5)
a = a * 2 + 1;
} else {
// [0.5, 1.0)
a = (a | 1) * 2;
}
// Calculate largest b which for which b < 1.0 / sqrt(a).
// Start from b = 1.0 (in u.9) since b cannot be smaller.
u64 b = 512;
// u.10 * u.9 * u.9 -> u.28
while (a * (b + 1) * (b + 1) < (1u << 28)) {
b++;
}
// Round to nearest u0.8 (with implied set integer bit).
result[i] = static_cast<u8>((b + 1) / 2);
}
return result;
}();
return lut[a & 0x1FF];
}
} // namespace Dynarmic::Common

10
src/common/math_util.h
View file

@ -35,4 +35,14 @@ constexpr T Sum(T first, Ts&&... rest) {
*/
u8 RecipEstimate(u64 a);
/**
* Input is a u0.9 fixed point number. Only values in [0.25, 1.0) are valid.
* Output is a u0.8 fixed point number, with an implied 1 prefixed.
* i.e.: The output is a value in [1.0, 2.0).
*
* @see RecipSqrtEstimate() within the ARMv8 architecture reference manual
* for a general overview of the requirements of the algorithm.
*/
u8 RecipSqrtEstimate(u64 a);
} // namespace Dynarmic::Common

4
src/frontend/ir/ir_emitter.cpp
View file

@ -1623,6 +1623,10 @@ U128 IREmitter::VectorUnsignedRecipEstimate(const U128& a) {
return Inst<U128>(Opcode::VectorUnsignedRecipEstimate, a);
}
U128 IREmitter::VectorUnsignedRecipSqrtEstimate(const U128& a) {
return Inst<U128>(Opcode::VectorUnsignedRecipSqrtEstimate, a);
}
U128 IREmitter::VectorUnsignedSaturatedNarrow(size_t esize, const U128& a) {
switch (esize) {
case 16:

1
src/frontend/ir/ir_emitter.h
View file

@ -274,6 +274,7 @@ public:
U128 VectorTableLookup(const U128& defaults, const Table& table, const U128& indices);
U128 VectorUnsignedAbsoluteDifference(size_t esize, const U128& a, const U128& b);
U128 VectorUnsignedRecipEstimate(const U128& a);
U128 VectorUnsignedRecipSqrtEstimate(const U128& a);
U128 VectorUnsignedSaturatedNarrow(size_t esize, const U128& a);
U128 VectorZeroExtend(size_t original_esize, const U128& a);
U128 VectorZeroUpper(const U128& a);

1
src/frontend/ir/opcodes.inc
View file

@ -419,6 +419,7 @@ OPCODE(VectorUnsignedAbsoluteDifference8, U128, U128,
OPCODE(VectorUnsignedAbsoluteDifference16, U128, U128, U128 )
OPCODE(VectorUnsignedAbsoluteDifference32, U128, U128, U128 )
OPCODE(VectorUnsignedRecipEstimate, U128, U128 )
OPCODE(VectorUnsignedRecipSqrtEstimate, U128, U128 )
OPCODE(VectorUnsignedSaturatedNarrow16, U128, U128 )
OPCODE(VectorUnsignedSaturatedNarrow32, U128, U128 )
OPCODE(VectorUnsignedSaturatedNarrow64, U128, U128 )