integrations/tensorflow/compiler/GuaranteeAllFuncsOneUse.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 "mlir/IR/SymbolTable.h"
#include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassRegistry.h"
#include "mlir/Support/LLVM.h"
#include "mlir/Support/LogicalResult.h"
#include "mlir/Transforms/Utils.h"

namespace mlir {
namespace iree_compiler {

namespace {}  // namespace

// Clones FuncOp's until they have a single use only (or no users).
//
// The tf-shape-inference pass doesn't support functions that have more than
// a single use. But some real code from frontends does end up creating code
// like that. For example, the same LSTM cell function or loop body function
// will be reused.
//
// This pass clones functions as needed to establish the invariant that all
// functions have a single use. This can in principle cause exponential code
// size bloat, and should in general be guided by a proper cost model.
//
// There are two factors which should be considered by a principled replacement
// to this pass:
//
// 1. IREE currently relies on "sufficiently good shape inference" for
// correctness so for now the cost of doing this seems acceptable since
// pathological cases haven't hit us yet.
//
// 2. Cloning functions can help by allowing code to be specialized (much as
// inlining does). In fact, tf-shape-inference attempts to do specialization
// of callees which is difficult if callees have multiple uses.
class GuaranteeAllFuncsOneUse
    : public PassWrapper<GuaranteeAllFuncsOneUse, OperationPass<ModuleOp>> {
 public:
  void runOnOperation() override {
    if (failed(run())) {
      signalPassFailure();
    }
  }

  LogicalResult run() {
    auto module = getOperation();

    // Overall strategy:
    // Fixed point iteration, iteratively applying a rule that clones
    // any FuncOp with more than one use to eliminate its uses.

    SymbolTable symbolTable(module);
    bool madeChanges = false;
    // This value needs to be low enough to actually stop compilation in a
    // reasonable time, but not too low that it blocks real programs.
    // This number was chosen semi-randomly.
    const int kMaxClones = 1000;
    int numClones = 0;
    do {
      madeChanges = false;
      for (auto func : llvm::make_early_inc_range(module.getOps<FuncOp>())) {
        auto usesOptional = symbolTable.getSymbolUses(func, module);
        if (!usesOptional.hasValue()) {
          return func.emitError() << "could not walk uses of func";
        }
        auto &uses = *usesOptional;
        if (llvm::size(uses) <= 1) {
          continue;
        }
        // At this point, we know we are going to change the module.
        madeChanges = true;
        for (const SymbolTable::SymbolUse &use : llvm::drop_begin(uses, 1)) {
          auto newFunc = func.clone();
          if (numClones++ > kMaxClones) {
            return func.emitError()
                   << "reached cloning limit (likely recursive call graph or "
                      "repeated diamond-like call structure "
                      "or just very large program)";
          }
          symbolTable.insert(newFunc);
          newFunc.setVisibility(SymbolTable::Visibility::Private);
          if (failed(symbolTable.replaceAllSymbolUses(func, newFunc.getName(),
                                                      use.getUser()))) {
            return func.emitError() << "could not replace symbol use";
          }
        }
      }
    } while (madeChanges);

    return success();
  }
};

std::unique_ptr<OperationPass<ModuleOp>> createGuaranteeAllFuncsOneUse() {
  return std::make_unique<GuaranteeAllFuncsOneUse>();
}

static PassRegistration<GuaranteeAllFuncsOneUse> pass(
    "iree-guarantee-all-funcs-one-use",
    "Guarantee all func's have only a single use.");

}  // namespace iree_compiler
}  // namespace mlir