ScheduleOrderedAssignments.h

//===- ScheduleOrderedAssignments.h --- Assignment scheduling ---*- 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 defines a utility to analyze and schedule the evaluation of
// of hlfir::OrderedAssignmentTreeOpInterface trees that represent Fortran
// Forall, Where, user defined assignments and assignments to vector
// subscripted entities.
//===----------------------------------------------------------------------===//
 
#ifndef OPTIMIZER_HLFIR_TRANSFORM_SCHEDULEORDEREDASSIGNMENTS_H
#define OPTIMIZER_HLFIR_TRANSFORM_SCHEDULEORDEREDASSIGNMENTS_H
 
#include "flang/Optimizer/HLFIR/HLFIROps.h"
#include "mlir/Interfaces/SideEffectInterfaces.h"
#include <list>
 
namespace hlfir {
 
struct ElementalTree {
  // build an elemental tree given a masked region terminator.
  static ElementalTree buildElementalTree(mlir::Operation &regionTerminator);
  // Check if op is an ElementalOpInterface that is part of this elemental tree.
  bool contains(mlir::Operation *op) const;
 
  std::optional<bool> isOrdered(mlir::Operation *op) const;
 
private:
  void gatherElementalTree(hlfir::ElementalOpInterface elemental,
                           bool isAppliedInOrder);
  void insert(hlfir::ElementalOpInterface elementalOp, bool isAppliedInOrder);
  // List of ElementalOpInterface operation forming this tree, as well as a
  // Boolean to indicate if they are applied in order (that is, if their
  // indexing space is the same as the one for the array yielded by the mask
  // region that owns this tree).
  llvm::SmallVector<std::pair<mlir::Operation *, bool>> tree;
};

struct SaveEntity {
  mlir::Region *yieldRegion;
  mlir::Value getSavedValue();
};

class DetailedEffectInstance {
public:
  DetailedEffectInstance(mlir::MemoryEffects::Effect *effect,
                         mlir::OpOperand *value = nullptr,
                         mlir::Value orderedElementalEffectOn = nullptr);
  DetailedEffectInstance(mlir::MemoryEffects::EffectInstance effectInstance,
                         mlir::Value orderedElementalEffectOn = nullptr);
 
  static DetailedEffectInstance getArrayReadEffect(mlir::OpOperand *array);
  static DetailedEffectInstance getArrayWriteEffect(mlir::OpOperand *array);
 
  mlir::Value getValue() const { return effectInstance.getValue(); }
  mlir::MemoryEffects::Effect *getEffect() const {
    return effectInstance.getEffect();
  }
  mlir::Value getOrderedElementalEffectOn() const {
    return orderedElementalEffectOn;
  }
 
private:
  mlir::MemoryEffects::EffectInstance effectInstance;
  // Array whose elements are affected in array order by the
  // ordered assignment iterations. Null value otherwise.
  mlir::Value orderedElementalEffectOn;
};

struct Run {
  using Action = std::variant<hlfir::RegionAssignOp, SaveEntity>;
  llvm::SmallVector<Action> actions;
  llvm::SmallVector<DetailedEffectInstance> memoryEffects;
};

using Schedule = std::list<Run>;


Schedule buildEvaluationSchedule(hlfir::OrderedAssignmentTreeOpInterface root,
                                 bool tryFusingAssignments);
 
} // namespace hlfir
#endif // OPTIMIZER_HLFIR_TRANSFORM_SCHEDULEORDERASSIGNMENTS_H