// Copyright (c) 2022 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 "paddle/fluid/framework/ir/mkldnn/elt_act_mkldnn_fuse_pass.h"

#include "paddle/fluid/framework/ir/graph_pattern_detector.h"
#include "paddle/fluid/framework/op_version_registry.h"
#include "paddle/fluid/platform/enforce.h"
#include "paddle/fluid/string/pretty_log.h"

namespace paddle {
namespace framework {
namespace ir {

using string::PrettyLogDetail;

void ElementwiseActivationOneDNNPass::ApplyImpl(Graph *graph) const {
  std::vector<std::string> act_types = {"relu",
                                        "tanh",
                                        "leaky_relu",
                                        "swish",
                                        "hard_swish",
                                        "sqrt",
                                        "abs",
                                        "clip",
                                        "gelu",
                                        "relu6",
                                        "sigmoid"};
  std::vector<std::string> elt_types = {
      "elementwise_add", "elementwise_sub", "elementwise_mul"};

  for (const auto &elt_type : elt_types)
    for (const auto &act_type : act_types) {
      std::unordered_map<std::string, std::string> attr_map;

      if (act_type == "swish")
        attr_map.emplace("beta", "activation_alpha");
      else if (act_type == "relu6")
        attr_map.emplace("threshold", "activation_alpha");
      else if (act_type == "clip") {
        attr_map.emplace("min", "activation_alpha");
        attr_map.emplace("max", "activation_beta");
      } else {
        attr_map.emplace("alpha", "activation_alpha");
        attr_map.emplace("beta", "activation_beta");
      }
      FuseElementwiseAct(graph, elt_type, act_type, attr_map);
    }
}

void ElementwiseActivationOneDNNPass::FuseElementwiseAct(
    Graph *graph,
    const std::string &elt_type,
    const std::string &act_type,
    const std::unordered_map<std::string, std::string> &attr_map) const {
  PADDLE_ENFORCE_NOT_NULL(
      graph, platform::errors::InvalidArgument("Graph cannot be nullptr."));
  FusePassBase::Init(elt_type + "_" + act_type + "_mkldnn_fuse_pass", graph);

  GraphPatternDetector gpd;
  auto *elementwise_input = gpd.mutable_pattern()
                                ->NewNode(elt_type + "_act/elementwise_input")
                                ->AsInput()
                                ->assert_is_op_input(elt_type, "X");
  patterns::ElementwiseActivation elementwise_act_pattern(gpd.mutable_pattern(),
                                                          elt_type + "_act");
  elementwise_act_pattern(elementwise_input, elt_type, act_type);

  int found_elementwise_activation_count = 0;
  auto handler = [&](const GraphPatternDetector::subgraph_t &subgraph,
                     Graph *g) {
    VLOG(4) << "Fuse " << elt_type << " with activation op.";
    // Elementwise output
    GET_IR_NODE_FROM_SUBGRAPH(
        elementwise_out, elementwise_out, elementwise_act_pattern);
    // ACT output
    GET_IR_NODE_FROM_SUBGRAPH(
        activation_out, activation_out, elementwise_act_pattern);
    // ops
    GET_IR_NODE_FROM_SUBGRAPH(
        elementwise, elementwise, elementwise_act_pattern);
    GET_IR_NODE_FROM_SUBGRAPH(activation, activation, elementwise_act_pattern);

    auto *elementwise_op = elementwise->Op();

    if (elementwise_op->HasAttr("use_mkldnn")) {
      const std::string wo_elt_type =
          "The " + elt_type;  // Workaround for PP error message checking.
      PADDLE_ENFORCE_EQ(
          BOOST_GET_CONST(bool, elementwise_op->GetAttr("use_mkldnn")),
          true,
          platform::errors::PreconditionNotMet(
              wo_elt_type + "+Act fusion may happen only when oneDNN library "
                            "is used."));
    }

    auto *activation_op = activation->Op();
    for (const auto &attr : attr_map) {
      if (activation_op->HasAttr(attr.first)) {
        elementwise_op->SetAttr(attr.second,
                                activation_op->GetAttr(attr.first));
      }
    }

    if (act_type == "gelu" && activation_op->HasAttr("approximate") &&
        BOOST_GET_CONST(bool, activation_op->GetAttr("approximate")))
      elementwise_op->SetAttr("activation_type", std::string("gelu_tanh"));
    else
      elementwise_op->SetAttr("activation_type", act_type);

    elementwise_op->SetOutput("Out", {activation_out->Name()});

    IR_OP_VAR_LINK(elementwise, activation_out);
    GraphSafeRemoveNodes(g, {activation, elementwise_out});
    found_elementwise_activation_count++;
  };

  gpd(graph, handler);
  AddStatis(found_elementwise_activation_count);
  PrettyLogDetail("---    fused %d %s with %s activation",
                  found_elementwise_activation_count,
                  elt_type,
                  act_type);
}

}  // namespace ir
}  // namespace framework
}  // namespace paddle

REGISTER_PASS(elt_act_mkldnn_fuse_pass,
              paddle::framework::ir::ElementwiseActivationOneDNNPass);
REGISTER_PASS_CAPABILITY(elt_act_mkldnn_fuse_pass)
    .AddCombination(
        paddle::framework::compatible::OpVersionComparatorCombination()
            .LE("elementwise_add", 1)
            .LE("elementwise_sub", 1)
            .LE("elementwise_mul", 1)
            .LE("relu", 0)
            .LE("tanh", 0)
            .LE("leaky_relu", 1)
            .LE("swish", 0)
            .LE("hard_swish", 0)
            .LE("sqrt", 0)
            .LE("abs", 0)
            .LE("clip", 1)
            .LE("gelu", 0)
            .LE("relu6", 0)
            .LE("sigmoid", 0));
