integrations/tensorflow/compiler/PropagateResourceCasts.cpp

// Copyright 2020 Google LLC
//
// 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
//
//      https://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 "integrations/tensorflow/compiler/Passes.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "mlir/IR/Function.h"
#include "mlir/IR/StandardTypes.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_ops.h"
#include "tensorflow/compiler/mlir/tensorflow/ir/tf_types.h"

namespace mlir {
namespace iree_compiler {

namespace {
// Determine whether we should bypass the cast for input (a) to output (b).
bool shouldBypassCast(ShapedType a, ShapedType b) {
  // If the element type changes the cast is required.
  if (a.getElementType() != b.getElementType()) {
    return false;
  }

  // If we have no rank for the output we should bypass the cast.
  if (!b.hasRank()) {
    return true;
  }

  // If the input doesn't have a rank we can't gain informatio
  if (!a.hasRank()) {
    return false;
  }

  if (a.getRank() != b.getRank()) {
    return false;
  }

  auto a_shape = a.getShape();
  auto b_shape = b.getShape();
  for (auto pair : llvm::zip(a_shape, b_shape)) {
    auto a_dim = std::get<0>(pair);
    auto b_dim = std::get<1>(pair);
    if (a_dim != b_dim && a_dim == -1) {
      return false;
    }
  }
  return true;
}
}  // namespace

// Attempts to propagate resource casts by bypassing them when they are not
// necessary or can further refine required types.
class PropagateResourceCasts
    : public PassWrapper<PropagateResourceCasts, OperationPass<ModuleOp>> {
 public:
  void runOnOperation() override {
    auto operation = getOperation();
    for (auto func : operation.getOps<FuncOp>()) {
      for (auto cast : func.getOps<TF::CastOp>()) {
        auto input = cast.x();
        auto output = cast.getResult();

        auto input_ty = input.getType().cast<ShapedType>();
        auto output_ty = output.getType().cast<ShapedType>();

        // If the input/output types match we can just bypass it.
        if (input_ty == output_ty) {
          output.replaceAllUsesWith(input);
          continue;
        }

        auto input_element_ty =
            input_ty.getElementType().dyn_cast<TF::ResourceType>();
        auto output_element_ty =
            output_ty.getElementType().dyn_cast<TF::ResourceType>();

        // Check whether it is a
        if (!input_element_ty || !output_element_ty ||
            input_element_ty.getSubtypes().empty()) {
          continue;
        }

        auto input_resource_ty = input_element_ty.getSubtypes().front();
        if (!output_element_ty.getSubtypes().empty()) {
          auto output_resource_ty = output_element_ty.getSubtypes().front();
          if (!shouldBypassCast(input_resource_ty, output_resource_ty)) {
            continue;
          }
        }

        // TODO(suderman): Check which functions could be updated and
        // substitute.
        output.replaceAllUsesWith(input);
      }
    }
  }
};

std::unique_ptr<OperationPass<ModuleOp>> createPropagateResourceCasts() {
  return std::make_unique<PropagateResourceCasts>();
}

static PassRegistration<PropagateResourceCasts> pass(
    "iree-propagate-resource-casts",
    "Guarantee all func's have only a single use.");

}  // namespace iree_compiler
}  // namespace mlir