Merge branch 'develop' into optimize_jenkinsfile

test/verify/test_cos.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_cos : verify_program<test_cos>
+template <migraphx::shape::type_t DType>
+struct test_cos : verify_program<test_cos<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {8}};
+        migraphx::shape s{DType, {8}};
         auto x = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("cos"), x);
         return p;
     }
 };
+
+template struct test_cos<migraphx::shape::float_type>;
+template struct test_cos<migraphx::shape::half_type>;
+template struct test_cos<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_cosh.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_cosh : verify_program<test_cosh>
+template <migraphx::shape::type_t DType>
+struct test_cosh : verify_program<test_cosh<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {16}};
+        migraphx::shape s{DType, {16}};
         auto x = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("cosh"), x);
         return p;
     }
 };
+
+template struct test_cosh<migraphx::shape::float_type>;
+template struct test_cosh<migraphx::shape::half_type>;
+template struct test_cosh<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_erf.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_erf : verify_program<test_erf>
+template <migraphx::shape::type_t DType>
+struct test_erf : verify_program<test_erf<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {2, 3, 4, 6}};
+        migraphx::shape s{DType, {2, 3, 4, 6}};
         auto param = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("erf"), param);
         return p;
     }
 };
+
+template struct test_erf<migraphx::shape::float_type>;
+template struct test_erf<migraphx::shape::half_type>;
+template struct test_erf<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_exp.cpp

@@ -27,15 +27,20 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_exp : verify_program<test_exp>
+template <migraphx::shape::type_t DType>
+struct test_exp : verify_program<test_exp<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {6}};
+        migraphx::shape s{DType, {6}};
         auto x = mm->add_instruction(migraphx::make_op("abs"), mm->add_parameter("x", s));
         mm->add_instruction(migraphx::make_op("exp"), x);
         return p;
     }
 };
+
+template struct test_exp<migraphx::shape::float_type>;
+template struct test_exp<migraphx::shape::half_type>;
+template struct test_exp<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_floor.cpp

@@ -27,16 +27,21 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_floor : verify_program<test_floor>
+template <migraphx::shape::type_t DType>
+struct test_floor : verify_program<test_floor<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
 
-        migraphx::shape s{migraphx::shape::float_type, {2, 3, 4, 6}};
+        migraphx::shape s{DType, {2, 3, 4, 6}};
         auto param = mm->add_parameter("x", s);
         mm->add_instruction(migraphx::make_op("floor"), param);
         return p;
     };
 };
+
+template struct test_floor<migraphx::shape::float_type>;
+template struct test_floor<migraphx::shape::half_type>;
+template struct test_floor<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_fmod_mod.cpp

@@ -34,40 +34,52 @@
     Adding this because HIP fmod sign changes when y = 0 resulting in nan and -nan not beign
    consistent between ref and gpu implementations.
 */
-migraphx::instruction_ref add_epsilon(migraphx::module& m, migraphx::instruction_ref y)
+migraphx::instruction_ref add_epsilon(migraphx::module& m,
+                                      migraphx::instruction_ref y,
+                                      migraphx::shape::type_t dtype = migraphx::shape::float_type)
 {
-    auto zero = m.add_literal(0.0f);
-    auto eps  = m.add_literal(1e-3f);
+    auto zero = m.add_literal(migraphx::literal{migraphx::shape{dtype}, {0.0f}});
+    auto eps  = m.add_literal(migraphx::literal{migraphx::shape{dtype}, {1e-3f}});
     auto op_y = add_common_op(m, migraphx::make_op("equal"), {y, zero});
     return add_common_op(m, migraphx::make_op("where"), {op_y, eps, y});
 }
 
-struct test_fmod : verify_program<test_fmod>
+template <migraphx::shape::type_t DType>
+struct test_fmod : verify_program<test_fmod<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {64}};
+        migraphx::shape s{DType, {64}};
         auto x        = mm->add_parameter("x", s);
         auto y        = mm->add_parameter("y", s);
-        auto op_where = add_epsilon(*mm, y);
+        auto op_where = add_epsilon(*mm, y, DType);
         mm->add_instruction(migraphx::make_op("fmod"), x, op_where);
         return p;
     }
 };
+template struct test_fmod<migraphx::shape::float_type>;
+template struct test_fmod<migraphx::shape::half_type>;
+template struct test_fmod<migraphx::shape::fp8e4m3fnuz_type>;
 
-struct test_mod : verify_program<test_mod>
+template <migraphx::shape::type_t DType>
+struct test_mod : verify_program<test_mod<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {64}};
+        migraphx::shape s{DType, {64}};
         auto x        = mm->add_parameter("x", s);
         auto y        = mm->add_parameter("y", s);
