1 // Copyright 2017 The Dawn Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include <gtest/gtest.h>
16
17 #include "common/Math.h"
18 #include "dawn/EnumClassBitmasks.h"
19
20 #include <cmath>
21 #include "dawn/webgpu_cpp.h"
22
23 namespace wgpu {
24 enum class TestEnum {
25 A = 0x1,
26 B = 0x2,
27 C = 0x4,
28 };
29 } // namespace wgpu
30
31 namespace dawn {
32 template <>
33 struct IsDawnBitmask<wgpu::TestEnum> {
34 static constexpr bool enable = true;
35 };
36 } // namespace dawn
37
38 // Tests for ScanForward
TEST(Math,ScanForward)39 TEST(Math, ScanForward) {
40 // Test extrema
41 ASSERT_EQ(ScanForward(1), 0u);
42 ASSERT_EQ(ScanForward(0x80000000), 31u);
43
44 // Test with more than one bit set.
45 ASSERT_EQ(ScanForward(256), 8u);
46 ASSERT_EQ(ScanForward(256 + 32), 5u);
47 ASSERT_EQ(ScanForward(1024 + 256 + 32), 5u);
48 }
49
50 // Tests for Log2
TEST(Math,Log2)51 TEST(Math, Log2) {
52 // Test extrema
53 ASSERT_EQ(Log2(1u), 0u);
54 ASSERT_EQ(Log2(0xFFFFFFFFu), 31u);
55 ASSERT_EQ(Log2(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)), 63u);
56
57 static_assert(ConstexprLog2(1u) == 0u, "");
58 static_assert(ConstexprLog2(0xFFFFFFFFu) == 31u, "");
59 static_assert(ConstexprLog2(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)) == 63u, "");
60
61 // Test boundary between two logs
62 ASSERT_EQ(Log2(0x80000000u), 31u);
63 ASSERT_EQ(Log2(0x7FFFFFFFu), 30u);
64 ASSERT_EQ(Log2(static_cast<uint64_t>(0x8000000000000000)), 63u);
65 ASSERT_EQ(Log2(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)), 62u);
66
67 static_assert(ConstexprLog2(0x80000000u) == 31u, "");
68 static_assert(ConstexprLog2(0x7FFFFFFFu) == 30u, "");
69 static_assert(ConstexprLog2(static_cast<uint64_t>(0x8000000000000000)) == 63u, "");
70 static_assert(ConstexprLog2(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)) == 62u, "");
71
72 ASSERT_EQ(Log2(16u), 4u);
73 ASSERT_EQ(Log2(15u), 3u);
74
75 static_assert(ConstexprLog2(16u) == 4u, "");
76 static_assert(ConstexprLog2(15u) == 3u, "");
77 }
78
79 // Tests for Log2Ceil
TEST(Math,Log2Ceil)80 TEST(Math, Log2Ceil) {
81 // Test extrema
82 ASSERT_EQ(Log2Ceil(1u), 0u);
83 ASSERT_EQ(Log2Ceil(0xFFFFFFFFu), 32u);
84 ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)), 64u);
85
86 static_assert(ConstexprLog2Ceil(1u) == 0u, "");
87 static_assert(ConstexprLog2Ceil(0xFFFFFFFFu) == 32u, "");
88 static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)) == 64u, "");
89
90 // Test boundary between two logs
91 ASSERT_EQ(Log2Ceil(0x80000001u), 32u);
92 ASSERT_EQ(Log2Ceil(0x80000000u), 31u);
93 ASSERT_EQ(Log2Ceil(0x7FFFFFFFu), 31u);
94 ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0x8000000000000001)), 64u);
95 ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0x8000000000000000)), 63u);
96 ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)), 63u);
97
98 static_assert(ConstexprLog2Ceil(0x80000001u) == 32u, "");
99 static_assert(ConstexprLog2Ceil(0x80000000u) == 31u, "");
100 static_assert(ConstexprLog2Ceil(0x7FFFFFFFu) == 31u, "");
101 static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0x8000000000000001)) == 64u, "");
102 static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0x8000000000000000)) == 63u, "");
103 static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)) == 63u, "");
104
105 ASSERT_EQ(Log2Ceil(17u), 5u);
106 ASSERT_EQ(Log2Ceil(16u), 4u);
107 ASSERT_EQ(Log2Ceil(15u), 4u);
108
109 static_assert(ConstexprLog2Ceil(17u) == 5u, "");
110 static_assert(ConstexprLog2Ceil(16u) == 4u, "");
111 static_assert(ConstexprLog2Ceil(15u) == 4u, "");
112 }
113
114 // Tests for IsPowerOfTwo
TEST(Math,IsPowerOfTwo)115 TEST(Math, IsPowerOfTwo) {
116 ASSERT_TRUE(IsPowerOfTwo(1));
117 ASSERT_TRUE(IsPowerOfTwo(2));
118 ASSERT_FALSE(IsPowerOfTwo(3));
119
120 ASSERT_TRUE(IsPowerOfTwo(0x8000000));
121 ASSERT_FALSE(IsPowerOfTwo(0x8000400));
122 }
123
124 // Tests for NextPowerOfTwo
TEST(Math,NextPowerOfTwo)125 TEST(Math, NextPowerOfTwo) {
126 // Test extrema
127 ASSERT_EQ(NextPowerOfTwo(0), 1ull);
128 ASSERT_EQ(NextPowerOfTwo(0x7FFFFFFFFFFFFFFF), 0x8000000000000000);
129
130 // Test boundary between powers-of-two.
131 ASSERT_EQ(NextPowerOfTwo(31), 32ull);
132 ASSERT_EQ(NextPowerOfTwo(33), 64ull);
133
134 ASSERT_EQ(NextPowerOfTwo(32), 32ull);
135 }
136
137 // Tests for AlignPtr
TEST(Math,AlignPtr)138 TEST(Math, AlignPtr) {
139 constexpr size_t kTestAlignment = 8;
140
141 char buffer[kTestAlignment * 4];
142
143 for (size_t i = 0; i < 2 * kTestAlignment; ++i) {
144 char* unaligned = &buffer[i];
145 char* aligned = AlignPtr(unaligned, kTestAlignment);
146
147 ASSERT_GE(aligned - unaligned, 0);
148 ASSERT_LT(static_cast<size_t>(aligned - unaligned), kTestAlignment);
149 ASSERT_EQ(reinterpret_cast<uintptr_t>(aligned) & (kTestAlignment - 1), 0u);
150 }
151 }
152
153 // Tests for Align
TEST(Math,Align)154 TEST(Math, Align) {
155 // 0 aligns to 0
156 ASSERT_EQ(Align(0u, 4), 0u);
157 ASSERT_EQ(Align(0u, 256), 0u);
158 ASSERT_EQ(Align(0u, 512), 0u);
159
160 // Multiples align to self
161 ASSERT_EQ(Align(8u, 8), 8u);
162 ASSERT_EQ(Align(16u, 8), 16u);
163 ASSERT_EQ(Align(24u, 8), 24u);
164 ASSERT_EQ(Align(256u, 256), 256u);
165 ASSERT_EQ(Align(512u, 256), 512u);
166 ASSERT_EQ(Align(768u, 256), 768u);
167
168 // Alignment with 1 is self
169 for (uint32_t i = 0; i < 128; ++i) {
170 ASSERT_EQ(Align(i, 1), i);
171 }
172
173 // Everything in the range (align, 2*align] aligns to 2*align
174 for (uint32_t i = 1; i <= 64; ++i) {
175 ASSERT_EQ(Align(64 + i, 64), 128u);
176 }
177
178 // Test extrema
179 ASSERT_EQ(Align(static_cast<uint64_t>(0xFFFFFFFF), 4), 0x100000000u);
180 ASSERT_EQ(Align(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF), 1), 0xFFFFFFFFFFFFFFFFull);
181 }
182
183 // Tests for IsPtrAligned
TEST(Math,IsPtrAligned)184 TEST(Math, IsPtrAligned) {
185 constexpr size_t kTestAlignment = 8;
186
187 char buffer[kTestAlignment * 4];
188
189 for (size_t i = 0; i < 2 * kTestAlignment; ++i) {
190 char* unaligned = &buffer[i];
191 char* aligned = AlignPtr(unaligned, kTestAlignment);
192
193 ASSERT_EQ(IsPtrAligned(unaligned, kTestAlignment), unaligned == aligned);
194 }
195 }
196
197 // Tests for IsAligned
TEST(Math,IsAligned)198 TEST(Math, IsAligned) {
199 // 0 is aligned
200 ASSERT_TRUE(IsAligned(0, 4));
201 ASSERT_TRUE(IsAligned(0, 256));
202 ASSERT_TRUE(IsAligned(0, 512));
203
204 // Multiples are aligned
205 ASSERT_TRUE(IsAligned(8, 8));
206 ASSERT_TRUE(IsAligned(16, 8));
207 ASSERT_TRUE(IsAligned(24, 8));
208 ASSERT_TRUE(IsAligned(256, 256));
209 ASSERT_TRUE(IsAligned(512, 256));
210 ASSERT_TRUE(IsAligned(768, 256));
211
212 // Alignment with 1 is always aligned
213 for (uint32_t i = 0; i < 128; ++i) {
214 ASSERT_TRUE(IsAligned(i, 1));
215 }
216
217 // Everything in the range (align, 2*align) is not aligned
218 for (uint32_t i = 1; i < 64; ++i) {
219 ASSERT_FALSE(IsAligned(64 + i, 64));
220 }
221 }
222
223 // Tests for float32 to float16 conversion
TEST(Math,Float32ToFloat16)224 TEST(Math, Float32ToFloat16) {
225 ASSERT_EQ(Float32ToFloat16(0.0f), 0x0000);
226 ASSERT_EQ(Float32ToFloat16(-0.0f), 0x8000);
227
228 ASSERT_EQ(Float32ToFloat16(INFINITY), 0x7C00);
229 ASSERT_EQ(Float32ToFloat16(-INFINITY), 0xFC00);
230
231 // Check that NaN is converted to a value in one of the float16 NaN ranges
232 uint16_t nan16 = Float32ToFloat16(NAN);
233 ASSERT_TRUE(nan16 > 0xFC00 || (nan16 < 0x8000 && nan16 > 0x7C00));
234
235 ASSERT_EQ(Float32ToFloat16(1.0f), 0x3C00);
236 }
237
238 // Tests for IsFloat16NaN
TEST(Math,IsFloat16NaN)239 TEST(Math, IsFloat16NaN) {
240 ASSERT_FALSE(IsFloat16NaN(0u));
241 ASSERT_FALSE(IsFloat16NaN(0u));
242 ASSERT_FALSE(IsFloat16NaN(Float32ToFloat16(1.0f)));
243 ASSERT_FALSE(IsFloat16NaN(Float32ToFloat16(INFINITY)));
244 ASSERT_FALSE(IsFloat16NaN(Float32ToFloat16(-INFINITY)));
245
246 ASSERT_TRUE(IsFloat16NaN(Float32ToFloat16(INFINITY) + 1));
247 ASSERT_TRUE(IsFloat16NaN(Float32ToFloat16(-INFINITY) + 1));
248 ASSERT_TRUE(IsFloat16NaN(0x7FFF));
249 ASSERT_TRUE(IsFloat16NaN(0xFFFF));
250 }
251
252 // Tests for SRGBToLinear
TEST(Math,SRGBToLinear)253 TEST(Math, SRGBToLinear) {
254 ASSERT_EQ(SRGBToLinear(0.0f), 0.0f);
255 ASSERT_EQ(SRGBToLinear(1.0f), 1.0f);
256
257 ASSERT_EQ(SRGBToLinear(-1.0f), 0.0f);
258 ASSERT_EQ(SRGBToLinear(2.0f), 1.0f);
259
260 ASSERT_FLOAT_EQ(SRGBToLinear(0.5f), 0.21404114f);
261 }
262
263 // Tests for RoundUp
TEST(Math,RoundUp)264 TEST(Math, RoundUp) {
265 ASSERT_EQ(RoundUp(2, 2), 2u);
266 ASSERT_EQ(RoundUp(2, 4), 4u);
267 ASSERT_EQ(RoundUp(6, 2), 6u);
268 ASSERT_EQ(RoundUp(8, 4), 8u);
269 ASSERT_EQ(RoundUp(12, 6), 12u);
270
271 ASSERT_EQ(RoundUp(3, 3), 3u);
272 ASSERT_EQ(RoundUp(3, 5), 5u);
273 ASSERT_EQ(RoundUp(5, 3), 6u);
274 ASSERT_EQ(RoundUp(9, 5), 10u);
275
276 // Test extrema
277 ASSERT_EQ(RoundUp(0x7FFFFFFFFFFFFFFFull, 0x8000000000000000ull), 0x8000000000000000ull);
278 ASSERT_EQ(RoundUp(1, 1), 1u);
279 }
280
281 // Tests for IsSubset
TEST(Math,IsSubset)282 TEST(Math, IsSubset) {
283 // single value is a subset
284 ASSERT_TRUE(IsSubset(0b100, 0b101));
285 ASSERT_FALSE(IsSubset(0b010, 0b101));
286 ASSERT_TRUE(IsSubset(0b001, 0b101));
287
288 // empty set is a subset
289 ASSERT_TRUE(IsSubset(0b000, 0b101));
290
291 // equal-to is a subset
292 ASSERT_TRUE(IsSubset(0b101, 0b101));
293
294 // superset is not a subset
295 ASSERT_FALSE(IsSubset(0b111, 0b101));
296
297 // only empty is a subset of empty
298 ASSERT_FALSE(IsSubset(0b100, 0b000));
299 ASSERT_FALSE(IsSubset(0b010, 0b000));
300 ASSERT_FALSE(IsSubset(0b001, 0b000));
301 ASSERT_TRUE(IsSubset(0b000, 0b000));
302
303 // Test with enums
304 ASSERT_TRUE(IsSubset(wgpu::TestEnum::A, wgpu::TestEnum::A));
305 ASSERT_TRUE(IsSubset(wgpu::TestEnum::A, wgpu::TestEnum::A | wgpu::TestEnum::B));
306 ASSERT_FALSE(IsSubset(wgpu::TestEnum::C, wgpu::TestEnum::A | wgpu::TestEnum::B));
307 ASSERT_FALSE(IsSubset(wgpu::TestEnum::A | wgpu::TestEnum::C, wgpu::TestEnum::A));
308 }
309