Skip to content

Commit 10fc52f

Browse files
SC llvm teamSC llvm team
SC llvm team
authored and
SC llvm team
committed
Merged main:1ace91f925ad87c3e5eb836ad58fdffe60c4aea6 into amd-gfx:a9dc02e5ed6f
Local branch amd-gfx a9dc02e Merged main:e05c22484efb5c767115525adfa4273e48b1ae26 into amd-gfx:4744f1225122 Remote branch main 1ace91f [libc][math] Add performance tests for fmul and fmull. (llvm#106262)
2 parents a9dc02e + 1ace91f commit 10fc52f

File tree

191 files changed

+3223
-1110
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

191 files changed

+3223
-1110
lines changed

‎clang/lib/CodeGen/CodeGenFunction.cpp

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1064,13 +1064,17 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy,
10641064
// OpenCL C 2.0 v2.2-11 s6.9.i:
10651065
// Recursion is not supported.
10661066
//
1067+
// HLSL
1068+
// Recursion is not supported.
1069+
//
10671070
// SYCL v1.2.1 s3.10:
10681071
// kernels cannot include RTTI information, exception classes,
10691072
// recursive code, virtual functions or make use of C++ libraries that
10701073
// are not compiled for the device.
1071-
if (FD && ((getLangOpts().CPlusPlus && FD->isMain()) ||
1072-
getLangOpts().OpenCL || getLangOpts().SYCLIsDevice ||
1073-
(getLangOpts().CUDA && FD->hasAttr<CUDAGlobalAttr>())))
1074+
if (FD &&
1075+
((getLangOpts().CPlusPlus && FD->isMain()) || getLangOpts().OpenCL ||
1076+
getLangOpts().HLSL || getLangOpts().SYCLIsDevice ||
1077+
(getLangOpts().CUDA && FD->hasAttr<CUDAGlobalAttr>())))
10741078
Fn->addFnAttr(llvm::Attribute::NoRecurse);
10751079

10761080
llvm::RoundingMode RM = getLangOpts().getDefaultRoundingMode();

‎clang/test/CodeGen/aarch64-targetattr.c

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -191,6 +191,14 @@ __attribute__((target("no-v9.3a")))
191191
//
192192
void minusarch() {}
193193

194+
__attribute__((target("cpu=apple-m4")))
195+
// CHECK-LABEL: define {{[^@]+}}@applem4
196+
// CHECK-SAME: () #[[ATTR18:[0-9]+]] {
197+
// CHECK-NEXT: entry:
198+
// CHECK-NEXT: ret void
199+
//
200+
void applem4() {}
201+
194202
//.
195203
// CHECK: attributes #[[ATTR0]] = { noinline nounwind optnone "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+crc,+fp-armv8,+lse,+neon,+ras,+rdm,+v8.1a,+v8.2a,+v8a" }
196204
// CHECK: attributes #[[ATTR1]] = { noinline nounwind optnone "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+crc,+fp-armv8,+fullfp16,+lse,+neon,+ras,+rdm,+sve,+v8.1a,+v8.2a,+v8a" }
@@ -210,6 +218,7 @@ void minusarch() {}
210218
// CHECK: attributes #[[ATTR15]] = { noinline nounwind optnone "branch-target-enforcement" "guarded-control-stack" "no-trapping-math"="true" "sign-return-address"="non-leaf" "sign-return-address-key"="a_key" "stack-protector-buffer-size"="8" "target-cpu"="neoverse-n1" "target-features"="+aes,+bf16,+bti,+ccidx,+complxnum,+crc,+dit,+dotprod,+flagm,+fp-armv8,+fullfp16,+i8mm,+jsconv,+lse,+neon,+pauth,+perfmon,+predres,+ras,+rcpc,+rdm,+sb,+sha2,+spe,+ssbs,+sve,+sve2,+v8.1a,+v8.2a,+v8.3a,+v8.4a,+v8.5a,+v8.6a,+v8a" "tune-cpu"="cortex-a710" }
211219
// CHECK: attributes #[[ATTR16]] = { noinline nounwind optnone "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
212220
// CHECK: attributes #[[ATTR17]] = { noinline nounwind optnone "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="-v9.3a" }
221+
// CHECK: attributes #[[ATTR18]] = { noinline nounwind optnone "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-cpu"="apple-m4" "target-features"="+aes,+bf16,+bti,+ccidx,+complxnum,+crc,+dit,+dotprod,+flagm,+fp-armv8,+fp16fml,+fpac,+fullfp16,+i8mm,+jsconv,+lse,+neon,+pauth,+perfmon,+predres,+ras,+rcpc,+rdm,+sb,+sha2,+sha3,+sme,+sme-f64f64,+sme-i16i64,+sme2,+ssbs,+v8.1a,+v8.2a,+v8.3a,+v8.4a,+v8.5a,+v8.6a,+v8.7a,+v8a,+wfxt" }
213222
//.
214223
// CHECK: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
215224
// CHECK: [[META1:![0-9]+]] = !{!"{{.*}}clang version {{.*}}"}

‎clang/test/CodeGenHLSL/implicit-norecurse-attrib.hlsl

Lines changed: 93 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,93 @@
1+
// RUN: %clang_cc1 -x hlsl -triple dxil-pc-shadermodel6.3-library -finclude-default-header %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s
2+
// RUN: %clang_cc1 -x hlsl -triple dxil-pc-shadermodel6.0-compute -finclude-default-header %s -emit-llvm -disable-llvm-passes -o - | FileCheck %s
3+
4+
// Verify that a few different function types all get the NoRecurse attribute
5+
6+
#define MAX 100
7+
8+
struct Node {
9+
uint value;
10+
uint key;
11+
uint left, right;
12+
};
13+
14+
// CHECK: Function Attrs:{{.*}}norecurse
15+
// CHECK: define noundef i32 @"?Find@@YAIY0GE@UNode@@I@Z"(ptr noundef byval([100 x %struct.Node]) align 4 %SortedTree, i32 noundef %key) [[IntAttr:\#[0-9]+]]
16+
// CHECK: ret i32
17+
// Find and return value corresponding to key in the SortedTree
18+
uint Find(Node SortedTree[MAX], uint key) {
19+
uint nix = 0; // head
20+
while(true) {
21+
if (nix < 0)
22+
return 0.0; // Not found
23+
Node n = SortedTree[nix];
24+
if (n.key == key)
25+
return n.value;
26+
if (key < n.key)
27+
nix = n.left;
28+
else
29+
nix = n.right;
30+
}
31+
}
32+
33+
// CHECK: Function Attrs:{{.*}}norecurse
34+
// CHECK: define noundef i1 @"?InitTree@@YA_NY0GE@UNode@@V?$RWBuffer@T?$__vector@I$03@__clang@@@hlsl@@I@Z"(ptr noundef byval([100 x %struct.Node]) align 4 %tree, ptr noundef byval(%"class.hlsl::RWBuffer") align 4 %encodedTree, i32 noundef %maxDepth) [[ExtAttr:\#[0-9]+]]
35+
// CHECK: ret i1
36+
// Initialize tree with given buffer
37+
// Imagine the inout works
38+
export
39+
bool InitTree(/*inout*/ Node tree[MAX], RWBuffer<uint4> encodedTree, uint maxDepth) {
40+
uint size = pow(2.f, maxDepth) - 1;
41+
if (size > MAX) return false;
42+
for (uint i = 1; i < size; i++) {
43+
tree[i].value = encodedTree[i].x;
44+
tree[i].key = encodedTree[i].y;
45+
tree[i].left = encodedTree[i].z;
46+
tree[i].right = encodedTree[i].w;
47+
}
48+
return true;
49+
}
50+
51+
RWBuffer<uint4> gTree;
52+
53+
// Mangled entry points are internal
54+
// CHECK: Function Attrs:{{.*}}norecurse
55+
// CHECK: define internal void @"?main@@YAXI@Z"(i32 noundef %GI) [[IntAttr]]
56+
// CHECK: ret void
57+
58+
// Canonical entry points are external and shader attributed
59+
// CHECK: Function Attrs:{{.*}}norecurse
60+
// CHECK: define void @main() [[EntryAttr:\#[0-9]+]]
61+
// CHECK: ret void
62+
63+
[numthreads(1,1,1)]
64+
[shader("compute")]
65+
void main(uint GI : SV_GroupIndex) {
66+
Node haystack[MAX];
67+
uint needle = 0;
68+
if (InitTree(haystack, gTree, GI))
69+
needle = Find(haystack, needle);
70+
}
71+
72+
// Mangled entry points are internal
73+
// CHECK: Function Attrs:{{.*}}norecurse
74+
// CHECK: define internal void @"?defaultMain@@YAXXZ"() [[IntAttr]]
75+
// CHECK: ret void
76+
77+
// Canonical entry points are external and shader attributed
78+
// CHECK: Function Attrs:{{.*}}norecurse
79+
// CHECK: define void @defaultMain() [[EntryAttr]]
80+
// CHECK: ret void
81+
82+
[numthreads(1,1,1)]
83+
[shader("compute")]
84+
void defaultMain() {
85+
Node haystack[MAX];
86+
uint needle = 0;
87+
if (InitTree(haystack, gTree, 4))
88+
needle = Find(haystack, needle);
89+
}
90+
91+
// CHECK: attributes [[IntAttr]] = {{.*}} norecurse
92+
// CHECK: attributes [[ExtAttr]] = {{.*}} norecurse
93+
// CHECK: attributes [[EntryAttr]] = {{.*}} norecurse

‎clang/test/CodeGenHLSL/this-assignment-overload.hlsl

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ void main() {
2525
}
2626

2727
// This test makes a probably safe assumption that HLSL 202x includes operator overloading for assignment operators.
28-
// CHECK: define linkonce_odr noundef i32 @"?getFirst@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #2 align 2 {
28+
// CHECK: define linkonce_odr noundef i32 @"?getFirst@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #0 align 2 {
2929
// CHECK-NEXT:entry:
3030
// CHECK-NEXT:%this.addr = alloca ptr, align 4
3131
// CHECK-NEXT:%Another = alloca %struct.Pair, align 4
@@ -42,7 +42,7 @@ void main() {
4242
// CHECK-NEXT:%0 = load i32, ptr %First2, align 4
4343
// CHECK-NEXT:ret i32 %0
4444

45-
// CHECK: define linkonce_odr noundef i32 @"?getSecond@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #2 align 2 {
45+
// CHECK: define linkonce_odr noundef i32 @"?getSecond@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #0 align 2 {
4646
// CHECK-NEXT:entry:
4747
// CHECK-NEXT:%this.addr = alloca ptr, align 4
4848
// CHECK-NEXT:%agg.tmp = alloca %struct.Pair, align 4

‎clang/test/CodeGenHLSL/this-assignment.hlsl

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ void main() {
2424
}
2525

2626
// This tests reference like implicit this in HLSL
27-
// CHECK: define linkonce_odr noundef i32 @"?getFirst@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #3 align 2 {
27+
// CHECK: define linkonce_odr noundef i32 @"?getFirst@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #0 align 2 {
2828
// CHECK-NEXT:entry:
2929
// CHECK-NEXT:%this.addr = alloca ptr, align 4
3030
// CHECK-NEXT:%Another = alloca %struct.Pair, align 4
@@ -34,7 +34,7 @@ void main() {
3434
// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 4 %this1, ptr align 4 %Another, i32 8, i1 false)
3535
// CHECK-NEXT:%First = getelementptr inbounds nuw %struct.Pair, ptr %this1, i32 0, i32 0
3636

37-
// CHECK: define linkonce_odr noundef i32 @"?getSecond@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #3 align 2 {
37+
// CHECK: define linkonce_odr noundef i32 @"?getSecond@Pair@@QAAHXZ"(ptr noundef nonnull align 4 dereferenceable(8) %this) #0 align 2 {
3838
// CHECK-NEXT:entry:
3939
// CHECK-NEXT:%this.addr = alloca ptr, align 4
4040
// CHECK-NEXT:%ref.tmp = alloca %struct.Pair, align 4

‎libc/test/src/math/performance_testing/BinaryOpSingleOutputPerf.h

Lines changed: 28 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -16,15 +16,15 @@
1616

1717
namespace LIBC_NAMESPACE_DECL {
1818
namespace testing {
19-
20-
template <typename T> class BinaryOpSingleOutputPerf {
21-
using FPBits = fputil::FPBits<T>;
19+
template <typename OutputType, typename InputType>
20+
class BinaryOpSingleOutputPerf {
21+
using FPBits = fputil::FPBits<OutputType>;
2222
using StorageType = typename FPBits::StorageType;
2323
static constexpr StorageType UIntMax =
2424
cpp::numeric_limits<StorageType>::max();
2525

2626
public:
27-
typedef T Func(T, T);
27+
typedef OutputType Func(InputType, InputType);
2828

2929
static void run_perf_in_range(Func myFunc, Func otherFunc,
3030
StorageType startingBit, StorageType endingBit,
@@ -33,7 +33,7 @@ template <typename T> class BinaryOpSingleOutputPerf {
3333
N = cpp::min(N, static_cast<size_t>(endingBit - startingBit));
3434

3535
auto runner = [=](Func func) {
36-
[[maybe_unused]] volatile T result;
36+
[[maybe_unused]] volatile OutputType result;
3737
if (endingBit < startingBit) {
3838
return;
3939
}
@@ -42,8 +42,8 @@ template <typename T> class BinaryOpSingleOutputPerf {
4242
for (size_t i = 0; i < rounds; i++) {
4343
for (StorageType bitsX = startingBit, bitsY = endingBit;;
4444
bitsX += step, bitsY -= step) {
45-
T x = FPBits(bitsX).get_val();
46-
T y = FPBits(bitsY).get_val();
45+
InputType x = FPBits(bitsX).get_val();
46+
InputType y = FPBits(bitsY).get_val();
4747
result = func(x, y);
4848
if (endingBit - bitsX < step) {
4949
break;
@@ -94,10 +94,11 @@ template <typename T> class BinaryOpSingleOutputPerf {
9494
1'000'001, rounds, log);
9595
log << "\n Performance tests with inputs in normal range with exponents "
9696
"close to each other:\n";
97-
run_perf_in_range(myFunc, otherFunc,
98-
/* startingBit= */ FPBits(T(0x1.0p-10)).uintval(),
99-
/* endingBit= */ FPBits(T(0x1.0p+10)).uintval(),
100-
1'000'001, rounds, log);
97+
run_perf_in_range(
98+
myFunc, otherFunc,
99+
/* startingBit= */ FPBits(OutputType(0x1.0p-10)).uintval(),
100+
/* endingBit= */ FPBits(OutputType(0x1.0p+10)).uintval(), 1'000'001,
101+
rounds, log);
101102
}
102103

103104
static void run_diff(Func myFunc, Func otherFunc, const char *logFile) {
@@ -115,8 +116,10 @@ template <typename T> class BinaryOpSingleOutputPerf {
115116
log << "\n Diff tests with inputs in normal range with exponents "
116117
"close to each other:\n";
117118
diffCount += run_diff_in_range(
118-
myFunc, otherFunc, /* startingBit= */ FPBits(T(0x1.0p-10)).uintval(),
119-
/* endingBit= */ FPBits(T(0x1.0p+10)).uintval(), 10'000'001, log);
119+
myFunc, otherFunc,
120+
/* startingBit= */ FPBits(OutputType(0x1.0p-10)).uintval(),
121+
/* endingBit= */ FPBits(OutputType(0x1.0p+10)).uintval(), 10'000'001,
122+
log);
120123

121124
log << "Total number of differing results: " << diffCount << '\n';
122125
}
@@ -125,18 +128,21 @@ template <typename T> class BinaryOpSingleOutputPerf {
125128
} // namespace testing
126129
} // namespace LIBC_NAMESPACE_DECL
127130

128-
#define BINARY_OP_SINGLE_OUTPUT_PERF(T, myFunc, otherFunc, filename) \
131+
#define BINARY_OP_SINGLE_OUTPUT_PERF(OutputType, InputType, myFunc, otherFunc, \
132+
filename) \
129133
int main() { \
130-
LIBC_NAMESPACE::testing::BinaryOpSingleOutputPerf<T>::run_perf( \
131-
&myFunc, &otherFunc, 1, filename); \
134+
LIBC_NAMESPACE::testing::BinaryOpSingleOutputPerf< \
135+
OutputType, InputType>::run_perf(&myFunc, &otherFunc, 1, filename); \
132136
return 0; \
133137
}
134138

135-
#define BINARY_OP_SINGLE_OUTPUT_PERF_EX(T, myFunc, otherFunc, rounds, \
136-
filename) \
139+
#define BINARY_OP_SINGLE_OUTPUT_PERF_EX(OutputType, InputType, myFunc, \
140+
otherFunc, rounds, filename) \
137141
{ \
138-
LIBC_NAMESPACE::testing::BinaryOpSingleOutputPerf<T>::run_perf( \
139-
&myFunc, &otherFunc, rounds, filename); \
140-
LIBC_NAMESPACE::testing::BinaryOpSingleOutputPerf<T>::run_perf( \
141-
&myFunc, &otherFunc, rounds, filename); \
142+
LIBC_NAMESPACE::testing::BinaryOpSingleOutputPerf< \
143+
OutputType, InputType>::run_perf(&myFunc, &otherFunc, rounds, \
144+
filename); \
145+
LIBC_NAMESPACE::testing::BinaryOpSingleOutputPerf< \
146+
OutputType, InputType>::run_perf(&myFunc, &otherFunc, rounds, \
147+
filename); \
142148
}

‎libc/test/src/math/performance_testing/CMakeLists.txt

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -476,3 +476,25 @@ add_perf_binary(
476476
COMPILE_OPTIONS
477477
-fno-builtin
478478
)
479+
480+
add_perf_binary(
481+
fmul_perf
482+
SRCS
483+
fmul_perf.cpp
484+
DEPENDS
485+
.binary_op_single_output_diff
486+
libc.src.math.fmul
487+
COMPILE_OPTIONS
488+
-fno-builtin
489+
)
490+
491+
add_perf_binary(
492+
fmull_perf
493+
SRCS
494+
fmull_perf.cpp
495+
DEPENDS
496+
.binary_op_single_output_diff
497+
libc.src.math.fmull
498+
COMPILE_OPTIONS
499+
-fno-builtin
500+
)

‎libc/test/src/math/performance_testing/fmod_perf.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,5 +12,5 @@
1212

1313
#include <math.h>
1414

15-
BINARY_OP_SINGLE_OUTPUT_PERF(double, LIBC_NAMESPACE::fmod, ::fmod,
15+
BINARY_OP_SINGLE_OUTPUT_PERF(double, double, LIBC_NAMESPACE::fmod, ::fmod,
1616
"fmod_perf.log")

‎libc/test/src/math/performance_testing/fmodf16_perf.cpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,11 +16,11 @@
1616
#define FMOD_FUNC(U) (LIBC_NAMESPACE::fputil::generic::FMod<float16, U>::eval)
1717

1818
int main() {
19-
BINARY_OP_SINGLE_OUTPUT_PERF_EX(float16, FMOD_FUNC(uint16_t),
19+
BINARY_OP_SINGLE_OUTPUT_PERF_EX(float16, float16, FMOD_FUNC(uint16_t),
2020
FMOD_FUNC(uint32_t), 5000,
2121
"fmodf16_u16_vs_u32_perf.log")
2222

23-
BINARY_OP_SINGLE_OUTPUT_PERF_EX(float16, FMOD_FUNC(uint16_t),
23+
BINARY_OP_SINGLE_OUTPUT_PERF_EX(float16, float16, FMOD_FUNC(uint16_t),
2424
FMOD_FUNC(uint64_t), 5000,
2525
"fmodf16_u16_vs_u64_perf.log")
2626
return 0;

‎libc/test/src/math/performance_testing/fmodf_perf.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,5 +12,5 @@
1212

1313
#include <math.h>
1414

15-
BINARY_OP_SINGLE_OUTPUT_PERF(float, LIBC_NAMESPACE::fmodf, ::fmodf,
15+
BINARY_OP_SINGLE_OUTPUT_PERF(float, float, LIBC_NAMESPACE::fmodf, ::fmodf,
1616
"fmodf_perf.log")

‎libc/test/src/math/performance_testing/fmul_perf.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
//===-- Performance test for the fmul function ----------------------------===//
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 "BinaryOpSingleOutputPerf.h"
10+
#include "src/math/fmul.h"
11+
12+
static constexpr size_t DOUBLE_ROUNDS = 40;
13+
14+
float fmul_placeholder_binary(double x, double y) {
15+
return static_cast<float>(x * y);
16+
}
17+
18+
int main() {
19+
BINARY_OP_SINGLE_OUTPUT_PERF_EX(float, double, LIBC_NAMESPACE::fmul,
20+
fmul_placeholder_binary, DOUBLE_ROUNDS,
21+
"fmul_perf.log")
22+
return 0;
23+
}

‎libc/test/src/math/performance_testing/fmull_perf.cpp

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
//===-- Performance test for the fmull function ---------------------------===//
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 "BinaryOpSingleOutputPerf.h"
10+
#include "src/math/fmull.h"
11+
12+
static constexpr size_t LONG_DOUBLE_ROUNDS = 40;
13+
14+
float fmull_placeholder_binary(long double x, long double y) {
15+
return static_cast<float>(x * y);
16+
}
17+
18+
int main() {
19+
BINARY_OP_SINGLE_OUTPUT_PERF_EX(float, long double, LIBC_NAMESPACE::fmull,
20+
fmull_placeholder_binary, LONG_DOUBLE_ROUNDS,
21+
"fmull_perf.log")
22+
return 0;
23+
}

‎libc/test/src/math/performance_testing/hypot_perf.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,5 +12,5 @@
1212

1313
#include <math.h>
1414

15-
BINARY_OP_SINGLE_OUTPUT_PERF(double, LIBC_NAMESPACE::hypot, ::hypot,
15+
BINARY_OP_SINGLE_OUTPUT_PERF(double, double, LIBC_NAMESPACE::hypot, ::hypot,
1616
"hypot_perf.log")

‎libc/test/src/math/performance_testing/hypotf_perf.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -12,5 +12,5 @@
1212

1313
#include <math.h>
1414

15-
BINARY_OP_SINGLE_OUTPUT_PERF(float, LIBC_NAMESPACE::hypotf, ::hypotf,
15+
BINARY_OP_SINGLE_OUTPUT_PERF(float, float, LIBC_NAMESPACE::hypotf, ::hypotf,
1616
"hypotf_perf.log")

0 commit comments

Comments
 (0)