-        auto op_where = add_epsilon(*mm, y);
+        auto op_where = add_epsilon(*mm, y, DType);
         mm->add_instruction(migraphx::make_op("mod"), x, op_where);
         return p;
     }
 };
+
+template struct test_mod<migraphx::shape::float_type>;
+// TODO: Fix half type test
+// template struct test_mod<migraphx::shape::half_type>;
+template struct test_mod<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gather.cpp

@@ -27,14 +27,14 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-template <int Axis>
-struct test_gather : verify_program<test_gather<Axis>>
+template <int Axis, migraphx::shape::type_t DType>
+struct test_gather : verify_program<test_gather<Axis, DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape s{migraphx::shape::float_type, {3, 3}};
+        migraphx::shape s{DType, {3, 3}};
         migraphx::shape s_indices{migraphx::shape::int32_type, {2, 2}};
         std::vector<int> indices{1, 2, 2, 1};
         auto a0  = mm->add_parameter("data", s);
@@ -46,6 +46,10 @@ struct test_gather : verify_program<test_gather<Axis>>
 };
 
 // Standard gather test
-template struct test_gather<0>;
+template struct test_gather<0, migraphx::shape::float_type>;
+template struct test_gather<0, migraphx::shape::half_type>;
+template struct test_gather<0, migraphx::shape::fp8e4m3fnuz_type>;
 // Test Negative axis
-template struct test_gather<-2>;
+template struct test_gather<-2, migraphx::shape::float_type>;
+template struct test_gather<-2, migraphx::shape::half_type>;
+template struct test_gather<-2, migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gathernd_default.cpp

@@ -26,13 +26,14 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gathernd_default : verify_program<test_gathernd_default>
+template <migraphx::shape::type_t DType>
+struct test_gathernd_default : verify_program<test_gathernd_default<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape ds{migraphx::shape::float_type, {2, 2}};
+        migraphx::shape ds{DType, {2, 2}};
         migraphx::shape is{migraphx::shape::int64_type, {2, 2}};
         std::vector<int64_t> indices{0, 0, 1, 1};
         auto a0 = mm->add_parameter("data", ds);
@@ -41,3 +42,7 @@ struct test_gathernd_default : verify_program<test_gathernd_default>
         return p;
     }
 };
+
+template struct test_gathernd_default<migraphx::shape::float_type>;
+template struct test_gathernd_default<migraphx::shape::half_type>;
+template struct test_gathernd_default<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm.cpp

@@ -26,16 +26,20 @@
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
-
-struct test_gemm : verify_program<test_gemm>
+template <migraphx::shape::type_t DType>
+struct test_gemm : verify_program<test_gemm<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {4, 5}});
-        auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {5, 3}});
+        auto a   = mm->add_parameter("a", migraphx::shape{DType, {4, 5}});
+        auto b   = mm->add_parameter("b", migraphx::shape{DType, {5, 3}});
         mm->add_instruction(migraphx::make_op("dot"), a, b);
         return p;
     }
 };
+
+template struct test_gemm<migraphx::shape::float_type>;
+template struct test_gemm<migraphx::shape::half_type>;
+template struct test_gemm<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm_copy.cpp

@@ -28,15 +28,16 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gemm_copy : verify_program<test_gemm_copy>
+template <migraphx::shape::type_t DType>
+struct test_gemm_copy : verify_program<test_gemm_copy<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        migraphx::shape sa{migraphx::shape::float_type, {2, 16}};
-        migraphx::shape sb{migraphx::shape::float_type, {16, 8}};
-        migraphx::shape sc{migraphx::shape::float_type, {1, 8}};
+        migraphx::shape sa{DType, {2, 16}};
+        migraphx::shape sb{DType, {16, 8}};
+        migraphx::shape sc{DType, {1, 8}};
         auto pa = mm->add_parameter("a", sa);
         auto pb = mm->add_parameter("b", sb);
         auto pc = mm->add_parameter("c", sc);
@@ -46,3 +47,7 @@ struct test_gemm_copy : verify_program<test_gemm_copy>
         return p;
     }
 };
+
+template struct test_gemm_copy<migraphx::shape::float_type>;
+template struct test_gemm_copy<migraphx::shape::half_type>;
+template struct test_gemm_copy<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm_ex.cpp

