This is an archive of the discontinued LLVM Phabricator instance.

Differential D129227

[mlir][sparse] fix windows build error
ClosedPublic

Authored by Peiming on Jul 6 2022, 2:06 PM.

Details

Reviewers
aartbik
wrengr
Commits
rG66ae1d60bb27: [mlir][sparse] fix windows build error
Summary

Silence warning from MSVC when handling ##__VA_ARGS

Diff Detail

Event Timeline

Peiming created this revision.Jul 6 2022, 2:06 PM
Herald added a reviewer: aartbik. · View Herald TranscriptJul 6 2022, 2:06 PM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: anlunx, bzcheeseman, sdasgup3 and 20 others. · View Herald Transcript
Peiming requested review of this revision.Jul 6 2022, 2:06 PM
Herald added a project: Restricted Project. · View Herald TranscriptJul 6 2022, 2:06 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
aartbik added inline comments.Jul 6 2022, 2:10 PM
mlir/unittests/Dialect/SparseTensor/MergerTest.cpp
10–17

Is L10-17 the new part

aartbik added a reviewer: wrengr.Jul 6 2022, 2:10 PM
aartbik accepted this revision.Jul 6 2022, 2:14 PM
This revision is now accepted and ready to land.Jul 6 2022, 2:14 PM
This revision was landed with ongoing or failed builds.Jul 6 2022, 2:16 PM
Closed by commit rG66ae1d60bb27: [mlir][sparse] fix windows build error (authored by Peiming). · Explain Why
This revision was automatically updated to reflect the committed changes.
Peiming added a commit: rG66ae1d60bb27: [mlir][sparse] fix windows build error.
Peiming marked an inline comment as done.Jul 6 2022, 2:25 PM
Peiming added inline comments.
mlir/unittests/Dialect/SparseTensor/MergerTest.cpp
10–17

Yes and L640-642

Harbormaster completed remote builds in B173981: Diff 442684.Jul 6 2022, 2:42 PM

Revision Contents

PathSize
mlir/
unittests/
Dialect/
SparseTensor/
470 lines

Diff 442685

mlir/unittests/Dialect/SparseTensor/MergerTest.cpp

#include "mlir/Dialect/SparseTensor/Utils/Merger.h" #include "mlir/Dialect/SparseTensor/Utils/Merger.h"
#include "llvm/Support/Compiler.h"
#include "gmock/gmock.h" #include "gmock/gmock.h"
#include "gtest/gtest.h" #include "gtest/gtest.h"
#include <memory> #include <memory>
using namespace mlir; using namespace mlir;
using namespace mlir::sparse_tensor; using namespace mlir::sparse_tensor;
// Silence 'warning C4002: 'too many arguments for function-liked macro
// invocation'
// as MSVC handles ##__VA_ARGS__ differently as gcc/clang
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(push)
#pragma warning(disable : 4002)
#endif
aartbikUnsubmitted
Not Done
ReplyInline Actions

Is L10-17 the new part

aartbik: Is L10-17 the new part
PeimingAuthorUnsubmitted
Done
ReplyInline Actions

Yes and L640-642

