//===- NumberOfExecutions.h - Number of executions analysis -----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains an analysis for computing how many times a block within a
// region is executed *each time* that region is entered. The analysis
// iterates over all associated regions that are attached to the given top-level
// operation.
//
// It is possible to query number of executions information on block level.
//
//===----------------------------------------------------------------------===//

#ifndef MLIR_ANALYSIS_NUMBER_OF_EXECUTIONS_H
#define MLIR_ANALYSIS_NUMBER_OF_EXECUTIONS_H

#include "mlir/Support/LLVM.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Optional.h"

namespace mlir {

class Block;
class BlockNumberOfExecutionsInfo;
class Operation;
class Region;

/// Represents an analysis for computing how many times a block or an operation
/// within a region is executed *each time* that region is entered. The analysis
/// iterates over all associated regions that are attached to the given
/// top-level operation.
///
/// This analysis assumes that all operations complete in a finite amount of
/// time (do not abort and do not go into the infinite loop).
class NumberOfExecutions {
public:
  /// Creates a new NumberOfExecutions analysis that computes how many times a
  /// block within a region is executed for all associated regions.
  explicit NumberOfExecutions(Operation *op);

  /// Returns the number of times operations `op` is executed *each time* the
  /// control flow enters the region `perEntryOfThisRegion`. Returns empty
  /// optional if this is not known statically.
  Optional<int64_t> getNumberOfExecutions(Operation *op,
                                          Region *perEntryOfThisRegion) const;

  /// Returns the number of times block `block` is executed *each time* the
  /// control flow enters the region `perEntryOfThisRegion`. Returns empty
  /// optional if this is not known statically.
  Optional<int64_t> getNumberOfExecutions(Block *block,
                                          Region *perEntryOfThisRegion) const;

  /// Dumps the number of block executions *each time* the control flow enters
  /// the region `perEntryOfThisRegion` to the given stream.
  void printBlockExecutions(raw_ostream &os,
                            Region *perEntryOfThisRegion) const;

  /// Dumps the number of operation executions *each time* the control flow
  /// enters the region `perEntryOfThisRegion` to the given stream.
  void printOperationExecutions(raw_ostream &os,
                                Region *perEntryOfThisRegion) const;

private:
  /// The operation this analysis was constructed from.
  Operation *operation;

  /// A mapping from blocks to number of executions information.
  DenseMap<Block *, BlockNumberOfExecutionsInfo> blockNumbersOfExecution;
};

/// Represents number of block executions information.
class BlockNumberOfExecutionsInfo {
public:
  BlockNumberOfExecutionsInfo(Block *block,
                              Optional<int64_t> numberOfRegionInvocations,
                              Optional<int64_t> numberOfBlockExecutions);

  /// Returns the number of times this block will be executed *each time* the
  /// parent operation is executed.
  Optional<int64_t> getNumberOfExecutions() const;

  /// Returns the number of times this block will be executed if the parent
  /// region is invoked `numberOfRegionInvocations` times. This can be different
  /// from the number of region invocations by the parent operation.
  Optional<int64_t>
  getNumberOfExecutions(int64_t numberOfRegionInvocations) const;

  Block *getBlock() const { return block; }

private:
  Block *block;

  /// Number of `block` parent region invocations *each time* parent operation
  /// is executed.
  Optional<int64_t> numberOfRegionInvocations;

  /// Number of `block` executions *each time* parent region is invoked.
  Optional<int64_t> numberOfBlockExecutions;
};

} // end namespace mlir

#endif // MLIR_ANALYSIS_NUMBER_OF_EXECUTIONS_H