@@ -27,15 +27,19 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gemm_ex : verify_program<test_gemm_ex>
+template <migraphx::shape::type_t DType>
+struct test_gemm_ex : verify_program<test_gemm_ex<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto a = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {1, 1, 4, 5}});
-        auto b = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 3}});
+        auto a   = mm->add_parameter("a", migraphx::shape{DType, {1, 1, 4, 5}});
+        auto b   = mm->add_parameter("b", migraphx::shape{DType, {1, 1, 5, 3}});
         mm->add_instruction(migraphx::make_op("dot"), a, b);
         return p;
     }
 };
+template struct test_gemm_ex<migraphx::shape::float_type>;
+template struct test_gemm_ex<migraphx::shape::half_type>;
+template struct test_gemm_ex<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm_transposea.cpp

@@ -27,16 +27,21 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gemm_transposea : verify_program<test_gemm_transposea>
+template <migraphx::shape::type_t DType>
+struct test_gemm_transposea : verify_program<test_gemm_transposea<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {5, 4}});
-        auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {5, 3}});
+        auto a   = mm->add_parameter("a", migraphx::shape{DType, {5, 4}});
+        auto b   = mm->add_parameter("b", migraphx::shape{DType, {5, 3}});
         auto at = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), a);
         mm->add_instruction(migraphx::make_op("dot"), at, b);
         return p;
     }
 };
+
+template struct test_gemm_transposea<migraphx::shape::float_type>;
+template struct test_gemm_transposea<migraphx::shape::half_type>;
+template struct test_gemm_transposea<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm_transposea_ex.cpp

@@ -27,17 +27,22 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gemm_transposea_ex : verify_program<test_gemm_transposea_ex>
+template <migraphx::shape::type_t DType>
+struct test_gemm_transposea_ex : verify_program<test_gemm_transposea_ex<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto a = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 4}});
-        auto b = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {1, 1, 5, 3}});
+        auto a   = mm->add_parameter("a", migraphx::shape{DType, {1, 1, 5, 4}});
+        auto b   = mm->add_parameter("b", migraphx::shape{DType, {1, 1, 5, 3}});
         auto at =
             mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 1, 3, 2}}}), a);
         mm->add_instruction(migraphx::make_op("dot"), at, b);
         return p;
     }
 };
+
+template struct test_gemm_transposea_ex<migraphx::shape::float_type>;
+template struct test_gemm_transposea_ex<migraphx::shape::half_type>;
+template struct test_gemm_transposea_ex<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm_transposeab.cpp

@@ -27,17 +27,22 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gemm_transposeab : verify_program<test_gemm_transposeab>
+template <migraphx::shape::type_t DType>
+struct test_gemm_transposeab : verify_program<test_gemm_transposeab<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {5, 4}});
-        auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {3, 5}});
+        auto a   = mm->add_parameter("a", migraphx::shape{DType, {5, 4}});
+        auto b   = mm->add_parameter("b", migraphx::shape{DType, {3, 5}});
         auto at = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), a);
         auto bt = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), b);
         mm->add_instruction(migraphx::make_op("dot"), at, bt);
         return p;
     }
 };
+
+template struct test_gemm_transposeab<migraphx::shape::float_type>;
+template struct test_gemm_transposeab<migraphx::shape::half_type>;
+template struct test_gemm_transposeab<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm_transposeb.cpp

@@ -27,16 +27,21 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gemm_transposeb : verify_program<test_gemm_transposeb>
+template <migraphx::shape::type_t DType>
+struct test_gemm_transposeb : verify_program<test_gemm_transposeb<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {4, 5}});
-        auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {3, 5}});
+        auto a   = mm->add_parameter("a", migraphx::shape{DType, {4, 5}});
+        auto b   = mm->add_parameter("b", migraphx::shape{DType, {3, 5}});
         auto bt = mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {1, 0}}}), b);
         mm->add_instruction(migraphx::make_op("dot"), a, bt);
         return p;
     }
 };
+
+template struct test_gemm_transposeb<migraphx::shape::float_type>;
+template struct test_gemm_transposeb<migraphx::shape::half_type>;
+template struct test_gemm_transposeb<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_gemm_transposeb_ex.cpp

@@ -27,17 +27,22 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_gemm_transposeb_ex : verify_program<test_gemm_transposeb_ex>
+template <migraphx::shape::type_t DType>
+struct test_gemm_transposeb_ex : verify_program<test_gemm_transposeb_ex<DType>>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto a   = mm->add_parameter("a", migraphx::shape{migraphx::shape::float_type, {1, 4, 5}});
-        auto b   = mm->add_parameter("b", migraphx::shape{migraphx::shape::float_type, {1, 3, 5}});
+        auto a   = mm->add_parameter("a", migraphx::shape{DType, {1, 4, 5}});
+        auto b   = mm->add_parameter("b", migraphx::shape{DType, {1, 3, 5}});
         auto bt =
             mm->add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 1}}}), b);
         mm->add_instruction(migraphx::make_op("dot"), a, bt);
         return p;
     }
 };