Peiming: Yes and L640-642
namespace { namespace {
///
/// Defines macros to iterate binary and the combination of binary operations.
///
#define FOREVERY_BINOP(DO) \
DO(mulf, Kind::kMulF) \
DO(mulc, Kind::kMulC) \
DO(muli, Kind::kMulI) \
DO(addf, Kind::kAddF) \
DO(addc, Kind::kAddC) \
DO(addi, Kind::kAddI) \
DO(subf, Kind::kSubF) \
DO(subc, Kind::kSubC) \
DO(subi, Kind::kSubI) \
DO(andi, Kind::kAndI) \
DO(xori, Kind::kXorI) \
DO(ori, Kind::kOrI)
// TODO: Disjunctive binary operations that need special handling are not
// included, e.g., Division are not tested (for now) as it need a constant
// non-zero dividend.
// ##__VA_ARGS__ handles cases when __VA_ARGS__ is empty.
#define FOREVERY_COMMON_DISJ_BINOP(TEST, ...) \
TEST(addf, ##__VA_ARGS__) \
TEST(addc, ##__VA_ARGS__) \
TEST(addi, ##__VA_ARGS__) \
TEST(xori, ##__VA_ARGS__) \
TEST(ori, ##__VA_ARGS__)
// TODO: Conjunctive binary operations that need special handling are not
// included, e.g., substraction yields a different pattern as it is mapped to
// negate operation.
#define FOREVERY_COMMON_CONJ_BINOP(TEST, ...) \
TEST(mulf, ##__VA_ARGS__) \
TEST(mulc, ##__VA_ARGS__) \
TEST(muli, ##__VA_ARGS__) \
TEST(andi, ##__VA_ARGS__)
#define FOREVERY_PAIR_OF_COMMON_CONJ_DISJ_BINOP(TEST) \
FOREVERY_COMMON_CONJ_BINOP(TEST, addf) \
FOREVERY_COMMON_CONJ_BINOP(TEST, addc) \
FOREVERY_COMMON_CONJ_BINOP(TEST, addi) \
FOREVERY_COMMON_CONJ_BINOP(TEST, xori) \
FOREVERY_COMMON_CONJ_BINOP(TEST, ori)
#define FOREVERY_PAIR_OF_COMMON_CONJ_CONJ_BINOP(TEST) \
FOREVERY_COMMON_CONJ_BINOP(TEST, mulf) \
FOREVERY_COMMON_CONJ_BINOP(TEST, mulc) \
FOREVERY_COMMON_CONJ_BINOP(TEST, muli) \
FOREVERY_COMMON_CONJ_BINOP(TEST, andi)
#define FOREVERY_PAIR_OF_COMMON_DISJ_DISJ_BINOP(TEST) \
FOREVERY_COMMON_DISJ_BINOP(TEST, addf) \
FOREVERY_COMMON_DISJ_BINOP(TEST, addc) \
FOREVERY_COMMON_DISJ_BINOP(TEST, addi) \
FOREVERY_COMMON_DISJ_BINOP(TEST, ori) \
FOREVERY_COMMON_DISJ_BINOP(TEST, xori)
///
/// Helper classes/functions for testing Merger.
///
/// Simple recursive data structure used to match expressions in Mergers. /// Simple recursive data structure used to match expressions in Mergers.
struct Pattern { struct Pattern {
Kind kind; Kind kind;
/// Expressions representing tensors simply have a tensor number. /// Expressions representing tensors simply have a tensor number.
unsigned tensorNum; unsigned tensorNum;
/// Tensor operations point to their children. /// Tensor operations point to their children.
Show All 16 Lines
/// Readable Pattern builder functions. /// Readable Pattern builder functions.
/// These should be preferred over the actual constructors. /// These should be preferred over the actual constructors.
/// ///
static std::shared_ptr<Pattern> tensorPattern(unsigned tensorNum) { static std::shared_ptr<Pattern> tensorPattern(unsigned tensorNum) {
return std::make_shared<Pattern>(tensorNum); return std::make_shared<Pattern>(tensorNum);
} }
static std::shared_ptr<Pattern> #define IMPL_BINOP_PATTERN(OP, KIND) \
addfPattern(const std::shared_ptr<Pattern> &e0, LLVM_ATTRIBUTE_UNUSED static std::shared_ptr<Pattern> OP##Pattern( \
const std::shared_ptr<Pattern> &e1) { const std::shared_ptr<Pattern> &e0, \
return std::make_shared<Pattern>(Kind::kAddF, e0, e1); const std::shared_ptr<Pattern> &e1) { \
return std::make_shared<Pattern>(KIND, e0, e1); \
} }
static std::shared_ptr<Pattern> FOREVERY_BINOP(IMPL_BINOP_PATTERN)
mulfPattern(const std::shared_ptr<Pattern> &e0,
const std::shared_ptr<Pattern> &e1) { #undef IMPL_BINOP_PATTERN
return std::make_shared<Pattern>(Kind::kMulF, e0, e1);
}
class MergerTestBase : public ::testing::Test { class MergerTestBase : public ::testing::Test {
protected: protected:
MergerTestBase(unsigned numTensors, unsigned numLoops) MergerTestBase(unsigned numTensors, unsigned numLoops)
: numTensors(numTensors), numLoops(numLoops), : numTensors(numTensors), numLoops(numLoops),
merger(numTensors, numLoops) {} merger(numTensors, numLoops) {}
/// ///
/// Expression construction helpers. /// Expression construction helpers.
/// ///
unsigned tensor(unsigned tensor) { unsigned tensor(unsigned tensor) {
return merger.addExp(Kind::kTensor, tensor); return merger.addExp(Kind::kTensor, tensor);
} }
unsigned addf(unsigned e0, unsigned e1) { #define IMPL_BINOP_EXPR(OP, KIND) \
return merger.addExp(Kind::kAddF, e0, e1); LLVM_ATTRIBUTE_UNUSED unsigned OP##Expr(unsigned e0, unsigned e1) { \
return merger.addExp(KIND, e0, e1); \
} }
unsigned mulf(unsigned e0, unsigned e1) { FOREVERY_BINOP(IMPL_BINOP_EXPR)
return merger.addExp(Kind::kMulF, e0, e1);
} #undef IMPL_BINOP_EXPR
/// ///
/// Comparison helpers. /// Comparison helpers.
/// ///
/// For readability of tests. /// For readability of tests.
unsigned lat(unsigned lat) { return lat; } unsigned lat(unsigned lat) { return lat; }
/// Returns true if a lattice point with an expression matching the given /// Returns true if a lattice point with an expression matching the given
/// pattern and bits matching the given bits is present in lattice points /// pattern and bits matching the given bits is present in lattice points
/// [p, p+n) of lattice set s. This is useful for testing partial ordering /// [p, p+n) of lattice set s. This is useful for testing partial ordering
/// constraints between lattice points. We generally know how contiguous /// constraints between lattice points. We generally know how contiguous
/// groups of lattice points should be ordered with respect to other groups, /// groups of lattice points should be ordered with respect to other groups,
/// but there is no required ordering within groups. /// but there is no required ordering within groups.
/// If simple is true, then compare the lat.simple field instead to test the
/// result after optimization
bool latPointWithinRange(unsigned s, unsigned p, unsigned n, bool latPointWithinRange(unsigned s, unsigned p, unsigned n,
const std::shared_ptr<Pattern> &pattern, const std::shared_ptr<Pattern> &pattern,
const BitVector &bits) { const BitVector &bits, bool simple) {
for (unsigned i = p; i < p + n; ++i) { for (unsigned i = p; i < p + n; ++i) {
if (compareExpression(merger.lat(merger.set(s)[i]).exp, pattern) && if (compareExpression(merger.lat(merger.set(s)[i]).exp, pattern) &&
compareBits(s, i, bits)) compareBits(s, i, bits, simple))
return true; return true;
} }
return false; return false;
} }
/// Wrapper over latPointWithinRange for readability of tests. /// Wrapper over latPointWithinRange for readability of tests.
void expectLatPointWithinRange(unsigned s, unsigned p, unsigned n, void expectLatPointWithinRange(unsigned s, unsigned p, unsigned n,
const std::shared_ptr<Pattern> &pattern, const std::shared_ptr<Pattern> &pattern,
const BitVector &bits) { const BitVector &bits, bool simple = false) {
EXPECT_TRUE(latPointWithinRange(s, p, n, pattern, bits)); EXPECT_TRUE(latPointWithinRange(s, p, n, pattern, bits, simple));
} }
/// Wrapper over expectLatPointWithinRange for a single lat point. /// Wrapper over expectLatPointWithinRange for a single lat point.
void expectLatPoint(unsigned s, unsigned p, void expectLatPoint(unsigned s, unsigned p,
const std::shared_ptr<Pattern> &pattern, const std::shared_ptr<Pattern> &pattern,
const BitVector &bits) { const BitVector &bits, bool simple = false) {
EXPECT_TRUE(latPointWithinRange(s, p, 1, pattern, bits)); EXPECT_TRUE(latPointWithinRange(s, p, 1, pattern, bits, simple));
} }
/// Converts a vector of (loop, tensor) pairs to a bitvector with the /// Converts a vector of (loop, tensor) pairs to a bitvector with the
/// corresponding bits set. /// corresponding bits set.
BitVector BitVector
loopsToBits(const std::vector<std::pair<unsigned, unsigned>> &loops) { loopsToBits(const std::vector<std::pair<unsigned, unsigned>> &loops) {
BitVector testBits = BitVector(numTensors + 1, false); BitVector testBits = BitVector(numTensors + 1, false);
for (auto l : loops) { for (auto l : loops) {
auto loop = std::get<0>(l); auto loop = std::get<0>(l);
auto tensor = std::get<1>(l); auto tensor = std::get<1>(l);
testBits.set(numTensors * loop + tensor); testBits.set(numTensors * loop + tensor);
} }
return testBits; return testBits;
} }
/// Returns true if the bits of lattice point p in set s match the given bits. /// Returns true if the bits of lattice point p in set s match the given bits.
bool compareBits(unsigned s, unsigned p, const BitVector &bits) { /// If simple is true, then compare the lat.simple field instead to test the
/// result after optimization
bool compareBits(unsigned s, unsigned p, const BitVector &bits, bool simple) {
if (simple)
return merger.lat(merger.set(s)[p]).simple == bits;
return merger.lat(merger.set(s)[p]).bits == bits; return merger.lat(merger.set(s)[p]).bits == bits;
} }
/// Check that there are n lattice points in set s. /// Check that there are n lattice points in set s.
void expectNumLatPoints(unsigned s, unsigned n) { void expectNumLatPoints(unsigned s, unsigned n) {
EXPECT_THAT(merger.set(s).size(), n); EXPECT_THAT(merger.set(s).size(), n);
} }
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines bool compareExpression(unsigned e, const std::shared_ptr<Pattern> &pattern) {
llvm_unreachable("unexpected kind"); llvm_unreachable("unexpected kind");
} }
unsigned numTensors; unsigned numTensors;
unsigned numLoops; unsigned numLoops;
Merger merger; Merger merger;
}; };
///
/// Tests with all sparse inputs.
///
class MergerTest3T1L : public MergerTestBase { class MergerTest3T1L : public MergerTestBase {
protected: protected:
// Our three tensors (two inputs, one output). // Our three tensors (two inputs, one output).
const unsigned t0 = 0, t1 = 1, t2 = 2; const unsigned t0 = 0, t1 = 1, t2 = 2;
// Our single loop. // Our single loop.
const unsigned l0 = 0; const unsigned l0 = 0;
MergerTest3T1L() : MergerTestBase(3, 1) { MergerTest3T1L() : MergerTestBase(3, 1) {
// Tensor 0: sparse input vector. // Tensor 0: sparse input vector.
merger.addExp(Kind::kTensor, t0, -1u); merger.addExp(Kind::kTensor, t0, -1u);
merger.setDim(t0, l0, Dim::kSparse); merger.setDim(t0, l0, Dim::kSparse);
// Tensor 1: sparse input vector. // Tensor 1: sparse input vector.
merger.addExp(Kind::kTensor, t1, -1u); merger.addExp(Kind::kTensor, t1, -1u);
merger.setDim(t1, l0, Dim::kSparse); merger.setDim(t1, l0, Dim::kSparse);
// Tensor 2: dense output vector. // Tensor 2: dense output vector.
merger.addExp(Kind::kTensor, t2, -1u); merger.addExp(Kind::kTensor, t2, -1u);
merger.setDim(t2, l0, Dim::kDense); merger.setDim(t2, l0, Dim::kDense);
} }
}; };
class MergerTest4T1L : public MergerTestBase {
protected:
// Our four tensors (three inputs, one output).
const unsigned t0 = 0, t1 = 1, t2 = 2, t3 = 3;
// Our single loop.
const unsigned l0 = 0;
MergerTest4T1L() : MergerTestBase(4, 1) {
// Tensor 0: sparse input vector.
merger.addExp(Kind::kTensor, t0, -1u);
merger.setDim(t0, l0, Dim::kSparse);
// Tensor 1: sparse input vector.
merger.addExp(Kind::kTensor, t1, -1u);
merger.setDim(t1, l0, Dim::kSparse);
// Tensor 2: sparse input vector
merger.addExp(Kind::kTensor, t2, -1u);
merger.setDim(t2, l0, Dim::kSparse);
// Tensor 3: dense output vector
merger.addExp(Kind::kTensor, t3, -1u);
merger.setDim(t3, l0, Dim::kDense);
}
};
///
/// Tests with both sparse and dense input.
///
class MergerTest3T1LD : public MergerTestBase {
protected:
// Our three tensors (two inputs, one output).
const unsigned t0 = 0, t1 = 1, t2 = 2;
// Our single loop.
const unsigned l0 = 0;
MergerTest3T1LD() : MergerTestBase(3, 1) {
// Tensor 0: sparse input vector.
merger.addExp(Kind::kTensor, t0, -1u);
merger.setDim(t0, l0, Dim::kSparse);
// Tensor 1: dense input vector.
merger.addExp(Kind::kTensor, t1, -1u);
merger.setDim(t1, l0, Dim::kDense);
// Tensor 2: dense output vector.
merger.addExp(Kind::kTensor, t2, -1u);
merger.setDim(t2, l0, Dim::kDense);
}
};
} // namespace } // namespace
/// Vector addition of 2 vectors, i.e.: /// Vector addition (disjunction) of 2 vectors. i.e.;
/// a(i) = b(i) + c(i) /// a(i) = b(i) + c(i)
/// which should form the 3 lattice points /// which should form the 3 lattice points
/// { /// {
/// lat( i_00 i_01 / (tensor_0 + tensor_1) ) /// lat( i_00 i_01 / (tensor_0 + tensor_1) )
/// lat( i_00 / tensor_0 ) /// lat( i_00 / tensor_0 )
/// lat( i_01 / tensor_1 ) /// lat( i_01 / tensor_1 )
/// } /// }
/// and after optimization, will reduce to the 2 lattice points /// and after optimization, the lattice points do not change (as there is no
/// duplicated point and all input vectors are sparse vector).
/// { /// {
/// lat( i_00 i_01 / (tensor_0 + tensor_1) ) /// lat( i_00 i_01 / (tensor_0 + tensor_1) )
/// lat( i_00 / tensor_0 ) /// lat( i_00 / tensor_0 )
/// lat( i_01 / tensor_1 )
/// } /// }
TEST_F(MergerTest3T1L, VectorAdd2) { #define IMPL_MERGER_TEST_DISJ(OP) \
// Construct expression. TEST_F(MergerTest3T1L, vector_##OP) { \
auto e = addf(tensor(t0), tensor(t1)); auto e = OP##Expr(tensor(t0), tensor(t1)); \
auto p0 = tensorPattern(t0); \
// Build lattices and check. auto p1 = tensorPattern(t1); \
auto s = merger.buildLattices(e, l0); auto s = merger.buildLattices(e, l0); \
expectNumLatPoints(s, 3); \
expectLatPoint(s, lat(0), addfPattern(tensorPattern(t0), tensorPattern(t1)), expectNumLatPoints(s, 3); \
loopsToBits({{l0, t0}, {l0, t1}})); expectLatPoint(s, lat(0), OP##Pattern(p0, p1), \
expectLatPointWithinRange(s, lat(1), 2, tensorPattern(t0), loopsToBits({{l0, t0}, {l0, t1}})); \
loopsToBits({{l0, t0}})); expectLatPointWithinRange(s, lat(1), 2, p0, loopsToBits({{l0, t0}})); \
expectLatPointWithinRange(s, lat(1), 2, tensorPattern(t1), expectLatPointWithinRange(s, lat(1), 2, p1, loopsToBits({{l0, t1}})); \
loopsToBits({{l0, t1}})); \
s = merger.optimizeSet(s); \
// Optimize lattices and check. expectNumLatPoints(s, 3); \
s = merger.optimizeSet(s); expectLatPoint(s, lat(0), OP##Pattern(p0, p1), \
expectNumLatPoints(s, 3); loopsToBits({{l0, t0}, {l0, t1}}), true); \
expectLatPoint(s, lat(0), addfPattern(tensorPattern(t0), tensorPattern(t1)), expectLatPointWithinRange(s, lat(1), 2, p0, loopsToBits({{l0, t0}}), \
loopsToBits({{l0, t0}, {l0, t1}})); true); \
expectLatPointWithinRange(s, lat(1), 2, tensorPattern(t0), expectLatPointWithinRange(s, lat(1), 2, p1, loopsToBits({{l0, t1}}), \
loopsToBits({{l0, t0}})); true); \
expectLatPointWithinRange(s, lat(1), 2, tensorPattern(t1),
loopsToBits({{l0, t1}}));
} }
/// Vector multiplication of 2 vectors, i.e.: FOREVERY_COMMON_DISJ_BINOP(IMPL_MERGER_TEST_DISJ)
#undef IMPL_MERGER_TEST_DISJ
/// Vector multiplication (conjunction) of 2 vectors, i.e.;
/// a(i) = b(i) * c(i) /// a(i) = b(i) * c(i)
/// which should form the single lattice point /// which should form the single lattice point
/// { /// {
/// lat( i_00 i_01 / (tensor_0 * tensor_1) ) /// lat( i_00 i_01 / (tensor_0 * tensor_1) )
/// } /// }
TEST_F(MergerTest3T1L, VectorMul2) { #define IMPL_MERGER_TEST_CONJ(OP) \
// Construct expression. TEST_F(MergerTest3T1L, vector_##OP) { \
auto e = mulf(t0, t1); auto e = OP##Expr(t0, t1); \
auto p0 = tensorPattern(t0); \
// Build lattices and check. auto p1 = tensorPattern(t1); \
auto s = merger.buildLattices(e, l0); auto s = merger.buildLattices(e, l0); \
expectNumLatPoints(s, 1); \
expectLatPoint(s, lat(0), mulfPattern(tensorPattern(t0), tensorPattern(t1)), expectNumLatPoints(s, 1); \
loopsToBits({{l0, t0}, {l0, t1}})); expectLatPoint(s, lat(0), OP##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); \
// Optimize lattices and check. \
s = merger.optimizeSet(s); s = merger.optimizeSet(s); \
expectNumLatPoints(s, 1); expectNumLatPoints(s, 1); \
expectLatPoint(s, lat(0), mulfPattern(tensorPattern(t0), tensorPattern(t1)), expectLatPoint(s, lat(0), OP##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); loopsToBits({{l0, t0}, {l0, t1}}), true); \
}
FOREVERY_COMMON_CONJ_BINOP(IMPL_MERGER_TEST_CONJ)
#undef IMPL_MERGER_TEST_CONJ
/// Vector multiplication (conjunction) then addition (disjunction), i.e.;
/// a(i) = b(i) * c(i) + d(i);
/// which should form
/// {
/// lat( i_00 i_01 i_02 / (tensor_0 * tensor_1) + tensor_2 )
/// lat( i_00 i_01 / tensor_0 * tensor_1
/// lat( i_02 / tensor_2 )
/// }
#define IMPL_MERGER_TEST_CONJ_DISJ(CONJ, DISJ) \
TEST_F(MergerTest4T1L, vector_##CONJ##_##DISJ) { \
auto em = CONJ##Expr(t0, t1); \
auto e = DISJ##Expr(em, t2); \
auto p0 = tensorPattern(t0); \
auto p1 = tensorPattern(t1); \
auto p2 = tensorPattern(t2); \
auto s = merger.buildLattices(e, l0); \
\
expectNumLatPoints(s, 3); \
expectLatPoint(s, lat(0), DISJ##Pattern(CONJ##Pattern(p0, p1), p2), \
loopsToBits({{l0, t0}, {l0, t1}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 2, CONJ##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); \
expectLatPointWithinRange(s, lat(1), 2, p2, loopsToBits({{l0, t2}})); \
\
s = merger.optimizeSet(s); \
expectNumLatPoints(s, 3); \
expectLatPoint(s, lat(0), DISJ##Pattern(CONJ##Pattern(p0, p1), p2), \
loopsToBits({{l0, t0}, {l0, t1}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 2, CONJ##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); \
expectLatPointWithinRange(s, lat(1), 2, p2, loopsToBits({{l0, t2}})); \
}
FOREVERY_PAIR_OF_COMMON_CONJ_DISJ_BINOP(IMPL_MERGER_TEST_CONJ_DISJ)
#undef IMPL_MERGER_TEST_CONJ_DISJ
/// Vector addition (disjunction) then addition (disjunction), i.e.;
/// a(i) = b(i) + c(i) + d(i)
/// which should form
/// {
/// lat( i_00 i_01 i_02 / (tensor_0 + tensor_1) + tensor_2 )
/// lat( i_02 i_01 / tensor_2 + tensor_1 )
/// lat( i_02 i_00 / tensor_2 + tensor_0 )
/// lat( i_01 i_00 / tensor_1 + tensor_0 )
/// lat( i_02 / tensor_2 )
/// lat( i_01 / tensor_1 )
/// lat( i_00 / tensor_0 )
/// }
#define IMPL_MERGER_TEST_DISJ_DISJ(DISJ1, DISJ2) \
TEST_F(MergerTest4T1L, Vector_##DISJ1##_##DISJ2) { \
auto em = DISJ1##Expr(t0, t1); \
auto e = DISJ2##Expr(em, t2); \
auto p0 = tensorPattern(t0); \
auto p1 = tensorPattern(t1); \
auto p2 = tensorPattern(t2); \
auto s = merger.buildLattices(e, l0); \
\
expectNumLatPoints(s, 7); \
expectLatPoint(s, lat(0), DISJ2##Pattern(DISJ1##Pattern(p0, p1), p2), \
loopsToBits({{l0, t0}, {l0, t1}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, DISJ2##Pattern(p1, p2), \
loopsToBits({{l0, t1}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, DISJ2##Pattern(p0, p2), \
loopsToBits({{l0, t0}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, DISJ1##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); \
expectLatPointWithinRange(s, lat(1), 6, p2, loopsToBits({{l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, p1, loopsToBits({{l0, t1}})); \
expectLatPointWithinRange(s, lat(1), 6, p0, loopsToBits({{l0, t0}})); \
\
s = merger.optimizeSet(s); \
expectNumLatPoints(s, 7); \
expectLatPoint(s, lat(0), DISJ2##Pattern(DISJ1##Pattern(p0, p1), p2), \
loopsToBits({{l0, t0}, {l0, t1}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, DISJ2##Pattern(p1, p2), \
loopsToBits({{l0, t1}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, DISJ2##Pattern(p0, p2), \
loopsToBits({{l0, t0}, {l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, DISJ1##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); \
expectLatPointWithinRange(s, lat(1), 6, p2, loopsToBits({{l0, t2}})); \
expectLatPointWithinRange(s, lat(1), 6, p1, loopsToBits({{l0, t1}})); \
expectLatPointWithinRange(s, lat(1), 6, p0, loopsToBits({{l0, t0}})); \
}
FOREVERY_PAIR_OF_COMMON_DISJ_DISJ_BINOP(IMPL_MERGER_TEST_DISJ_DISJ)
#undef IMPL_MERGER_TEST_DISJ_DISJ
/// Vector multiplication (conjunction) then multiplication (conjunction), i.e.;
/// a(i) = b(i) * c(i) * d(i);
/// which should form
/// {
/// lat( i_00 i_01 i_02 / tensor_0 * tensor_1 * tensor_2 )
/// }
#define IMPL_MERGER_TEST_CONJ_CONJ(CONJ1, CONJ2) \
TEST_F(MergerTest4T1L, vector_##CONJ1##_##CONJ2) { \
auto em = CONJ1##Expr(t0, t1); \
auto e = CONJ2##Expr(em, t2); \
auto p0 = tensorPattern(t0); \
auto p1 = tensorPattern(t1); \
auto p2 = tensorPattern(t2); \
auto s = merger.buildLattices(e, l0); \
expectNumLatPoints(s, 1); \
expectLatPoint(s, lat(0), CONJ2##Pattern(CONJ1##Pattern(p0, p1), p2), \
loopsToBits({{l0, t0}, {l0, t1}, {l0, t2}})); \
s = merger.optimizeSet(s); \
expectNumLatPoints(s, 1); \
expectLatPoint(s, lat(0), CONJ2##Pattern(CONJ1##Pattern(p0, p1), p2), \
loopsToBits({{l0, t0}, {l0, t1}, {l0, t2}}), true); \
} }
FOREVERY_PAIR_OF_COMMON_CONJ_CONJ_BINOP(IMPL_MERGER_TEST_CONJ_CONJ)
#undef IMPL_MERGER_TEST_CONJ_CONJ
/// Vector addition (disjunction) of 2 vectors, i.e.;
/// a(i) = b(i) + c(i)
/// which should form the 3 lattice points
/// {
/// lat( i_00 i_01 / (sparse_tensor_0 + dense_tensor_1) )
/// lat( i_00 / sparse_tensor_0 )
/// lat( i_01 / dense_tensor_1 )
/// }
/// which should be optimized to
/// {
/// lat( i_00 i_01 / (sparse_tensor_0 + dense_tensor_1) ) (not singleton)
/// lat( i_01 / dense_tensor_0 ) (no sparse dimension)
/// }
///
/// lat( i_00 / sparse_tensor_0 ) should be opted out as it only has dense diff
/// with lat( i_00 i_01 / (sparse_tensor_0 + dense_tensor_1) ).
#define IMPL_MERGER_TEST_OPTIMIZED_DISJ(OP) \
TEST_F(MergerTest3T1LD, vector_opted_##OP) { \
auto e = OP##Expr(tensor(t0), tensor(t1)); \
auto p0 = tensorPattern(t0); \
auto p1 = tensorPattern(t1); \
auto s = merger.buildLattices(e, l0); \
\
expectNumLatPoints(s, 3); \
expectLatPoint(s, lat(0), OP##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); \
expectLatPointWithinRange(s, lat(1), 2, p0, loopsToBits({{l0, t0}})); \
expectLatPointWithinRange(s, lat(1), 2, p1, loopsToBits({{l0, t1}})); \
\
s = merger.optimizeSet(s); \
expectNumLatPoints(s, 2); \
expectLatPoint(s, lat(0), OP##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}}), true); \
expectLatPoint(s, lat(1), p1, loopsToBits({{l0, t1}}), true); \
}
FOREVERY_COMMON_DISJ_BINOP(IMPL_MERGER_TEST_OPTIMIZED_DISJ)
#undef IMPL_MERGER_TEST_OPTIMIZED_CONJ
/// Vector multiplication (conjunction) of 2 vectors, i.e.:
/// a(i) = b(i) * c(i)
/// which should form the single lattice point
/// {
/// lat( i_00 i_01 / (sparse_tensor_0 * dense_tensor_1) )
/// }
/// it should be optimized to
/// {
/// lat( i_00 / (sparse_tensor_0 * dense_tensor_1) )
/// }
/// since i_01 is a dense dimension.
#define IMPL_MERGER_TEST_OPTIMIZED_CONJ(OP) \
TEST_F(MergerTest3T1LD, vector_opted_##OP) { \
auto e = OP##Expr(t0, t1); \
auto p0 = tensorPattern(t0); \
auto p1 = tensorPattern(t1); \
auto s = merger.buildLattices(e, l0); \
\
expectNumLatPoints(s, 1); \
expectLatPoint(s, lat(0), OP##Pattern(p0, p1), \
loopsToBits({{l0, t0}, {l0, t1}})); \
\
s = merger.optimizeSet(s); \
expectNumLatPoints(s, 1); \
expectLatPoint(s, lat(0), OP##Pattern(p0, p1), loopsToBits({{l0, t0}}), \
true); \
}
FOREVERY_COMMON_CONJ_BINOP(IMPL_MERGER_TEST_OPTIMIZED_CONJ)
#undef IMPL_MERGER_TEST_OPTIMIZED_CONJ
// TODO: mult-dim tests
// restore warning status
#if defined(_MSC_VER) && !defined(__clang__)
#pragma warning(pop)
#endif