From 6c0363c579361a4833099317c0269b7ae04d29e3 Mon Sep 17 00:00:00 2001 From: "Aditya.Joshi" Date: Mon, 24 Jun 2024 20:30:28 +0000 Subject: [PATCH 1/2] Support for predicate arithmetic intensity added on top of streamK branch in Alex's repo --- tensilelite/Tensile/Common.py | 6 ++ tensilelite/Tensile/Contractions.py | 6 ++ .../include/Tensile/ContractionProblem.hpp | 8 +- .../Tensile/ContractionProblemPredicates.hpp | 77 +++++++++++++++++++ .../Serialization/ContractionPredicates.hpp | 14 ++++ .../Source/lib/source/ContractionProblem.cpp | 37 +++++++++ 6 files changed, 147 insertions(+), 1 deletion(-) diff --git a/tensilelite/Tensile/Common.py b/tensilelite/Tensile/Common.py index 88568fb832..91ca7b79ca 100644 --- a/tensilelite/Tensile/Common.py +++ b/tensilelite/Tensile/Common.py @@ -700,6 +700,12 @@ def getArchitectureName(gfxName): # 1 indicates no assertion (since all sizes are multiples of 1) "AssertFree1ElementMultiple" : [1,2,4,8,16], + # Assertions that require arithmetic intensity to be specified value. + # Arithmetic intensity measures the ratio of computation to memory bandwidth required for a problem. + # These predicates can be used to adjust solution selection compute-bound or memory-bound problems. + "AssertAIGreaterThanEqual": -1, + "AssertAILessThanEqual": -1, + # Stagger the start summation position of the tiles. # Elements from the summation dimension are loaded at offsets rather than all starting at 0. # StaggerU is the max 'clicks' of StaggerUStride bytes where each wg starts ; see StaggerUMapping diff --git a/tensilelite/Tensile/Contractions.py b/tensilelite/Tensile/Contractions.py index e20320b918..48b679277c 100644 --- a/tensilelite/Tensile/Contractions.py +++ b/tensilelite/Tensile/Contractions.py @@ -384,6 +384,12 @@ class ProblemPredicate(Properties.Predicate): @classmethod def FromOriginalKeyPair(cls, pair): (key, value) = pair + # Arithmetic intensity assertions + if key == "AssertAIGreaterThanEqual": + return cls("AIGreaterThanEqual", value=value) if value > 0 else None + if key == "AssertAILessThanEqual": + return cls("AILessThanEqual", value=value) if value > 0 else None + if key.endswith('Multiple'): if value == 1: return None diff --git a/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblem.hpp b/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblem.hpp index 494227f05e..8496379dba 100644 --- a/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblem.hpp +++ b/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblem.hpp @@ -1027,6 +1027,11 @@ namespace Tensile return m_eligibleForPK; } + double arithmeticIntensity() const + { + return m_arithmeticIntensity; + } + virtual std::vector const constants() const { std::vector c = {{"alpha", m_alphaType}, {"beta", m_betaType}}; @@ -1103,7 +1108,7 @@ namespace Tensile KernelLanguage m_kernelLanguage = KernelLanguage::Any; PerformanceMetric m_performanceMetric = PerformanceMetric::DeviceEfficiency; - + double m_arithmeticIntensity; DataType m_alphaType = DataType::None; // if not assigned, will follow d-type DataType m_betaType = DataType::None; // for bwd-compatible DataType m_scaleAType = DataType::None; // if not assigned, will follow alpha-type @@ -1145,6 +1150,7 @@ namespace Tensile void normalize(); void normalizeSparse(); + void calcArithmeticIntensity(); void consistencyCheck() const; diff --git a/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp b/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp index ab7b63b939..4ed2e32390 100644 --- a/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp +++ b/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp @@ -1015,6 +1015,83 @@ namespace Tensile } }; + struct AIGreaterThanEqual + : public Predicate_CRTP + { + enum + { + HasIndex = false, + HasValue = true + }; + + double value; + + AIGreaterThanEqual() = default; + AIGreaterThanEqual(double value) + : value(value) + { + } + + static std::string Type() + { + return "AIGreaterThanEqual"; + } + + virtual bool operator()(ContractionProblem const& problem) const override + { + return problem.arithmeticIntensity() >= value; + } + + virtual bool debugEval(ContractionProblem const& problem, + std::ostream& stream) const override + { + bool rv = (*this)(problem); + + stream << *this << ": (" << problem.arithmeticIntensity() << " >= " << value + << ") == " << rv; + + return rv; + } + }; + + struct AILessThanEqual : public Predicate_CRTP + { + enum + { + HasIndex = false, + HasValue = true + }; + + double value; + + AILessThanEqual() = default; + AILessThanEqual(double value) + : value(value) + { + } + + static std::string Type() + { + return "AILessThanEqual"; + } + + virtual bool operator()(ContractionProblem const& problem) const override + { + return problem.arithmeticIntensity() <= value; + } + + virtual bool debugEval(ContractionProblem const& problem, + std::ostream& stream) const override + { + bool rv = (*this)(problem); + + stream << *this << ": (" << problem.arithmeticIntensity() << " <= " << value + << ") == " << rv; + + return rv; + } + }; + struct AlphaValue : public Predicate_CRTP { enum diff --git a/tensilelite/Tensile/Source/lib/include/Tensile/Serialization/ContractionPredicates.hpp b/tensilelite/Tensile/Source/lib/include/Tensile/Serialization/ContractionPredicates.hpp index 0bfdb91287..1e811bef3d 100644 --- a/tensilelite/Tensile/Source/lib/include/Tensile/Serialization/ContractionPredicates.hpp +++ b/tensilelite/Tensile/Source/lib/include/Tensile/Serialization/ContractionPredicates.hpp @@ -75,6 +75,8 @@ namespace Tensile Base::template Pair(), Base::template Pair(), Base::template Pair(), + Base::template Pair(), + Base::template Pair(), Base::template Pair(), Base::template Pair(), Base::template Pair(), @@ -245,6 +247,18 @@ namespace Tensile { }; + template + struct MappingTraits + : public AutoMappingTraits + { + }; + + template + struct MappingTraits + : public AutoMappingTraits + { + }; + template struct MappingTraits : public AutoMappingTraits diff --git a/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp b/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp index 03e65486a1..02890b7b22 100644 --- a/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp +++ b/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp @@ -608,6 +608,7 @@ namespace Tensile m_beta); // Set enum using beta to potentially allow for faster solutions consistencyCheck(); normalize(); + calcArithmeticIntensity(); } size_t ContractionProblemGemm::toAPos(size_t idx) const @@ -1065,6 +1066,42 @@ namespace Tensile TENSILE_ASSERT_EXC(dUse == 1); } + void ContractionProblem::calcArithmeticIntensity() + { + size_t problemSize = 1; + for(size_t i = 0; i < m_problemSizes.size(); ++i) + { + problemSize *= m_problemSizes[i]; + } + double gflop = 2 * problemSize * 1e-9; + + size_t aSize = 1; + for(size_t i = 0; i < m_a.dimensions(); ++i) + { + aSize *= m_a.sizes()[i]; + } + size_t bSize = 1; + for(size_t i = 0; i < m_b.dimensions(); ++i) + { + bSize *= m_b.sizes()[i]; + } + size_t cSize = 1; + for(size_t i = 0; i < m_c.dimensions(); ++i) + { + cSize *= m_c.sizes()[i]; + } + if(m_beta != 0) // If problem includes beta, update gflops and gbytes + { + gflop += 2 * cSize * 1e-9; // Include (+ beta * C) in gflops + cSize *= 2; // Include read C and write D in gbytes + } + double gbyte + = (aSize * m_a.elementBytes() + bSize * m_b.elementBytes() + cSize * m_c.elementBytes()) + * 1e-9; + + m_arithmeticIntensity = gflop / gbyte; + } + size_t ContractionProblemGemm::freeSizeA(size_t idx) const { return m_freeSizesA.at(idx); From 260ed3e569b57ba0164659041b706d7b2217c032 Mon Sep 17 00:00:00 2001 From: "Aditya.Joshi" Date: Tue, 2 Jul 2024 16:49:51 +0000 Subject: [PATCH 2/2] Change ContractionProblem to ContractionProblemGemm and adding default vals in common.py --- tensilelite/Tensile/Common.py | 3 +++ .../include/Tensile/ContractionProblemPredicates.hpp | 12 ++++++------ .../Tensile/Source/lib/source/ContractionProblem.cpp | 2 +- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/tensilelite/Tensile/Common.py b/tensilelite/Tensile/Common.py index 91ca7b79ca..a74276b2eb 100644 --- a/tensilelite/Tensile/Common.py +++ b/tensilelite/Tensile/Common.py @@ -1136,6 +1136,9 @@ def getArchitectureName(gfxName): {"AssertSummationElementMultiple": [ 1 ] }, {"AssertFree0ElementMultiple": [ 1 ] }, {"AssertFree1ElementMultiple": [ 1 ] }, + + {"AssertAIGreaterThanEqual": [-1]}, + {"AssertAILessThanEqual": [-1]}, {"StaggerU": [ 32 ] }, # recommend [0,32] {"StaggerUStride": [ 256 ] }, # recommend 256 for V10,V20 diff --git a/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp b/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp index 4ed2e32390..7a52365097 100644 --- a/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp +++ b/tensilelite/Tensile/Source/lib/include/Tensile/ContractionProblemPredicates.hpp @@ -1016,7 +1016,7 @@ namespace Tensile }; struct AIGreaterThanEqual - : public Predicate_CRTP + : public Predicate_CRTP { enum { @@ -1037,12 +1037,12 @@ namespace Tensile return "AIGreaterThanEqual"; } - virtual bool operator()(ContractionProblem const& problem) const override + virtual bool operator()(ContractionProblemGemm const& problem) const override { return problem.arithmeticIntensity() >= value; } - virtual bool debugEval(ContractionProblem const& problem, + virtual bool debugEval(ContractionProblemGemm const& problem, std::ostream& stream) const override { bool rv = (*this)(problem); @@ -1054,7 +1054,7 @@ namespace Tensile } }; - struct AILessThanEqual : public Predicate_CRTP + struct AILessThanEqual : public Predicate_CRTP { enum { @@ -1075,12 +1075,12 @@ namespace Tensile return "AILessThanEqual"; } - virtual bool operator()(ContractionProblem const& problem) const override + virtual bool operator()(ContractionProblemGemm const& problem) const override { return problem.arithmeticIntensity() <= value; } - virtual bool debugEval(ContractionProblem const& problem, + virtual bool debugEval(ContractionProblemGemm const& problem, std::ostream& stream) const override { bool rv = (*this)(problem); diff --git a/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp b/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp index 02890b7b22..9a67773bfd 100644 --- a/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp +++ b/tensilelite/Tensile/Source/lib/source/ContractionProblem.cpp @@ -1066,7 +1066,7 @@ namespace Tensile TENSILE_ASSERT_EXC(dUse == 1); } - void ContractionProblem::calcArithmeticIntensity() + void ContractionProblemGemm::calcArithmeticIntensity() { size_t problemSize = 1; for(size_t i = 0; i < m_problemSizes.size(); ++i)