diff --git a/paddle/fluid/ir/dialect/op_gen.py b/paddle/fluid/ir/dialect/op_gen.py index 6ad080756f2d5ec585621684fae9dca882250206..89ac8b0157f636bc7eba7b1e86be14288a17c423 100644 --- a/paddle/fluid/ir/dialect/op_gen.py +++ b/paddle/fluid/ir/dialect/op_gen.py @@ -249,6 +249,15 @@ def to_phi_and_fluid_op_name(op_item): return phi_name, fluid_name +scalar_type_maps = { + 'int': 'ir::Int32_tAttribute', + 'int64_t': 'ir::Int64_tAttribute', + 'float': 'ir::FloatAttribute', + 'dobule': 'ir::DoubleAttribute', + 'bool': 'ir::BoolAttribute', +} + + # ===================================== # Parse Op Compat From Yaml # ===================================== @@ -298,10 +307,10 @@ class OpInfoParser: self.attr_types_map = { 'IntArray': ['paddle::dialect::IntArrayAttribute', 'IntArray'], 'Scalar': ['paddle::dialect::ScalarAttribute', 'Scalar'], - 'Scalar(int)': ['paddle::dialect::ScalarAttribute', 'int'], - 'Scalar(int64_t)': ['paddle::dialect::ScalarAttribute', 'int64_t'], - 'Scalar(float)': ['paddle::dialect::ScalarAttribute', 'float'], - 'Scalar(dobule)': ['paddle::dialect::ScalarAttribute', 'dobule'], + 'Scalar(int)': ['ir::Int32_tAttribute', 'int'], + 'Scalar(int64_t)': ['ir::Int64_tAttribute', 'int64_t'], + 'Scalar(float)': ['ir::FloatAttribute', 'float'], + 'Scalar(dobule)': ['ir::DoubleAttribute', 'dobule'], 'Scalar[]': [ 'ir::ArrayAttribute', 'std::vector', @@ -707,7 +716,7 @@ def GenBuildAttributes( ): INTARRAY_STR_TEMPLATE = """ ir::Attribute attr_{attr_name} = {op_attribute_type}::get(ir::IrContext::Instance(), phi::IntArray({attr})); """ - SCALAR_STR_TEMPLATE = """ ir::Attribute attr_{attr_name} = {op_attribute_type}::get(ir::IrContext::Instance(), phi::Scalar({attr})); + SCALAR_STR_TEMPLATE = """ ir::Attribute attr_{attr_name} = TransToIrAttribute({attr}, ir::IrContext::Instance()); """ STR_TEMPLATE = """ ir::Attribute attr_{attr_name} = {op_attribute_type}::get(ir::IrContext::Instance(), {attr}); """ @@ -742,7 +751,6 @@ def GenBuildAttributes( + ".size()", create_attribute=SCALAR_STR_TEMPLATE.format( attr_name=op_non_mutable_attribute_name_list[idx], - op_attribute_type=inner_attribute_type, attr=op_non_mutable_attribute_name_list[idx] + "[i]", ), ) @@ -773,7 +781,6 @@ def GenBuildAttributes( ): attr_str += SCALAR_STR_TEMPLATE.format( attr_name=op_non_mutable_attribute_name_list[idx], - op_attribute_type=op_non_mutable_attribute_type_list[idx], attr=op_non_mutable_attribute_name_list[idx], ) else: @@ -828,7 +835,7 @@ def GenBuildOutputs( }} """ CREATE_INTARRAY_MUTABLE_ATTRIBUE_TEMPLATE = """ std::vector {name} = {name}_.owner()->dyn_cast().value().dyn_cast().data().GetData(); (void){name};\n""" - CREATE_SCALAR_MUTABLE_ATTRIBUE_TEMPLATE = """ {dtype} {name} = {name}_.owner()->dyn_cast().value().dyn_cast().data().to<{dtype}>(); (void){name};\n""" + CREATE_SCALAR_MUTABLE_ATTRIBUE_TEMPLATE = """ {dtype} {name} = {name}_.owner()->dyn_cast().value().dyn_cast<{ir_type}>().data(); (void){name};\n""" CREATE_STRING_MUTABLE_ATTRIBUE_TEMPLATE = """ std::string {name} = {name}_.owner()->dyn_cast().value().dyn_cast().data(); (void){name};\n""" CREATE_OUTPUT_METATENSOR_TEMPLATE = """ phi::DenseTensor dense_{name}; @@ -869,7 +876,9 @@ def GenBuildOutputs( # scalar elif attr_dtype[0] == "paddle::dialect::ScalarAttribute": build_output_str += CREATE_SCALAR_MUTABLE_ATTRIBUE_TEMPLATE.format( - name=op_mutable_attribute_name_list[idx], dtype=attr_dtype[1] + name=op_mutable_attribute_name_list[idx], + dtype=attr_dtype[1], + ir_type=scalar_type_maps[attr_dtype[1]], ) # string elif attr_dtype[0] == "ir::StrAttribute": diff --git a/paddle/fluid/ir/dialect/pd_attribute.cc b/paddle/fluid/ir/dialect/pd_attribute.cc index c151aaab8012f246c85028247844935f3f197dd0..4829010609d5570a46bb379516dfc71e948e0d46 100644 --- a/paddle/fluid/ir/dialect/pd_attribute.cc +++ b/paddle/fluid/ir/dialect/pd_attribute.cc @@ -18,10 +18,6 @@ namespace paddle { namespace dialect { phi::IntArray IntArrayAttribute::data() const { return storage()->GetAsKey(); } -paddle::experimental::Scalar ScalarAttribute::data() const { - return storage()->GetAsKey(); -} - phi::DataType DataTypeAttribute::data() const { return storage()->GetAsKey(); } phi::Place PlaceAttribute::data() const { return storage()->GetAsKey(); } diff --git a/paddle/fluid/ir/dialect/pd_attribute.h b/paddle/fluid/ir/dialect/pd_attribute.h index 22825443a7d6f843589fee0dd41e598681e0972f..67093f965539f27fdc672472c39741108e130193 100644 --- a/paddle/fluid/ir/dialect/pd_attribute.h +++ b/paddle/fluid/ir/dialect/pd_attribute.h @@ -16,6 +16,7 @@ #include "paddle/fluid/ir/dialect/pd_attribute_storage.h" #include "paddle/ir/core/attribute.h" +#include "paddle/ir/core/builtin_attribute.h" namespace paddle { namespace dialect { @@ -37,13 +38,13 @@ class ScalarAttribute : public ir::Attribute { public: using Attribute::Attribute; - DECLARE_ATTRIBUTE_UTILITY_FUNCTOR(ScalarAttribute, ScalarAttributeStorage); - - bool operator<(const ScalarAttribute &right) const { - return storage() < right.storage(); + static bool classof(ir::Attribute val) { + return (val.type_id() == ir::BoolAttribute::type_id()) || + (val.type_id() == ir::FloatAttribute::type_id()) || + (val.type_id() == ir::DoubleAttribute::type_id()) || + (val.type_id() == ir::Int32_tAttribute::type_id()) || + (val.type_id() == ir::Int64_tAttribute::type_id()); } - - paddle::experimental::Scalar data() const; }; class DataTypeAttribute : public ir::Attribute { diff --git a/paddle/fluid/ir/dialect/pd_attribute_storage.h b/paddle/fluid/ir/dialect/pd_attribute_storage.h index 4bf4f3427c7f3802005909b4c7118511c70e08c1..6270791f725d4f0b5b7311f44a5de060be6fe850 100644 --- a/paddle/fluid/ir/dialect/pd_attribute_storage.h +++ b/paddle/fluid/ir/dialect/pd_attribute_storage.h @@ -20,7 +20,6 @@ #include "paddle/phi/common/int_array.h" #include "paddle/phi/common/layout.h" #include "paddle/phi/common/place.h" -#include "paddle/phi/common/scalar.h" namespace paddle { namespace dialect { @@ -54,28 +53,6 @@ struct IntArrayAttributeStorage : public ir::AttributeStorage { phi::IntArray data_; }; -struct ScalarAttributeStorage : public ir::AttributeStorage { - using ParamKey = paddle::experimental::Scalar; - - explicit ScalarAttributeStorage(const ParamKey &key) { data_ = key; } - - static ScalarAttributeStorage *Construct(ParamKey key) { - return new ScalarAttributeStorage(key); - } - - static std::size_t HashValue(const ParamKey &key) { - return ir::hash_combine(std::hash()(key.ToString()), - std::hash()(key.FromTensor())); - } - - bool operator==(const ParamKey &key) const { return data_ == key; } - - ParamKey GetAsKey() const { return ParamKey(data_); } - - private: - paddle::experimental::Scalar data_; -}; - struct DataTypeAttributeStorage : public ir::AttributeStorage { using ParamKey = phi::DataType; diff --git a/paddle/fluid/ir/dialect/pd_dialect.cc b/paddle/fluid/ir/dialect/pd_dialect.cc index ccc089fda18b026a8c89198316442559d0982af1..d7b4b599b55fe613962ddee955d7ff10c6fa4524 100644 --- a/paddle/fluid/ir/dialect/pd_dialect.cc +++ b/paddle/fluid/ir/dialect/pd_dialect.cc @@ -92,7 +92,6 @@ void PaddleDialect::initialize() { RegisterTypes(); RegisterAttributes(); diff --git a/paddle/fluid/ir/dialect/utils.h b/paddle/fluid/ir/dialect/utils.h index 7d629fd6c1322ec55780d37d792ec6463b2dacff..65f68db2c6a586f725e222b90bf137a25dc60e23 100644 --- a/paddle/fluid/ir/dialect/utils.h +++ b/paddle/fluid/ir/dialect/utils.h @@ -17,14 +17,16 @@ #include "paddle/fluid/framework/convert_utils.h" #include "paddle/fluid/framework/data_type.h" #include "paddle/fluid/ir/dialect/pd_type_storage.h" +#include "paddle/ir/core/builtin_attribute.h" #include "paddle/ir/core/builtin_type.h" +#include "paddle/phi/common/scalar.h" #include "paddle/phi/core/dense_tensor.h" namespace paddle { namespace dialect { // TODO(zhangbo): The builtin type needs to cover all data types of // phi::DataType. -inline phi::DataType TransToPhiDataType(ir::Type dtype) { +static inline phi::DataType TransToPhiDataType(ir::Type dtype) { if (dtype.isa()) { return phi::DataType::FLOAT16; } else if (dtype.isa()) { @@ -44,8 +46,8 @@ inline phi::DataType TransToPhiDataType(ir::Type dtype) { } } -inline ir::Type TransToIrDataType(phi::DataType dtype, - ir::IrContext *ctx = nullptr) { +static inline ir::Type TransToIrDataType(phi::DataType dtype, + ir::IrContext *ctx = nullptr) { if (ctx == nullptr) { ctx = ir::IrContext::Instance(); } @@ -70,6 +72,30 @@ inline ir::Type TransToIrDataType(phi::DataType dtype, } } +static inline ir::Attribute TransToIrAttribute(phi::Scalar scalar, + ir::IrContext *ctx = nullptr) { + if (ctx == nullptr) { + ctx = ir::IrContext::Instance(); + } + switch (scalar.dtype()) { + case phi::DataType::FLOAT32: + return ir::FloatAttribute::get(ctx, scalar.to()); + case phi::DataType::FLOAT64: + return ir::DoubleAttribute::get(ctx, scalar.to()); + case phi::DataType::INT32: + return ir::Int32_tAttribute::get(ctx, scalar.to()); + case phi::DataType::INT64: + return ir::Int64_tAttribute::get(ctx, scalar.to()); + case phi::DataType::BOOL: + return ir::BoolAttribute::get(ctx, scalar.to()); + default: + PADDLE_THROW(phi::errors::Unimplemented( + "Unsupported phi data type `%s` when casting it into " + "ir attribute.", + scalar.dtype())); + } +} + struct OpInputInfo { std::string name; std::string type_name; diff --git a/paddle/fluid/ir_adaptor/translator/attribute_translator.cc b/paddle/fluid/ir_adaptor/translator/attribute_translator.cc index 67c323a42c679a2c6919443f86e8de1522dfbcba..f2da12c6643d94f43f6ddf761804341a208dbae0 100644 --- a/paddle/fluid/ir_adaptor/translator/attribute_translator.cc +++ b/paddle/fluid/ir_adaptor/translator/attribute_translator.cc @@ -18,6 +18,7 @@ #include #include "paddle/fluid/ir/dialect/pd_attribute.h" +#include "paddle/ir/core/enforce.h" #include "paddle/phi/common/data_type.h" #include "paddle/phi/common/int_array.h" #include "paddle/phi/common/layout.h" @@ -62,7 +63,7 @@ class AttributeVisitor { virtual ir::Attribute operator()(const paddle::experimental::Scalar& scalar) { VLOG(10) << "translating scalar"; - return paddle::dialect::ScalarAttribute::get(ctx, scalar); + IR_THROW("not support translating paddle::experimental::Scalar"); } virtual ir::Attribute operator()(const std::vector& strs) { @@ -128,12 +129,8 @@ class AttributeVisitor { virtual ir::Attribute operator()( const std::vector& ss) { VLOG(10) << "translating vector"; - std::vector attrs; - attrs.reserve(ss.size()); - for (const auto& v : ss) { - attrs.push_back(paddle::dialect::ScalarAttribute::get(ctx, v)); - } - return ir::ArrayAttribute::get(ctx, attrs); + IR_THROW( + "not support translating std::vector"); } virtual ir::Attribute operator()(const paddle::blank& blank) { @@ -164,22 +161,6 @@ class IntArrayAttributeVisitor : public AttributeVisitor { } }; -class ScalarAttributeVisitor : public AttributeVisitor { - public: - using AttributeVisitor::AttributeVisitor; - ir::Attribute operator()(int i) override { - VLOG(10) << "translating int to Scalar"; - phi::Scalar data(i); - return paddle::dialect::ScalarAttribute::get(ctx, data); - } - - ir::Attribute operator()(float f) override { - VLOG(10) << "translating float to Scalar"; - phi::Scalar data(f); - return paddle::dialect::ScalarAttribute::get(ctx, data); - } -}; - class DataTypeAttributeVisitor : public AttributeVisitor { public: using AttributeVisitor::AttributeVisitor; @@ -205,8 +186,6 @@ AttributeTranslator::AttributeTranslator() { general_visitor = new AttributeVisitor(); special_visitors["paddle::dialect::IntArrayAttribute"] = new IntArrayAttributeVisitor(); - special_visitors["paddle::dialect::ScalarAttribute"] = - new ScalarAttributeVisitor(); special_visitors["paddle::dialect::DataTypeAttribute"] = new DataTypeAttributeVisitor(); special_visitors["paddle::dialect::PlaceAttribute"] = diff --git a/test/cpp/ir/core/CMakeLists.txt b/test/cpp/ir/core/CMakeLists.txt index 2cd6030faa0950459eeb7e07864945ad2142f1ae..111da5c3e29ef52d46b9db084d83d13315e445ac 100644 --- a/test/cpp/ir/core/CMakeLists.txt +++ b/test/cpp/ir/core/CMakeLists.txt @@ -32,6 +32,15 @@ cc_test_old( phi gtest) +cc_test_old( + scalar_attribute_test + SRCS + scalar_attribute_test.cc + DEPS + pd_dialect + new_ir + gtest) + file( DOWNLOAD https://paddle-ci.gz.bcebos.com/ir_translator_test/restnet50_main.prog diff --git a/test/cpp/ir/core/ir_exe_test.cc b/test/cpp/ir/core/ir_exe_test.cc index e8227982fbeaf28a6e538a5d453d5c7a021eea6f..0ca3b99681888d0d594b76e6915838b7efbe6f53 100644 --- a/test/cpp/ir/core/ir_exe_test.cc +++ b/test/cpp/ir/core/ir_exe_test.cc @@ -74,10 +74,8 @@ TEST(program_test, program) { ctx, std::vector({2, 2})); ir::Attribute data_type = paddle::dialect::DataTypeAttribute::get(ctx, phi::DataType::FLOAT32); - ir::Attribute min = - paddle::dialect::ScalarAttribute::get(ctx, phi::Scalar(0.0)); - ir::Attribute max = - paddle::dialect::ScalarAttribute::get(ctx, phi::Scalar(1.0)); + ir::Attribute min = ir::FloatAttribute::get(ctx, 0.0); + ir::Attribute max = ir::FloatAttribute::get(ctx, 1.0); ir::Attribute seed = ir::Int32_tAttribute::get(ctx, 2); ir::Attribute uni_place = paddle::dialect::PlaceAttribute::get( ctx, phi::Place(phi::AllocationType::CPU)); diff --git a/test/cpp/ir/core/phi_kernel_adaptor.h b/test/cpp/ir/core/phi_kernel_adaptor.h index 601e37649c5fa5846fec2bb581d62443280280a8..4916582dfbf0b30fac65884e51ba0a922e39f651 100644 --- a/test/cpp/ir/core/phi_kernel_adaptor.h +++ b/test/cpp/ir/core/phi_kernel_adaptor.h @@ -143,9 +143,6 @@ void build_context(ir::Operation* op, } else if (type_name == "paddle::dialect::DataTypeAttribute") { ctx->EmplaceBackAttr( attr_map[t].dyn_cast().data()); - } else if (type_name == "paddle::dialect::ScalarAttribute") { - ctx->EmplaceBackAttr( - attr_map[t].dyn_cast().data()); } else if (type_name == "ir::Int32_tAttribute") { ctx->EmplaceBackAttr( attr_map[t].dyn_cast().data()); diff --git a/test/cpp/ir/core/scalar_attribute_test.cc b/test/cpp/ir/core/scalar_attribute_test.cc new file mode 100644 index 0000000000000000000000000000000000000000..c2292357f412df2f0bf6c05597ffabfb1ad52340 --- /dev/null +++ b/test/cpp/ir/core/scalar_attribute_test.cc @@ -0,0 +1,55 @@ +// Copyright (c) 2023 PaddlePaddle Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include + +#include "paddle/fluid/ir/dialect/pd_attribute.h" +#include "paddle/ir/core/attribute.h" +#include "paddle/ir/core/builtin_attribute.h" +#include "paddle/ir/core/builtin_dialect.h" +#include "paddle/ir/core/dialect.h" +#include "paddle/ir/core/ir_context.h" + +using ScalarAttribute = paddle::dialect::ScalarAttribute; + +TEST(ScalarTest, base) { + ir::IrContext *ctx = ir::IrContext::Instance(); + + ir::Attribute bool_scalar = ir::BoolAttribute::get(ctx, false); + EXPECT_TRUE(bool_scalar.isa()); + EXPECT_TRUE(bool_scalar.isa()); + ir::BoolAttribute pure_bool = bool_scalar.dyn_cast(); + EXPECT_TRUE(pure_bool.isa()); + ScalarAttribute scalar_from_bool = bool_scalar.dyn_cast(); + EXPECT_TRUE(scalar_from_bool.isa()); + EXPECT_NO_THROW(scalar_from_bool.dyn_cast()); +} + +TEST(ScalarTest, test_classof) { + ir::IrContext *ctx = ir::IrContext::Instance(); + ir::Attribute bool_scalar = ir::BoolAttribute::get(ctx, false); + EXPECT_TRUE(bool_scalar.isa()); + + ir::Attribute float_scalar = ir::FloatAttribute::get(ctx, 1.0f); + EXPECT_TRUE(float_scalar.isa()); + + ir::Attribute double_scalar = ir::DoubleAttribute::get(ctx, 1.0); + EXPECT_TRUE(double_scalar.isa()); + + ir::Attribute int32_scalar = ir::Int32_tAttribute::get(ctx, 1); + EXPECT_TRUE(int32_scalar.isa()); + + ir::Attribute int64_scalar = ir::Int64_tAttribute::get(ctx, 1l); + EXPECT_TRUE(int64_scalar.isa()); +}