maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/unittests/Analysis/VectorUtilsTest.cpp

713 lines
27 KiB
C++
Raw Blame History

//===- VectorUtilsTest.cpp - VectorUtils tests ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/VectorUtils.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/AsmParser/Parser.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/NoFolder.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/SourceMgr.h"
#include "llvm/Support/KnownBits.h"
#include "gtest/gtest.h"
using namespace llvm;
namespace {
class VectorUtilsTest : public testing::Test {
protected:
void parseAssembly(const char *Assembly) {
SMDiagnostic Error;
M = parseAssemblyString(Assembly, Error, Context);
std::string errMsg;
raw_string_ostream os(errMsg);
Error.print("", os);
// A failure here means that the test itself is buggy.
if (!M)
report_fatal_error(os.str());
Function *F = M->getFunction("test");
if (F == nullptr)
report_fatal_error("Test must have a function named @test");
A = nullptr;
for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
if (I->hasName()) {
if (I->getName() == "A")
A = &*I;
}
}
if (A == nullptr)
report_fatal_error("@test must have an instruction %A");
}
LLVMContext Context;
std::unique_ptr<Module> M;
Instruction *A;
};
struct BasicTest : public testing::Test {
LLVMContext Ctx;
std::unique_ptr<Module> M;
Function *F;
BasicBlock *BB;
IRBuilder<NoFolder> IRB;
BasicTest()
: M(new Module("VectorUtils", Ctx)),
F(Function::Create(
FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
Function::ExternalLinkage, "f", M.get())),
BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {}
};
} // namespace
TEST_F(BasicTest, isSplat) {
Value *UndefVec = UndefValue::get(FixedVectorType::get(IRB.getInt8Ty(), 4));
EXPECT_TRUE(isSplatValue(UndefVec));
Constant *UndefScalar = UndefValue::get(IRB.getInt8Ty());
EXPECT_FALSE(isSplatValue(UndefScalar));
Constant *ScalarC = IRB.getInt8(42);
EXPECT_FALSE(isSplatValue(ScalarC));
Constant *OtherScalarC = IRB.getInt8(-42);
Constant *NonSplatC = ConstantVector::get({ScalarC, OtherScalarC});
EXPECT_FALSE(isSplatValue(NonSplatC));
Value *SplatC = IRB.CreateVectorSplat(5, ScalarC);
EXPECT_TRUE(isSplatValue(SplatC));
Value *SplatC_SVE =
IRB.CreateVectorSplat(ElementCount::getScalable(5), ScalarC);
EXPECT_TRUE(isSplatValue(SplatC_SVE));
// FIXME: Constant splat analysis does not allow undef elements.
Constant *SplatWithUndefC = ConstantVector::get({ScalarC, UndefScalar});
EXPECT_FALSE(isSplatValue(SplatWithUndefC));
}
TEST_F(BasicTest, narrowShuffleMaskElts) {
SmallVector<int, 16> ScaledMask;
narrowShuffleMaskElts(1, {3,2,0,-2}, ScaledMask);
EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({3,2,0,-2}));
narrowShuffleMaskElts(4, {3,2,0,-1}, ScaledMask);
EXPECT_EQ(makeArrayRef(ScaledMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}));
}
TEST_F(BasicTest, widenShuffleMaskElts) {
SmallVector<int, 16> WideMask;
SmallVector<int, 16> NarrowMask;
// scale == 1 is a copy
EXPECT_TRUE(widenShuffleMaskElts(1, {3,2,0,-1}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1}));
// back to original mask
narrowShuffleMaskElts(1, makeArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({3,2,0,-1}));
// can't widen non-consecutive 3/2
EXPECT_FALSE(widenShuffleMaskElts(2, {3,2,0,-1}, WideMask));
// can't widen if not evenly divisible
EXPECT_FALSE(widenShuffleMaskElts(2, {0,1,2}, WideMask));
// can always widen identity to single element
EXPECT_TRUE(widenShuffleMaskElts(3, {0,1,2}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({0}));
// back to original mask
narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({0,1,2}));
// groups of 4 must be consecutive/undef
EXPECT_TRUE(widenShuffleMaskElts(4, {12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({3,2,0,-1}));
// back to original mask
narrowShuffleMaskElts(4, makeArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({12,13,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}));
// groups of 2 must be consecutive/undef
EXPECT_FALSE(widenShuffleMaskElts(2, {12,12,14,15,8,9,10,11,0,1,2,3,-1,-1,-1,-1}, WideMask));
// groups of 3 must be consecutive/undef
EXPECT_TRUE(widenShuffleMaskElts(3, {6,7,8,0,1,2,-1,-1,-1}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({2,0,-1}));
// back to original mask
narrowShuffleMaskElts(3, makeArrayRef(WideMask), NarrowMask);
EXPECT_EQ(makeArrayRef(NarrowMask), makeArrayRef({6,7,8,0,1,2,-1,-1,-1}));
// groups of 3 must be consecutive/undef (partial undefs are not ok)
EXPECT_FALSE(widenShuffleMaskElts(3, {-1,7,8,0,-1,2,-1,-1,-1}, WideMask));
// negative indexes must match across a wide element
EXPECT_FALSE(widenShuffleMaskElts(2, {-1,-2,-1,-1}, WideMask));
// negative indexes must match across a wide element
EXPECT_TRUE(widenShuffleMaskElts(2, {-2,-2,-3,-3}, WideMask));
EXPECT_EQ(makeArrayRef(WideMask), makeArrayRef({-2,-3}));
}
TEST_F(BasicTest, getSplatIndex) {
EXPECT_EQ(getSplatIndex({0,0,0}), 0);
EXPECT_EQ(getSplatIndex({1,0,0}), -1); // no splat
EXPECT_EQ(getSplatIndex({0,1,1}), -1); // no splat
EXPECT_EQ(getSplatIndex({42,42,42}), 42); // array size is independent of splat index
EXPECT_EQ(getSplatIndex({42,42,-1}), 42); // ignore negative
EXPECT_EQ(getSplatIndex({-1,42,-1}), 42); // ignore negatives
EXPECT_EQ(getSplatIndex({-4,42,-42}), 42); // ignore all negatives
EXPECT_EQ(getSplatIndex({-4,-1,-42}), -1); // all negative values map to -1
}
TEST_F(VectorUtilsTest, isSplatValue_00) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> zeroinitializer\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_00_index0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> zeroinitializer\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A, 0));
}
TEST_F(VectorUtilsTest, isSplatValue_00_index1) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> zeroinitializer\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 1));
}
TEST_F(VectorUtilsTest, isSplatValue_11) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_11_index0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 0));
}
TEST_F(VectorUtilsTest, isSplatValue_11_index1) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A, 1));
}
TEST_F(VectorUtilsTest, isSplatValue_01) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_01_index0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 0));
}
TEST_F(VectorUtilsTest, isSplatValue_01_index1) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 1));
}
// FIXME: Allow undef matching with Constant (mask) splat analysis.
TEST_F(VectorUtilsTest, isSplatValue_0u) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 undef>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A));
}
// FIXME: Allow undef matching with Constant (mask) splat analysis.
TEST_F(VectorUtilsTest, isSplatValue_0u_index0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 undef>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 0));
}
TEST_F(VectorUtilsTest, isSplatValue_0u_index1) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %A = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 undef>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 1));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = udiv <2 x i8> %v0, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop_index0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = udiv <2 x i8> %v0, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 0));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop_index1) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = udiv <2 x i8> %v0, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 1));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = ashr <2 x i8> <i8 42, i8 42>, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0_index0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = ashr <2 x i8> <i8 42, i8 42>, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A, 0));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop_ConstantOp0_index1) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = ashr <2 x i8> <i8 42, i8 42>, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A, 1));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop_Not_Op0) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 0>\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = add <2 x i8> %v0, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Binop_Not_Op1) {
parseAssembly(
"define <2 x i8> @test(<2 x i8> %x) {\n"
" %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %v1 = shufflevector <2 x i8> %x, <2 x i8> undef, <2 x i32> <i32 0, i32 1>\n"
" %A = shl <2 x i8> %v0, %v1\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Select) {
parseAssembly(
"define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
" %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
" %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
" %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = select <2 x i1> %v0, <2 x i8> %v1, <2 x i8> %v2\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Select_ConstantOp) {
parseAssembly(
"define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
" %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
" %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = select <2 x i1> %v0, <2 x i8> <i8 42, i8 42>, <2 x i8> %v2\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Select_NotCond) {
parseAssembly(
"define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
" %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
" %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = select <2 x i1> %x, <2 x i8> %v1, <2 x i8> %v2\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Select_NotOp1) {
parseAssembly(
"define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
" %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
" %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %A = select <2 x i1> %v0, <2 x i8> %y, <2 x i8> %v2\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_Select_NotOp2) {
parseAssembly(
"define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
" %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
" %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
" %A = select <2 x i1> %v0, <2 x i8> %v1, <2 x i8> %z\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_FALSE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, isSplatValue_SelectBinop) {
parseAssembly(
"define <2 x i8> @test(<2 x i1> %x, <2 x i8> %y, <2 x i8> %z) {\n"
" %v0 = shufflevector <2 x i1> %x, <2 x i1> undef, <2 x i32> <i32 1, i32 1>\n"
" %v1 = shufflevector <2 x i8> %y, <2 x i8> undef, <2 x i32> <i32 0, i32 0>\n"
" %v2 = shufflevector <2 x i8> %z, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" %bo = xor <2 x i8> %v1, %v2\n"
" %A = select <2 x i1> %v0, <2 x i8> %bo, <2 x i8> %v2\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_TRUE(isSplatValue(A));
}
TEST_F(VectorUtilsTest, getSplatValueElt0) {
parseAssembly(
"define <2 x i8> @test(i8 %x) {\n"
" %ins = insertelement <2 x i8> undef, i8 %x, i32 0\n"
" %A = shufflevector <2 x i8> %ins, <2 x i8> undef, <2 x i32> zeroinitializer\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_EQ(getSplatValue(A)->getName(), "x");
}
TEST_F(VectorUtilsTest, getSplatValueEltMismatch) {
parseAssembly(
"define <2 x i8> @test(i8 %x) {\n"
" %ins = insertelement <2 x i8> undef, i8 %x, i32 1\n"
" %A = shufflevector <2 x i8> %ins, <2 x i8> undef, <2 x i32> zeroinitializer\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_EQ(getSplatValue(A), nullptr);
}
// TODO: This is a splat, but we don't recognize it.
TEST_F(VectorUtilsTest, getSplatValueElt1) {
parseAssembly(
"define <2 x i8> @test(i8 %x) {\n"
" %ins = insertelement <2 x i8> undef, i8 %x, i32 1\n"
" %A = shufflevector <2 x i8> %ins, <2 x i8> undef, <2 x i32> <i32 1, i32 1>\n"
" ret <2 x i8> %A\n"
"}\n");
EXPECT_EQ(getSplatValue(A), nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// VFShape API tests.
////////////////////////////////////////////////////////////////////////////////
class VFShapeAPITest : public testing::Test {
protected:
void SetUp() override {
M = parseAssemblyString(IR, Err, Ctx);
// Get the only call instruction in the block, which is the first
// instruction.
CI = dyn_cast<CallInst>(&*(instructions(M->getFunction("f")).begin()));
}
const char *IR = "define i32 @f(i32 %a, i64 %b, double %c) {\n"
" %1 = call i32 @g(i32 %a, i64 %b, double %c)\n"
" ret i32 %1\n"
"}\n"
"declare i32 @g(i32, i64, double)\n";
LLVMContext Ctx;
SMDiagnostic Err;
std::unique_ptr<Module> M;
CallInst *CI;
// Dummy shape with no parameters, overwritten by buildShape when invoked.
VFShape Shape = {/*VF*/ 2, /*IsScalable*/ false, /*Parameters*/ {}};
VFShape Expected;
SmallVector<VFParameter, 8> &ExpectedParams = Expected.Parameters;
void buildShape(unsigned VF, bool IsScalable, bool HasGlobalPred) {
Shape = VFShape::get(*CI, ElementCount::get(VF, IsScalable), HasGlobalPred);
}
bool validParams(ArrayRef<VFParameter> Parameters) {
Shape.Parameters =
SmallVector<VFParameter, 8>(Parameters.begin(), Parameters.end());
return Shape.hasValidParameterList();
}
};
TEST_F(VFShapeAPITest, API_buildVFShape) {
buildShape(/*VF*/ 2, /*IsScalable*/ false, /*HasGlobalPred*/ false);
Expected = {/*VF*/ 2, /*IsScalable*/ false, /*Parameters*/ {
{0, VFParamKind::Vector},
{1, VFParamKind::Vector},
{2, VFParamKind::Vector},
}};
EXPECT_EQ(Shape, Expected);
buildShape(/*VF*/ 4, /*IsScalable*/ false, /*HasGlobalPred*/ true);
Expected = {/*VF*/ 4, /*IsScalable*/ false, /*Parameters*/ {
{0, VFParamKind::Vector},
{1, VFParamKind::Vector},
{2, VFParamKind::Vector},
{3, VFParamKind::GlobalPredicate},
}};
EXPECT_EQ(Shape, Expected);
buildShape(/*VF*/ 16, /*IsScalable*/ true, /*HasGlobalPred*/ false);
Expected = {/*VF*/ 16, /*IsScalable*/ true, /*Parameters*/ {
{0, VFParamKind::Vector},
{1, VFParamKind::Vector},
{2, VFParamKind::Vector},
}};
EXPECT_EQ(Shape, Expected);
}
TEST_F(VFShapeAPITest, API_getScalarShape) {
buildShape(/*VF*/ 1, /*IsScalable*/ false, /*HasGlobalPred*/ false);
EXPECT_EQ(VFShape::getScalarShape(*CI), Shape);
}
TEST_F(VFShapeAPITest, API_getVectorizedFunction) {
VFShape ScalarShape = VFShape::getScalarShape(*CI);
EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(ScalarShape),
M->getFunction("g"));
buildShape(/*VF*/ 1, /*IsScalable*/ true, /*HasGlobalPred*/ false);
EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
buildShape(/*VF*/ 1, /*IsScalable*/ false, /*HasGlobalPred*/ true);
EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
buildShape(/*VF*/ 1, /*IsScalable*/ true, /*HasGlobalPred*/ true);
EXPECT_EQ(VFDatabase(*CI).getVectorizedFunction(Shape), nullptr);
}
TEST_F(VFShapeAPITest, API_updateVFShape) {
buildShape(/*VF*/ 2, /*IsScalable*/ false, /*HasGlobalPred*/ false);
Shape.updateParam({0 /*Pos*/, VFParamKind::OMP_Linear, 1, Align(4)});
Expected = {/*VF*/ 2, /*IsScalable*/ false, /*Parameters*/ {
{0, VFParamKind::OMP_Linear, 1, Align(4)},
{1, VFParamKind::Vector},
{2, VFParamKind::Vector},
}};
EXPECT_EQ(Shape, Expected);
// From this point on, we update only the parameters of the VFShape,
// so we update only the reference of the expected Parameters.
Shape.updateParam({1 /*Pos*/, VFParamKind::OMP_Uniform});
ExpectedParams = {
{0, VFParamKind::OMP_Linear, 1, Align(4)},
{1, VFParamKind::OMP_Uniform},
{2, VFParamKind::Vector},
};
EXPECT_EQ(Shape, Expected);
Shape.updateParam({2 /*Pos*/, VFParamKind::OMP_LinearRefPos, 1});
ExpectedParams = {
{0, VFParamKind::OMP_Linear, 1, Align(4)},
{1, VFParamKind::OMP_Uniform},
{2, VFParamKind::OMP_LinearRefPos, 1},
};
EXPECT_EQ(Shape, Expected);
}
TEST_F(VFShapeAPITest, API_updateVFShape_GlobalPredicate) {
buildShape(/*VF*/ 2, /*IsScalable*/ true, /*HasGlobalPred*/ true);
Shape.updateParam({1 /*Pos*/, VFParamKind::OMP_Uniform});
Expected = {/*VF*/ 2, /*IsScalable*/ true,
/*Parameters*/ {{0, VFParamKind::Vector},
{1, VFParamKind::OMP_Uniform},
{2, VFParamKind::Vector},
{3, VFParamKind::GlobalPredicate}}};
EXPECT_EQ(Shape, Expected);
}
TEST_F(VFShapeAPITest, Parameters_Valid) {
// ParamPos in order.
EXPECT_TRUE(validParams({{0, VFParamKind::Vector}}));
EXPECT_TRUE(
validParams({{0, VFParamKind::Vector}, {1, VFParamKind::Vector}}));
EXPECT_TRUE(validParams({{0, VFParamKind::Vector},
{1, VFParamKind::Vector},
{2, VFParamKind::Vector}}));
// GlocalPredicate is unique.
EXPECT_TRUE(validParams({{0, VFParamKind::Vector},
{1, VFParamKind::Vector},
{2, VFParamKind::Vector},
{3, VFParamKind::GlobalPredicate}}));
EXPECT_TRUE(validParams({{0, VFParamKind::Vector},
{1, VFParamKind::GlobalPredicate},
{2, VFParamKind::Vector}}));
}
TEST_F(VFShapeAPITest, Parameters_ValidOpenMPLinear) {
// Valid linear constant step (>0).
#define __BUILD_PARAMETERS(Kind, Val) \
{ \
{ 0, Kind, Val } \
}
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_Linear, 1)));
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRef, 2)));
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearVal, 4)));
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUVal, 33)));
#undef __BUILD_PARAMETERS
// Valid linear runtime step (the step parameter is marked uniform).
#define __BUILD_PARAMETERS(Kind) \
{ \
{0, VFParamKind::OMP_Uniform}, {1, VFParamKind::Vector}, { 2, Kind, 0 } \
}
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
EXPECT_TRUE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
#undef __BUILD_PARAMETERS
}
TEST_F(VFShapeAPITest, Parameters_Invalid) {
#ifndef NDEBUG
// Wrong order is checked by an assertion: make sure that the
// assertion is not removed.
EXPECT_DEATH(validParams({{1, VFParamKind::Vector}}),
"Broken parameter list.");
EXPECT_DEATH(
validParams({{1, VFParamKind::Vector}, {0, VFParamKind::Vector}}),
"Broken parameter list.");
#endif
// GlobalPredicate is not unique
EXPECT_FALSE(validParams({{0, VFParamKind::Vector},
{1, VFParamKind::GlobalPredicate},
{2, VFParamKind::GlobalPredicate}}));
EXPECT_FALSE(validParams({{0, VFParamKind::GlobalPredicate},
{1, VFParamKind::Vector},
{2, VFParamKind::GlobalPredicate}}));
}
TEST_F(VFShapeAPITest, Parameters_InvalidOpenMPLinear) {
// Compile time linear steps must be non-zero (compile time invariant).
#define __BUILD_PARAMETERS(Kind) \
{ \
{ 0, Kind, 0 } \
}
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_Linear)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRef)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearVal)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUVal)));
#undef __BUILD_PARAMETERS
// The step of a runtime linear parameter must be marked
// as uniform (runtime invariant).
#define __BUILD_PARAMETERS(Kind) \
{ \
{0, VFParamKind::OMP_Uniform}, {1, VFParamKind::Vector}, { 2, Kind, 1 } \
}
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
#undef __BUILD_PARAMETERS
// The linear step parameter can't point at itself.
#define __BUILD_PARAMETERS(Kind) \
{ \
{0, VFParamKind::Vector}, {1, VFParamKind::Vector}, { 2, Kind, 2 } \
}
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
#undef __BUILD_PARAMETERS
// Linear parameter (runtime) is out of range.
#define __BUILD_PARAMETERS(Kind) \
{ \
{0, VFParamKind::Vector}, {1, VFParamKind::Vector}, { 2, Kind, 3 } \
}
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearRefPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearValPos)));
EXPECT_FALSE(validParams(__BUILD_PARAMETERS(VFParamKind::OMP_LinearUValPos)));
#undef __BUILD_PARAMETERS
}
Reference in New Issue View Git Blame Copy Permalink