+
+template struct test_gemm_transposeb_ex<migraphx::shape::float_type>;
+template struct test_gemm_transposeb_ex<migraphx::shape::half_type>;
+template struct test_gemm_transposeb_ex<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_isinf.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <limits>
+#include "verify_program.hpp"
+#include <migraphx/program.hpp>
+#include <migraphx/generate.hpp>
+#include <migraphx/make_op.hpp>
+
+template <class T>
+struct test_isinf : verify_program<test_isinf<T>>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm = p.get_main_module();
+        auto max = std::numeric_limits<T>::max();
+        auto min = std::numeric_limits<T>::min();
+        auto inf = std::numeric_limits<T>::infinity();
+        auto nan = std::numeric_limits<T>::quiet_NaN();
+        auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::get_type<T>(), {5}});
+        std::vector<T> data0{inf, -inf, max, min, nan};
+        migraphx::shape s1{migraphx::shape::get_type<T>(), {5}};
+        auto l0 = mm->add_literal(migraphx::literal{s1, data0});
+        x       = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), x, l0);
+        mm->add_instruction(migraphx::make_op("isinf"), x);
+        return p;
+    }
+};
+
+template struct test_isinf<migraphx::half>;
+template struct test_isinf<float>;

test/verify/test_isnan_half.cpp → test/verify/test_isinf_broadcast.cpp

 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ * Copyright (c) 2015-2023 Advanced Micro Devices, Inc. All rights reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -26,18 +26,23 @@
 #include <migraphx/program.hpp>
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
-#include <migraphx/half.hpp>
 
-struct test_isnan_half : verify_program<test_isnan_half>
+struct test_isinf_broadcast : verify_program<test_isinf_broadcast>
 {
     migraphx::program create_program() const
     {
         migraphx::program p;
         auto* mm = p.get_main_module();
-        auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::half_type, {2}});
-        auto l0  = mm->add_literal(std::numeric_limits<migraphx::half>::quiet_NaN());
+        auto x   = mm->add_parameter("x", migraphx::shape{migraphx::shape::float_type, {2}});
+        auto s0  = migraphx::shape{migraphx::shape::float_type, {2, 2}};
+        x        = mm->add_instruction(
+            migraphx::make_op("broadcast", {{"axis", 0}, {"out_lens", s0.lens()}}), x);
+        auto inf = std::numeric_limits<float>::infinity();
+        std::vector<float> data0{-inf, inf};
+        migraphx::shape s1{migraphx::shape::float_type, {1, 2}};
+        auto l0 = mm->add_literal(migraphx::literal{s1, data0});
         x       = mm->add_instruction(migraphx::make_op("concat", {{"axis", 0}}), x, l0);
-        mm->add_instruction(migraphx::make_op("isnan"), x);
+        mm->add_instruction(migraphx::make_op("isinf"), x);
         return p;
     }
 };

test/verify/test_isnan_float.cpp → test/verify/test_isnan.cpp

@@ -27,7 +27,8 @@
 #include <migraphx/generate.hpp>
 #include <migraphx/make_op.hpp>
 
-struct test_isnan_float : verify_program<test_isnan_float>
+template <migraphx::shape::type_t DType>
+struct test_isnan : verify_program<test_isnan<DType>>
 {
     migraphx::program create_program() const
     {
@@ -40,3 +41,7 @@ struct test_isnan_float : verify_program<test_isnan_float>
         return p;
     }
 };
+
+template struct test_isnan<migraphx::shape::float_type>;
+template struct test_isnan<migraphx::shape::half_type>;
+template struct test_isnan<migraphx::shape::fp8e4m3fnuz_type>;

test/verify/test_layernorm.cpp

@@ -117,6 +117,19 @@ struct test_layernorm_fp16 : verify_program<test_layernorm_fp16>
     }
 };
 
+struct test_layernorm_fp8 : verify_program<test_layernorm_fp8>
+{
+    migraphx::program create_program() const
+    {
+        migraphx::program p;
+        auto* mm                 = p.get_main_module();
+        std::vector<size_t> dims = {1, 24, 64};
+        auto x = mm->add_parameter("x", migraphx::shape{migraphx::shape::fp8e4m3fnuz_type, dims});
+        add_layernorm(*mm, x, dims);
+        return p;
+    }
+};
+
 struct test_layernorm_eps : verify_program<test_layernorm_eps>
 {
     migraphx::program create_program() const