| 1 |
//===- llvm/unittest/Support/ScaledNumberTest.cpp - ScaledPair tests -----==// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#include "llvm/Support/ScaledNumber.h" |
| 10 |
#include "llvm/Support/DataTypes.h" |
| 11 |
#include "gtest/gtest.h" |
| 12 |
|
| 13 |
using namespace llvm; |
| 14 |
using namespace llvm::ScaledNumbers; |
| 15 |
|
| 16 |
namespace { |
| 17 |
|
| 18 |
template <class UIntT> struct ScaledPair { |
| 19 |
UIntT D; |
| 20 |
int S; |
| 21 |
ScaledPair(const std::pair<UIntT, int16_t> &F) : D(F.first), S(F.second) {} |
| 22 |
ScaledPair(UIntT D, int S) : D(D), S(S) {} |
| 23 |
|
| 24 |
bool operator==(const ScaledPair<UIntT> &X) const { |
| 25 |
return D == X.D && S == X.S; |
| 26 |
} |
| 27 |
}; |
| 28 |
template <class UIntT> |
| 29 |
bool operator==(const std::pair<UIntT, int16_t> &L, |
| 30 |
const ScaledPair<UIntT> &R) { |
| 31 |
return ScaledPair<UIntT>(L) == R; |
| 32 |
} |
| 33 |
template <class UIntT> |
| 34 |
void PrintTo(const ScaledPair<UIntT> &F, ::std::ostream *os) { |
| 35 |
*os << F.D << "*2^" << F.S; |
| 36 |
} |
| 37 |
|
| 38 |
typedef ScaledPair<uint32_t> SP32; |
| 39 |
typedef ScaledPair<uint64_t> SP64; |
| 40 |
|
| 41 |
TEST(ScaledNumberHelpersTest, getRounded) { |
| 42 |
EXPECT_EQ(getRounded32(0, 0, false), SP32(0, 0)); |
| 43 |
EXPECT_EQ(getRounded32(0, 0, true), SP32(1, 0)); |
| 44 |
EXPECT_EQ(getRounded32(20, 21, true), SP32(21, 21)); |
| 45 |
EXPECT_EQ(getRounded32(UINT32_MAX, 0, false), SP32(UINT32_MAX, 0)); |
| 46 |
EXPECT_EQ(getRounded32(UINT32_MAX, 0, true), SP32(1 << 31, 1)); |
| 47 |
|
| 48 |
EXPECT_EQ(getRounded64(0, 0, false), SP64(0, 0)); |
| 49 |
EXPECT_EQ(getRounded64(0, 0, true), SP64(1, 0)); |
| 50 |
EXPECT_EQ(getRounded64(20, 21, true), SP64(21, 21)); |
| 51 |
EXPECT_EQ(getRounded64(UINT32_MAX, 0, false), SP64(UINT32_MAX, 0)); |
| 52 |
EXPECT_EQ(getRounded64(UINT32_MAX, 0, true), SP64(UINT64_C(1) << 32, 0)); |
| 53 |
EXPECT_EQ(getRounded64(UINT64_MAX, 0, false), SP64(UINT64_MAX, 0)); |
| 54 |
EXPECT_EQ(getRounded64(UINT64_MAX, 0, true), SP64(UINT64_C(1) << 63, 1)); |
| 55 |
} |
| 56 |
|
| 57 |
TEST(ScaledNumberHelpersTest, getAdjusted) { |
| 58 |
const uint64_t Max32In64 = UINT32_MAX; |
| 59 |
EXPECT_EQ(getAdjusted32(0), SP32(0, 0)); |
| 60 |
EXPECT_EQ(getAdjusted32(0, 5), SP32(0, 5)); |
| 61 |
EXPECT_EQ(getAdjusted32(UINT32_MAX), SP32(UINT32_MAX, 0)); |
| 62 |
EXPECT_EQ(getAdjusted32(Max32In64 << 1), SP32(UINT32_MAX, 1)); |
| 63 |
EXPECT_EQ(getAdjusted32(Max32In64 << 1, 1), SP32(UINT32_MAX, 2)); |
| 64 |
EXPECT_EQ(getAdjusted32(Max32In64 << 31), SP32(UINT32_MAX, 31)); |
| 65 |
EXPECT_EQ(getAdjusted32(Max32In64 << 32), SP32(UINT32_MAX, 32)); |
| 66 |
EXPECT_EQ(getAdjusted32(Max32In64 + 1), SP32(1u << 31, 1)); |
| 67 |
EXPECT_EQ(getAdjusted32(UINT64_MAX), SP32(1u << 31, 33)); |
| 68 |
|
| 69 |
EXPECT_EQ(getAdjusted64(0), SP64(0, 0)); |
| 70 |
EXPECT_EQ(getAdjusted64(0, 5), SP64(0, 5)); |
| 71 |
EXPECT_EQ(getAdjusted64(UINT32_MAX), SP64(UINT32_MAX, 0)); |
| 72 |
EXPECT_EQ(getAdjusted64(Max32In64 << 1), SP64(Max32In64 << 1, 0)); |
| 73 |
EXPECT_EQ(getAdjusted64(Max32In64 << 1, 1), SP64(Max32In64 << 1, 1)); |
| 74 |
EXPECT_EQ(getAdjusted64(Max32In64 << 31), SP64(Max32In64 << 31, 0)); |
| 75 |
EXPECT_EQ(getAdjusted64(Max32In64 << 32), SP64(Max32In64 << 32, 0)); |
| 76 |
EXPECT_EQ(getAdjusted64(Max32In64 + 1), SP64(Max32In64 + 1, 0)); |
| 77 |
EXPECT_EQ(getAdjusted64(UINT64_MAX), SP64(UINT64_MAX, 0)); |
| 78 |
} |
| 79 |
|
| 80 |
TEST(ScaledNumberHelpersTest, getProduct) { |
| 81 |
// Zero. |
| 82 |
EXPECT_EQ(SP32(0, 0), getProduct32(0, 0)); |
| 83 |
EXPECT_EQ(SP32(0, 0), getProduct32(0, 1)); |
| 84 |
EXPECT_EQ(SP32(0, 0), getProduct32(0, 33)); |
| 85 |
|
| 86 |
// Basic. |
| 87 |
EXPECT_EQ(SP32(6, 0), getProduct32(2, 3)); |
| 88 |
EXPECT_EQ(SP32(UINT16_MAX / 3 * UINT16_MAX / 5 * 2, 0), |
| 89 |
getProduct32(UINT16_MAX / 3, UINT16_MAX / 5 * 2)); |
| 90 |
|
| 91 |
// Overflow, no loss of precision. |
| 92 |
// ==> 0xf00010 * 0x1001 |
| 93 |
// ==> 0xf00f00000 + 0x10010 |
| 94 |
// ==> 0xf00f10010 |
| 95 |
// ==> 0xf00f1001 * 2^4 |
| 96 |
EXPECT_EQ(SP32(0xf00f1001, 4), getProduct32(0xf00010, 0x1001)); |
| 97 |
|
| 98 |
// Overflow, loss of precision, rounds down. |
| 99 |
// ==> 0xf000070 * 0x1001 |
| 100 |
// ==> 0xf00f000000 + 0x70070 |
| 101 |
// ==> 0xf00f070070 |
| 102 |
// ==> 0xf00f0700 * 2^8 |
| 103 |
EXPECT_EQ(SP32(0xf00f0700, 8), getProduct32(0xf000070, 0x1001)); |
| 104 |
|
| 105 |
// Overflow, loss of precision, rounds up. |
| 106 |
// ==> 0xf000080 * 0x1001 |
| 107 |
// ==> 0xf00f000000 + 0x80080 |
| 108 |
// ==> 0xf00f080080 |
| 109 |
// ==> 0xf00f0801 * 2^8 |
| 110 |
EXPECT_EQ(SP32(0xf00f0801, 8), getProduct32(0xf000080, 0x1001)); |
| 111 |
|
| 112 |
// Reverse operand order. |
| 113 |
EXPECT_EQ(SP32(0, 0), getProduct32(1, 0)); |
| 114 |
EXPECT_EQ(SP32(0, 0), getProduct32(33, 0)); |
| 115 |
EXPECT_EQ(SP32(6, 0), getProduct32(3, 2)); |
| 116 |
EXPECT_EQ(SP32(UINT16_MAX / 3 * UINT16_MAX / 5 * 2, 0), |
| 117 |
getProduct32(UINT16_MAX / 5 * 2, UINT16_MAX / 3)); |
| 118 |
EXPECT_EQ(SP32(0xf00f1001, 4), getProduct32(0x1001, 0xf00010)); |
| 119 |
EXPECT_EQ(SP32(0xf00f0700, 8), getProduct32(0x1001, 0xf000070)); |
| 120 |
EXPECT_EQ(SP32(0xf00f0801, 8), getProduct32(0x1001, 0xf000080)); |
| 121 |
|
| 122 |
// Round to overflow. |
| 123 |
EXPECT_EQ(SP64(UINT64_C(1) << 63, 64), |
| 124 |
getProduct64(UINT64_C(10376293541461622786), |
| 125 |
UINT64_C(16397105843297379211))); |
| 126 |
|
| 127 |
// Big number with rounding. |
| 128 |
EXPECT_EQ(SP64(UINT64_C(9223372036854775810), 64), |
| 129 |
getProduct64(UINT64_C(18446744073709551556), |
| 130 |
UINT64_C(9223372036854775840))); |
| 131 |
} |
| 132 |
|
| 133 |
TEST(ScaledNumberHelpersTest, getQuotient) { |
| 134 |
// Zero. |
| 135 |
EXPECT_EQ(SP32(0, 0), getQuotient32(0, 0)); |
| 136 |
EXPECT_EQ(SP32(0, 0), getQuotient32(0, 1)); |
| 137 |
EXPECT_EQ(SP32(0, 0), getQuotient32(0, 73)); |
| 138 |
EXPECT_EQ(SP32(UINT32_MAX, MaxScale), getQuotient32(1, 0)); |
| 139 |
EXPECT_EQ(SP32(UINT32_MAX, MaxScale), getQuotient32(6, 0)); |
| 140 |
|
| 141 |
// Powers of two. |
| 142 |
EXPECT_EQ(SP32(1u << 31, -31), getQuotient32(1, 1)); |
| 143 |
EXPECT_EQ(SP32(1u << 31, -30), getQuotient32(2, 1)); |
| 144 |
EXPECT_EQ(SP32(1u << 31, -33), getQuotient32(4, 16)); |
| 145 |
EXPECT_EQ(SP32(7u << 29, -29), getQuotient32(7, 1)); |
| 146 |
EXPECT_EQ(SP32(7u << 29, -30), getQuotient32(7, 2)); |
| 147 |
EXPECT_EQ(SP32(7u << 29, -33), getQuotient32(7, 16)); |
| 148 |
|
| 149 |
// Divide evenly. |
| 150 |
EXPECT_EQ(SP32(3u << 30, -30), getQuotient32(9, 3)); |
| 151 |
EXPECT_EQ(SP32(9u << 28, -28), getQuotient32(63, 7)); |
| 152 |
|
| 153 |
// Divide unevenly. |
| 154 |
EXPECT_EQ(SP32(0xaaaaaaab, -33), getQuotient32(1, 3)); |
| 155 |
EXPECT_EQ(SP32(0xd5555555, -31), getQuotient32(5, 3)); |
| 156 |
|
| 157 |
// 64-bit division is hard to test, since divide64 doesn't canonicalize its |
| 158 |
// output. However, this is the algorithm the implementation uses: |
| 159 |
// |
| 160 |
// - Shift divisor right. |
| 161 |
// - If we have 1 (power of 2), return early -- not canonicalized. |
| 162 |
// - Shift dividend left. |
| 163 |
// - 64-bit integer divide. |
| 164 |
// - If there's a remainder, continue with long division. |
| 165 |
// |
| 166 |
// TODO: require less knowledge about the implementation in the test. |
| 167 |
|
| 168 |
// Zero. |
| 169 |
EXPECT_EQ(SP64(0, 0), getQuotient64(0, 0)); |
| 170 |
EXPECT_EQ(SP64(0, 0), getQuotient64(0, 1)); |
| 171 |
EXPECT_EQ(SP64(0, 0), getQuotient64(0, 73)); |
| 172 |
EXPECT_EQ(SP64(UINT64_MAX, MaxScale), getQuotient64(1, 0)); |
| 173 |
EXPECT_EQ(SP64(UINT64_MAX, MaxScale), getQuotient64(6, 0)); |
| 174 |
|
| 175 |
// Powers of two. |
| 176 |
EXPECT_EQ(SP64(1, 0), getQuotient64(1, 1)); |
| 177 |
EXPECT_EQ(SP64(2, 0), getQuotient64(2, 1)); |
| 178 |
EXPECT_EQ(SP64(4, -4), getQuotient64(4, 16)); |
| 179 |
EXPECT_EQ(SP64(7, 0), getQuotient64(7, 1)); |
| 180 |
EXPECT_EQ(SP64(7, -1), getQuotient64(7, 2)); |
| 181 |
EXPECT_EQ(SP64(7, -4), getQuotient64(7, 16)); |
| 182 |
|
| 183 |
// Divide evenly. |
| 184 |
EXPECT_EQ(SP64(UINT64_C(3) << 60, -60), getQuotient64(9, 3)); |
| 185 |
EXPECT_EQ(SP64(UINT64_C(9) << 58, -58), getQuotient64(63, 7)); |
| 186 |
|
| 187 |
// Divide unevenly. |
| 188 |
EXPECT_EQ(SP64(0xaaaaaaaaaaaaaaab, -65), getQuotient64(1, 3)); |
| 189 |
EXPECT_EQ(SP64(0xd555555555555555, -63), getQuotient64(5, 3)); |
| 190 |
} |
| 191 |
|
| 192 |
TEST(ScaledNumberHelpersTest, getLg) { |
| 193 |
EXPECT_EQ(0, getLg(UINT32_C(1), 0)); |
| 194 |
EXPECT_EQ(1, getLg(UINT32_C(1), 1)); |
| 195 |
EXPECT_EQ(1, getLg(UINT32_C(2), 0)); |
| 196 |
EXPECT_EQ(3, getLg(UINT32_C(1), 3)); |
| 197 |
EXPECT_EQ(3, getLg(UINT32_C(7), 0)); |
| 198 |
EXPECT_EQ(3, getLg(UINT32_C(8), 0)); |
| 199 |
EXPECT_EQ(3, getLg(UINT32_C(9), 0)); |
| 200 |
EXPECT_EQ(3, getLg(UINT32_C(64), -3)); |
| 201 |
EXPECT_EQ(31, getLg((UINT32_MAX >> 1) + 2, 0)); |
| 202 |
EXPECT_EQ(32, getLg(UINT32_MAX, 0)); |
| 203 |
EXPECT_EQ(-1, getLg(UINT32_C(1), -1)); |
| 204 |
EXPECT_EQ(-1, getLg(UINT32_C(2), -2)); |
| 205 |
EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), -1)); |
| 206 |
EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), 0)); |
| 207 |
EXPECT_EQ(INT32_MIN, getLg(UINT32_C(0), 1)); |
| 208 |
|
| 209 |
EXPECT_EQ(0, getLg(UINT64_C(1), 0)); |
| 210 |
EXPECT_EQ(1, getLg(UINT64_C(1), 1)); |
| 211 |
EXPECT_EQ(1, getLg(UINT64_C(2), 0)); |
| 212 |
EXPECT_EQ(3, getLg(UINT64_C(1), 3)); |
| 213 |
EXPECT_EQ(3, getLg(UINT64_C(7), 0)); |
| 214 |
EXPECT_EQ(3, getLg(UINT64_C(8), 0)); |
| 215 |
EXPECT_EQ(3, getLg(UINT64_C(9), 0)); |
| 216 |
EXPECT_EQ(3, getLg(UINT64_C(64), -3)); |
| 217 |
EXPECT_EQ(63, getLg((UINT64_MAX >> 1) + 2, 0)); |
| 218 |
EXPECT_EQ(64, getLg(UINT64_MAX, 0)); |
| 219 |
EXPECT_EQ(-1, getLg(UINT64_C(1), -1)); |
| 220 |
EXPECT_EQ(-1, getLg(UINT64_C(2), -2)); |
| 221 |
EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), -1)); |
| 222 |
EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), 0)); |
| 223 |
EXPECT_EQ(INT32_MIN, getLg(UINT64_C(0), 1)); |
| 224 |
} |
| 225 |
|
| 226 |
TEST(ScaledNumberHelpersTest, getLgFloor) { |
| 227 |
EXPECT_EQ(0, getLgFloor(UINT32_C(1), 0)); |
| 228 |
EXPECT_EQ(1, getLgFloor(UINT32_C(1), 1)); |
| 229 |
EXPECT_EQ(1, getLgFloor(UINT32_C(2), 0)); |
| 230 |
EXPECT_EQ(2, getLgFloor(UINT32_C(7), 0)); |
| 231 |
EXPECT_EQ(3, getLgFloor(UINT32_C(1), 3)); |
| 232 |
EXPECT_EQ(3, getLgFloor(UINT32_C(8), 0)); |
| 233 |
EXPECT_EQ(3, getLgFloor(UINT32_C(9), 0)); |
| 234 |
EXPECT_EQ(3, getLgFloor(UINT32_C(64), -3)); |
| 235 |
EXPECT_EQ(31, getLgFloor((UINT32_MAX >> 1) + 2, 0)); |
| 236 |
EXPECT_EQ(31, getLgFloor(UINT32_MAX, 0)); |
| 237 |
EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), -1)); |
| 238 |
EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), 0)); |
| 239 |
EXPECT_EQ(INT32_MIN, getLgFloor(UINT32_C(0), 1)); |
| 240 |
|
| 241 |
EXPECT_EQ(0, getLgFloor(UINT64_C(1), 0)); |
| 242 |
EXPECT_EQ(1, getLgFloor(UINT64_C(1), 1)); |
| 243 |
EXPECT_EQ(1, getLgFloor(UINT64_C(2), 0)); |
| 244 |
EXPECT_EQ(2, getLgFloor(UINT64_C(7), 0)); |
| 245 |
EXPECT_EQ(3, getLgFloor(UINT64_C(1), 3)); |
| 246 |
EXPECT_EQ(3, getLgFloor(UINT64_C(8), 0)); |
| 247 |
EXPECT_EQ(3, getLgFloor(UINT64_C(9), 0)); |
| 248 |
EXPECT_EQ(3, getLgFloor(UINT64_C(64), -3)); |
| 249 |
EXPECT_EQ(63, getLgFloor((UINT64_MAX >> 1) + 2, 0)); |
| 250 |
EXPECT_EQ(63, getLgFloor(UINT64_MAX, 0)); |
| 251 |
EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), -1)); |
| 252 |
EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), 0)); |
| 253 |
EXPECT_EQ(INT32_MIN, getLgFloor(UINT64_C(0), 1)); |
| 254 |
} |
| 255 |
|
| 256 |
TEST(ScaledNumberHelpersTest, getLgCeiling) { |
| 257 |
EXPECT_EQ(0, getLgCeiling(UINT32_C(1), 0)); |
| 258 |
EXPECT_EQ(1, getLgCeiling(UINT32_C(1), 1)); |
| 259 |
EXPECT_EQ(1, getLgCeiling(UINT32_C(2), 0)); |
| 260 |
EXPECT_EQ(3, getLgCeiling(UINT32_C(1), 3)); |
| 261 |
EXPECT_EQ(3, getLgCeiling(UINT32_C(7), 0)); |
| 262 |
EXPECT_EQ(3, getLgCeiling(UINT32_C(8), 0)); |
| 263 |
EXPECT_EQ(3, getLgCeiling(UINT32_C(64), -3)); |
| 264 |
EXPECT_EQ(4, getLgCeiling(UINT32_C(9), 0)); |
| 265 |
EXPECT_EQ(32, getLgCeiling(UINT32_MAX, 0)); |
| 266 |
EXPECT_EQ(32, getLgCeiling((UINT32_MAX >> 1) + 2, 0)); |
| 267 |
EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), -1)); |
| 268 |
EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), 0)); |
| 269 |
EXPECT_EQ(INT32_MIN, getLgCeiling(UINT32_C(0), 1)); |
| 270 |
|
| 271 |
EXPECT_EQ(0, getLgCeiling(UINT64_C(1), 0)); |
| 272 |
EXPECT_EQ(1, getLgCeiling(UINT64_C(1), 1)); |
| 273 |
EXPECT_EQ(1, getLgCeiling(UINT64_C(2), 0)); |
| 274 |
EXPECT_EQ(3, getLgCeiling(UINT64_C(1), 3)); |
| 275 |
EXPECT_EQ(3, getLgCeiling(UINT64_C(7), 0)); |
| 276 |
EXPECT_EQ(3, getLgCeiling(UINT64_C(8), 0)); |
| 277 |
EXPECT_EQ(3, getLgCeiling(UINT64_C(64), -3)); |
| 278 |
EXPECT_EQ(4, getLgCeiling(UINT64_C(9), 0)); |
| 279 |
EXPECT_EQ(64, getLgCeiling((UINT64_MAX >> 1) + 2, 0)); |
| 280 |
EXPECT_EQ(64, getLgCeiling(UINT64_MAX, 0)); |
| 281 |
EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), -1)); |
| 282 |
EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), 0)); |
| 283 |
EXPECT_EQ(INT32_MIN, getLgCeiling(UINT64_C(0), 1)); |
| 284 |
} |
| 285 |
|
| 286 |
TEST(ScaledNumberHelpersTest, compare) { |
| 287 |
EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), 1)); |
| 288 |
EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), -10)); |
| 289 |
EXPECT_EQ(0, compare(UINT32_C(0), 0, UINT32_C(0), 20)); |
| 290 |
EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(64), -3)); |
| 291 |
EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(32), -2)); |
| 292 |
EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(16), -1)); |
| 293 |
EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(8), 0)); |
| 294 |
EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(4), 1)); |
| 295 |
EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(2), 2)); |
| 296 |
EXPECT_EQ(0, compare(UINT32_C(8), 0, UINT32_C(1), 3)); |
| 297 |
EXPECT_EQ(-1, compare(UINT32_C(0), 0, UINT32_C(1), 3)); |
| 298 |
EXPECT_EQ(-1, compare(UINT32_C(7), 0, UINT32_C(1), 3)); |
| 299 |
EXPECT_EQ(-1, compare(UINT32_C(7), 0, UINT32_C(64), -3)); |
| 300 |
EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(1), 3)); |
| 301 |
EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(64), -3)); |
| 302 |
EXPECT_EQ(1, compare(UINT32_C(9), 0, UINT32_C(0), 0)); |
| 303 |
|
| 304 |
EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), 1)); |
| 305 |
EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), -10)); |
| 306 |
EXPECT_EQ(0, compare(UINT64_C(0), 0, UINT64_C(0), 20)); |
| 307 |
EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(64), -3)); |
| 308 |
EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(32), -2)); |
| 309 |
EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(16), -1)); |
| 310 |
EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(8), 0)); |
| 311 |
EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(4), 1)); |
| 312 |
EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(2), 2)); |
| 313 |
EXPECT_EQ(0, compare(UINT64_C(8), 0, UINT64_C(1), 3)); |
| 314 |
EXPECT_EQ(-1, compare(UINT64_C(0), 0, UINT64_C(1), 3)); |
| 315 |
EXPECT_EQ(-1, compare(UINT64_C(7), 0, UINT64_C(1), 3)); |
| 316 |
EXPECT_EQ(-1, compare(UINT64_C(7), 0, UINT64_C(64), -3)); |
| 317 |
EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(1), 3)); |
| 318 |
EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(64), -3)); |
| 319 |
EXPECT_EQ(1, compare(UINT64_C(9), 0, UINT64_C(0), 0)); |
| 320 |
EXPECT_EQ(-1, compare(UINT64_MAX, 0, UINT64_C(1), 64)); |
| 321 |
} |
| 322 |
|
| 323 |
TEST(ScaledNumberHelpersTest, matchScales) { |
| 324 |
#define MATCH_SCALES(T, LDIn, LSIn, RDIn, RSIn, LDOut, RDOut, SOut) \ |
| 325 |
do { \ |
| 326 |
T LDx = LDIn; \ |
| 327 |
T RDx = RDIn; \ |
| 328 |
T LDy = LDOut; \ |
| 329 |
T RDy = RDOut; \ |
| 330 |
int16_t LSx = LSIn; \ |
| 331 |
int16_t RSx = RSIn; \ |
| 332 |
int16_t Sy = SOut; \ |
| 333 |
\ |
| 334 |
EXPECT_EQ(SOut, matchScales(LDx, LSx, RDx, RSx)); \ |
| 335 |
EXPECT_EQ(LDy, LDx); \ |
| 336 |
EXPECT_EQ(RDy, RDx); \ |
| 337 |
if (LDy) { \ |
| 338 |
EXPECT_EQ(Sy, LSx); \ |
| 339 |
} \ |
| 340 |
if (RDy) { \ |
| 341 |
EXPECT_EQ(Sy, RSx); \ |
| 342 |
} \ |
| 343 |
} while (false) |
| 344 |
|
| 345 |
MATCH_SCALES(uint32_t, 0, 0, 0, 0, 0, 0, 0); |
| 346 |
MATCH_SCALES(uint32_t, 0, 50, 7, 1, 0, 7, 1); |
| 347 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 1, 9, 0, UINT32_C(1) << 31, 4, 1); |
| 348 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 2, 9, 0, UINT32_C(1) << 31, 2, 2); |
| 349 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 3, 9, 0, UINT32_C(1) << 31, 1, 3); |
| 350 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 31, 4, 9, 0, UINT32_C(1) << 31, 0, 4); |
| 351 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 30, 4, 9, 0, UINT32_C(1) << 31, 1, 3); |
| 352 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 29, 4, 9, 0, UINT32_C(1) << 31, 2, 2); |
| 353 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 28, 4, 9, 0, UINT32_C(1) << 31, 4, 1); |
| 354 |
MATCH_SCALES(uint32_t, UINT32_C(1) << 27, 4, 9, 0, UINT32_C(1) << 31, 9, 0); |
| 355 |
MATCH_SCALES(uint32_t, 7, 1, 0, 50, 7, 0, 1); |
| 356 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 1, 4, UINT32_C(1) << 31, 1); |
| 357 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 2, 2, UINT32_C(1) << 31, 2); |
| 358 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 3, 1, UINT32_C(1) << 31, 3); |
| 359 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 31, 4, 0, UINT32_C(1) << 31, 4); |
| 360 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 30, 4, 1, UINT32_C(1) << 31, 3); |
| 361 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 29, 4, 2, UINT32_C(1) << 31, 2); |
| 362 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 28, 4, 4, UINT32_C(1) << 31, 1); |
| 363 |
MATCH_SCALES(uint32_t, 9, 0, UINT32_C(1) << 27, 4, 9, UINT32_C(1) << 31, 0); |
| 364 |
|
| 365 |
MATCH_SCALES(uint64_t, 0, 0, 0, 0, 0, 0, 0); |
| 366 |
MATCH_SCALES(uint64_t, 0, 100, 7, 1, 0, 7, 1); |
| 367 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 1, 9, 0, UINT64_C(1) << 63, 4, 1); |
| 368 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 2, 9, 0, UINT64_C(1) << 63, 2, 2); |
| 369 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 3, 9, 0, UINT64_C(1) << 63, 1, 3); |
| 370 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 63, 4, 9, 0, UINT64_C(1) << 63, 0, 4); |
| 371 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 62, 4, 9, 0, UINT64_C(1) << 63, 1, 3); |
| 372 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 61, 4, 9, 0, UINT64_C(1) << 63, 2, 2); |
| 373 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 60, 4, 9, 0, UINT64_C(1) << 63, 4, 1); |
| 374 |
MATCH_SCALES(uint64_t, UINT64_C(1) << 59, 4, 9, 0, UINT64_C(1) << 63, 9, 0); |
| 375 |
MATCH_SCALES(uint64_t, 7, 1, 0, 100, 7, 0, 1); |
| 376 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 1, 4, UINT64_C(1) << 63, 1); |
| 377 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 2, 2, UINT64_C(1) << 63, 2); |
| 378 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 3, 1, UINT64_C(1) << 63, 3); |
| 379 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 63, 4, 0, UINT64_C(1) << 63, 4); |
| 380 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 62, 4, 1, UINT64_C(1) << 63, 3); |
| 381 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 61, 4, 2, UINT64_C(1) << 63, 2); |
| 382 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 60, 4, 4, UINT64_C(1) << 63, 1); |
| 383 |
MATCH_SCALES(uint64_t, 9, 0, UINT64_C(1) << 59, 4, 9, UINT64_C(1) << 63, 0); |
| 384 |
} |
| 385 |
|
| 386 |
TEST(ScaledNumberHelpersTest, getSum) { |
| 387 |
// Zero. |
| 388 |
EXPECT_EQ(SP32(1, 0), getSum32(0, 0, 1, 0)); |
| 389 |
EXPECT_EQ(SP32(8, -3), getSum32(0, 0, 8, -3)); |
| 390 |
EXPECT_EQ(SP32(UINT32_MAX, 0), getSum32(0, 0, UINT32_MAX, 0)); |
| 391 |
|
| 392 |
// Basic. |
| 393 |
EXPECT_EQ(SP32(2, 0), getSum32(1, 0, 1, 0)); |
| 394 |
EXPECT_EQ(SP32(3, 0), getSum32(1, 0, 2, 0)); |
| 395 |
EXPECT_EQ(SP32(67, 0), getSum32(7, 0, 60, 0)); |
| 396 |
|
| 397 |
// Different scales. |
| 398 |
EXPECT_EQ(SP32(3, 0), getSum32(1, 0, 1, 1)); |
| 399 |
EXPECT_EQ(SP32(4, 0), getSum32(2, 0, 1, 1)); |
| 400 |
|
| 401 |
// Loss of precision. |
| 402 |
EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 32, 1, 0)); |
| 403 |
EXPECT_EQ(SP32(UINT32_C(1) << 31, -31), getSum32(1, -32, 1, 0)); |
| 404 |
|
| 405 |
// Not quite loss of precision. |
| 406 |
EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1), getSum32(1, 32, 1, 1)); |
| 407 |
EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -32), getSum32(1, -32, 1, -1)); |
| 408 |
|
| 409 |
// Overflow. |
| 410 |
EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 0, UINT32_MAX, 0)); |
| 411 |
|
| 412 |
// Reverse operand order. |
| 413 |
EXPECT_EQ(SP32(1, 0), getSum32(1, 0, 0, 0)); |
| 414 |
EXPECT_EQ(SP32(8, -3), getSum32(8, -3, 0, 0)); |
| 415 |
EXPECT_EQ(SP32(UINT32_MAX, 0), getSum32(UINT32_MAX, 0, 0, 0)); |
| 416 |
EXPECT_EQ(SP32(3, 0), getSum32(2, 0, 1, 0)); |
| 417 |
EXPECT_EQ(SP32(67, 0), getSum32(60, 0, 7, 0)); |
| 418 |
EXPECT_EQ(SP32(3, 0), getSum32(1, 1, 1, 0)); |
| 419 |
EXPECT_EQ(SP32(4, 0), getSum32(1, 1, 2, 0)); |
| 420 |
EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(1, 0, 1, 32)); |
| 421 |
EXPECT_EQ(SP32(UINT32_C(1) << 31, -31), getSum32(1, 0, 1, -32)); |
| 422 |
EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1), getSum32(1, 1, 1, 32)); |
| 423 |
EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -32), getSum32(1, -1, 1, -32)); |
| 424 |
EXPECT_EQ(SP32(UINT32_C(1) << 31, 1), getSum32(UINT32_MAX, 0, 1, 0)); |
| 425 |
|
| 426 |
// Zero. |
| 427 |
EXPECT_EQ(SP64(1, 0), getSum64(0, 0, 1, 0)); |
| 428 |
EXPECT_EQ(SP64(8, -3), getSum64(0, 0, 8, -3)); |
| 429 |
EXPECT_EQ(SP64(UINT64_MAX, 0), getSum64(0, 0, UINT64_MAX, 0)); |
| 430 |
|
| 431 |
// Basic. |
| 432 |
EXPECT_EQ(SP64(2, 0), getSum64(1, 0, 1, 0)); |
| 433 |
EXPECT_EQ(SP64(3, 0), getSum64(1, 0, 2, 0)); |
| 434 |
EXPECT_EQ(SP64(67, 0), getSum64(7, 0, 60, 0)); |
| 435 |
|
| 436 |
// Different scales. |
| 437 |
EXPECT_EQ(SP64(3, 0), getSum64(1, 0, 1, 1)); |
| 438 |
EXPECT_EQ(SP64(4, 0), getSum64(2, 0, 1, 1)); |
| 439 |
|
| 440 |
// Loss of precision. |
| 441 |
EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 64, 1, 0)); |
| 442 |
EXPECT_EQ(SP64(UINT64_C(1) << 63, -63), getSum64(1, -64, 1, 0)); |
| 443 |
|
| 444 |
// Not quite loss of precision. |
| 445 |
EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1), getSum64(1, 64, 1, 1)); |
| 446 |
EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -64), getSum64(1, -64, 1, -1)); |
| 447 |
|
| 448 |
// Overflow. |
| 449 |
EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 0, UINT64_MAX, 0)); |
| 450 |
|
| 451 |
// Reverse operand order. |
| 452 |
EXPECT_EQ(SP64(1, 0), getSum64(1, 0, 0, 0)); |
| 453 |
EXPECT_EQ(SP64(8, -3), getSum64(8, -3, 0, 0)); |
| 454 |
EXPECT_EQ(SP64(UINT64_MAX, 0), getSum64(UINT64_MAX, 0, 0, 0)); |
| 455 |
EXPECT_EQ(SP64(3, 0), getSum64(2, 0, 1, 0)); |
| 456 |
EXPECT_EQ(SP64(67, 0), getSum64(60, 0, 7, 0)); |
| 457 |
EXPECT_EQ(SP64(3, 0), getSum64(1, 1, 1, 0)); |
| 458 |
EXPECT_EQ(SP64(4, 0), getSum64(1, 1, 2, 0)); |
| 459 |
EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(1, 0, 1, 64)); |
| 460 |
EXPECT_EQ(SP64(UINT64_C(1) << 63, -63), getSum64(1, 0, 1, -64)); |
| 461 |
EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1), getSum64(1, 1, 1, 64)); |
| 462 |
EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -64), getSum64(1, -1, 1, -64)); |
| 463 |
EXPECT_EQ(SP64(UINT64_C(1) << 63, 1), getSum64(UINT64_MAX, 0, 1, 0)); |
| 464 |
} |
| 465 |
|
| 466 |
TEST(ScaledNumberHelpersTest, getDifference) { |
| 467 |
// Basic. |
| 468 |
EXPECT_EQ(SP32(0, 0), getDifference32(1, 0, 1, 0)); |
| 469 |
EXPECT_EQ(SP32(1, 0), getDifference32(2, 0, 1, 0)); |
| 470 |
EXPECT_EQ(SP32(53, 0), getDifference32(60, 0, 7, 0)); |
| 471 |
|
| 472 |
// Equals "0", different scales. |
| 473 |
EXPECT_EQ(SP32(0, 0), getDifference32(2, 0, 1, 1)); |
| 474 |
|
| 475 |
// Subtract "0". |
| 476 |
EXPECT_EQ(SP32(1, 0), getDifference32(1, 0, 0, 0)); |
| 477 |
EXPECT_EQ(SP32(8, -3), getDifference32(8, -3, 0, 0)); |
| 478 |
EXPECT_EQ(SP32(UINT32_MAX, 0), getDifference32(UINT32_MAX, 0, 0, 0)); |
| 479 |
|
| 480 |
// Loss of precision. |
| 481 |
EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, 1), |
| 482 |
getDifference32((UINT32_C(1) << 31) + 1, 1, 1, 0)); |
| 483 |
EXPECT_EQ(SP32((UINT32_C(1) << 31) + 1, -31), |
| 484 |
getDifference32((UINT32_C(1) << 31) + 1, -31, 1, -32)); |
| 485 |
|
| 486 |
// Not quite loss of precision. |
| 487 |
EXPECT_EQ(SP32(UINT32_MAX, 0), getDifference32(1, 32, 1, 0)); |
| 488 |
EXPECT_EQ(SP32(UINT32_MAX, -32), getDifference32(1, 0, 1, -32)); |
| 489 |
|
| 490 |
// Saturate to "0". |
| 491 |
EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, 1, 0)); |
| 492 |
EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, 8, -3)); |
| 493 |
EXPECT_EQ(SP32(0, 0), getDifference32(0, 0, UINT32_MAX, 0)); |
| 494 |
EXPECT_EQ(SP32(0, 0), getDifference32(7, 0, 60, 0)); |
| 495 |
EXPECT_EQ(SP32(0, 0), getDifference32(1, 0, 1, 1)); |
| 496 |
EXPECT_EQ(SP32(0, 0), getDifference32(1, -32, 1, 0)); |
| 497 |
EXPECT_EQ(SP32(0, 0), getDifference32(1, -32, 1, -1)); |
| 498 |
|
| 499 |
// Regression tests for cases that failed during bringup. |
| 500 |
EXPECT_EQ(SP32(UINT32_C(1) << 26, -31), |
| 501 |
getDifference32(1, 0, UINT32_C(31) << 27, -32)); |
| 502 |
|
| 503 |
// Basic. |
| 504 |
EXPECT_EQ(SP64(0, 0), getDifference64(1, 0, 1, 0)); |
| 505 |
EXPECT_EQ(SP64(1, 0), getDifference64(2, 0, 1, 0)); |
| 506 |
EXPECT_EQ(SP64(53, 0), getDifference64(60, 0, 7, 0)); |
| 507 |
|
| 508 |
// Equals "0", different scales. |
| 509 |
EXPECT_EQ(SP64(0, 0), getDifference64(2, 0, 1, 1)); |
| 510 |
|
| 511 |
// Subtract "0". |
| 512 |
EXPECT_EQ(SP64(1, 0), getDifference64(1, 0, 0, 0)); |
| 513 |
EXPECT_EQ(SP64(8, -3), getDifference64(8, -3, 0, 0)); |
| 514 |
EXPECT_EQ(SP64(UINT64_MAX, 0), getDifference64(UINT64_MAX, 0, 0, 0)); |
| 515 |
|
| 516 |
// Loss of precision. |
| 517 |
EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, 1), |
| 518 |
getDifference64((UINT64_C(1) << 63) + 1, 1, 1, 0)); |
| 519 |
EXPECT_EQ(SP64((UINT64_C(1) << 63) + 1, -63), |
| 520 |
getDifference64((UINT64_C(1) << 63) + 1, -63, 1, -64)); |
| 521 |
|
| 522 |
// Not quite loss of precision. |
| 523 |
EXPECT_EQ(SP64(UINT64_MAX, 0), getDifference64(1, 64, 1, 0)); |
| 524 |
EXPECT_EQ(SP64(UINT64_MAX, -64), getDifference64(1, 0, 1, -64)); |
| 525 |
|
| 526 |
// Saturate to "0". |
| 527 |
EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, 1, 0)); |
| 528 |
EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, 8, -3)); |
| 529 |
EXPECT_EQ(SP64(0, 0), getDifference64(0, 0, UINT64_MAX, 0)); |
| 530 |
EXPECT_EQ(SP64(0, 0), getDifference64(7, 0, 60, 0)); |
| 531 |
EXPECT_EQ(SP64(0, 0), getDifference64(1, 0, 1, 1)); |
| 532 |
EXPECT_EQ(SP64(0, 0), getDifference64(1, -64, 1, 0)); |
| 533 |
EXPECT_EQ(SP64(0, 0), getDifference64(1, -64, 1, -1)); |
| 534 |
} |
| 535 |
|
| 536 |
TEST(ScaledNumberHelpersTest, arithmeticOperators) { |
| 537 |
EXPECT_EQ(ScaledNumber<uint32_t>(10, 0), |
| 538 |
ScaledNumber<uint32_t>(1, 3) + ScaledNumber<uint32_t>(1, 1)); |
| 539 |
EXPECT_EQ(ScaledNumber<uint32_t>(6, 0), |
| 540 |
ScaledNumber<uint32_t>(1, 3) - ScaledNumber<uint32_t>(1, 1)); |
| 541 |
EXPECT_EQ(ScaledNumber<uint32_t>(2, 3), |
| 542 |
ScaledNumber<uint32_t>(1, 3) * ScaledNumber<uint32_t>(1, 1)); |
| 543 |
EXPECT_EQ(ScaledNumber<uint32_t>(1, 2), |
| 544 |
ScaledNumber<uint32_t>(1, 3) / ScaledNumber<uint32_t>(1, 1)); |
| 545 |
EXPECT_EQ(ScaledNumber<uint32_t>(1, 2), ScaledNumber<uint32_t>(1, 3) >> 1); |
| 546 |
EXPECT_EQ(ScaledNumber<uint32_t>(1, 4), ScaledNumber<uint32_t>(1, 3) << 1); |
| 547 |
|
| 548 |
EXPECT_EQ(ScaledNumber<uint64_t>(10, 0), |
| 549 |
ScaledNumber<uint64_t>(1, 3) + ScaledNumber<uint64_t>(1, 1)); |
| 550 |
EXPECT_EQ(ScaledNumber<uint64_t>(6, 0), |
| 551 |
ScaledNumber<uint64_t>(1, 3) - ScaledNumber<uint64_t>(1, 1)); |
| 552 |
EXPECT_EQ(ScaledNumber<uint64_t>(2, 3), |
| 553 |
ScaledNumber<uint64_t>(1, 3) * ScaledNumber<uint64_t>(1, 1)); |
| 554 |
EXPECT_EQ(ScaledNumber<uint64_t>(1, 2), |
| 555 |
ScaledNumber<uint64_t>(1, 3) / ScaledNumber<uint64_t>(1, 1)); |
| 556 |
EXPECT_EQ(ScaledNumber<uint64_t>(1, 2), ScaledNumber<uint64_t>(1, 3) >> 1); |
| 557 |
EXPECT_EQ(ScaledNumber<uint64_t>(1, 4), ScaledNumber<uint64_t>(1, 3) << 1); |
| 558 |
} |
| 559 |
|
| 560 |
TEST(ScaledNumberHelpersTest, toIntBug) { |
| 561 |
ScaledNumber<uint32_t> n(1, 0); |
| 562 |
EXPECT_EQ(1u, (n * n).toInt<uint32_t>()); |
| 563 |
} |
| 564 |
|
| 565 |
static_assert(std::is_trivially_copyable_v<ScaledNumber<uint32_t>>, |
| 566 |
"trivially copyable"); |
| 567 |
|
| 568 |
} // end namespace |