llvm
/
torch-mlir
mirror of https://github.com/llvm/torch-mlir
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
torch-mlir/include/npcomp/E2E/Passes.td

71 lines
2.6 KiB
TableGen
Raw Normal View History

Initial TCF/TCP E2E seed. Very much WIP. This is enough to get tcf.add down to approximately the "linalg.generic on buffers" level of abstraction. (but there are nuances)
2020-05-07 09:41:54 +08:00
//===-- Passes.td - Pass definition file -------------------*- tablegen -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef NPCOMP_E2E_PASSES
#define NPCOMP_E2E_PASSES
include "mlir/Pass/PassBase.td"
def LowerLinalgOnTensorToLinalgOnMemref :
Pass<"lower-linalg-tensor-to-memref", "FuncOp"> {
let summary = "Lowers linalg on tensors to linalg on memrefs";
let constructor = "mlir::NPCOMP::createLowerLinalgOnTensorToLinalgOnMemrefPass()";
}
def LowerBroadcastToToLoops :
Pass<"lower-broadcast-to-to-loops", "FuncOp"> {
let summary = "Lower tcp::BroadcastTo to loops.";
let constructor = "mlir::NPCOMP::createLowerBroadcastToToLoopsPass()";
}
npcomprt: add support for constants - create tcp.global + tcp.get_global_memref - create npcomprt.global + npcomprt.get_global - LLVM lowering for new npcomprt ops - Runtime: - GlobalDescriptor struct emitted by LLVM lowering - implement __npcomp_compiler_rt_get_global Also, - cleanly isolate all runtime data structure definitions shared by the compiler and runtime into lib/runtime/CompilerDataStructures.h
2020-07-11 08:31:24 +08:00
def LowerConstantTensorsToMemrefs :
Pass<"lower-constant-tensors-to-memrefs", "ModuleOp"> {
let summary = "Lower std.constant of tensor type to hybrid tensor/memref.";
let description = [{
This has to be a module pass since it involves creating tcp.global ops.
}];
let constructor = "mlir::NPCOMP::createLowerConstantTensorsToMemrefsPass()";
}
Initial TCF/TCP E2E seed. Very much WIP. This is enough to get tcf.add down to approximately the "linalg.generic on buffers" level of abstraction. (but there are nuances)
2020-05-07 09:41:54 +08:00
def ResolveShapeOfOps : Pass<"resolve-shape-of-ops", "FuncOp"> {
let summary = "Resolve shape.shape_of ops to other shapes.";
let constructor = "mlir::NPCOMP::createResolveShapeOfOpsPass()";
}
"Finish" tensor -> memref conversion. There's a lot of details to flesh out here, but the basic approach seems promising (see comments in createE2ELoweringPipeline). This approach will be put to the test when we try to do our first fusions since that tickles some of the nasty phase ordering issues involved here. But we're not there yet.
2020-05-12 05:24:57 +08:00
def ResolveTensorLoadStoreOps : Pass<"resolve-tensor-load-store-ops", "FuncOp"> {
let summary = "Resolve tensor_load/tensor_store ops";
let constructor = "mlir::NPCOMP::createResolveTensorLoadStoreOpsPass()";
}
Add lowering from linalg to loops. This also adds a small pass to clean up the `dim` ops that linalg introduces. For now, it only has a trivial pattern that looks for a `tcp.alloc_memref(%shape)` op to get the shape as we currently have an invariant that all memrefs are the result of such ops. But eventually this will need to look through view ops and any other shape-ish stuff that linalg introduces as it lowers to loops, along with any slicing ops introduced by buffer allocation.
2020-05-12 09:50:51 +08:00
def LowerLinalgLoopDimOps : Pass<"lower-linalg-loop-dim-ops", "FuncOp"> {
let summary = "Lower dim ops introduced by linalg to loops lowering";
let constructor = "mlir::NPCOMP::createLowerLinalgLoopDimOpsPass();";
}
Lower !shape.shape to SSA values. This uses an approach inspired by what is done in IREE. See comments on LowerRankedShapes.cpp for how it works. The basic gist is that we have an op that creates a !shape.shape from a set of SSA values representing the extents, and then iteratively replace any op producing a !shape.shape with instances of that op.
2020-05-12 12:22:40 +08:00
def LowerRankedShapes : Pass<"lower-ranked-shapes", "FuncOp"> {
let summary = "Lower ranked !shape.shape types to SSA values";
let constructor = "mlir::NPCOMP::createLowerRankedShapesPass()";
}
Rework e2e flow to use new "npcomprt" This ~totally reworks the existing "runtime" stuff to be more principled and usable, such as from Python. It's still not fully production-quality, mainly in the department of memory management (e.g. it currently leaks memory; we need to figure out "who frees memrefs" + the analysis and transformation needed to do that (maybe use upstream buffer allocation pass?)). The user API is in include/npcomp/runtime/UserAPI.h, though include/npcomp/JITRuntime/JITModule.h is a friendlier wrapper. The stuff under {include,lib}/runtime is totally firewalled from the compiler and tiny (<6kB, though no attention has gone into optimizing that size). For example, we don't link in libSupport into the runtime, instead having our own bare bones replacements for basics like ArrayRef (the JITRuntime helps with bridging that gap, since it *can* depend on all common LLVM utilities). The overall features of npcomprt is that it exposes a module that with multiple function entry points. Each function has arguments and results that are tensor-valued, and npcomprt::Tensor is the runtime type that is used to interact with that (and a npcomprt::Ref<T> reference-counting wrapper is provided to wrap npcomprt::Tensor in the common case). From an implementation perspective, an npcomprt module at the LLVM/object/binary level exposes a single module descriptor struct that has pointers to other metadata (currently just a list of function metadata descriptors). All interactions with the npcomp runtime are keyed off of that module descriptor, including function lookups and dispatching. This is done to dodge platform ABI issues and also allow enough reflection to e.g. verify provided arguments. Most of the compiler-side work here was in LowerToNpcomprtABI and LowerToLLVM. Also, - Rename npcomp_rt/NpcompRt to npcomprt/Npcomprt; it was getting annoying to type the underscores/caps. - misc improvements to bash_helpers.sh
2020-07-09 08:15:40 +08:00
def LowerToNpcomprtABI : Pass<"lower-to-npcomprt-abi", "ModuleOp"> {
let summary = "Lower tensors at ABI boundaries to npcomprt dialect";
let constructor = "mlir::NPCOMP::createLowerToNpcomprtABIPass()";
Lower to the upstream memref ABI. Specifically, we use unranked memrefs which get passed as a fixed-size set of arguments/returns. One big caveat about this is that returning results isn't going to work. See TODO in LowerTensorLoadOp. This is far from enough runtime-wise, but it starts to demarcate a plausible layering. Notice for example how this removes the runtime-dependence from LowerRankedShapes. Eventually, we want to have an `npcomp_rt` or `npcomp_hal` dialect with its own set of runtime types that will supercede this. See comments in LowerTensorLoadOp for more direction about where this is going to evolve.
2020-05-16 07:33:01 +08:00
}
Lower tcp.alloc_memref ops to tcp.get_extent + std.alloc. - tcp.get_extent will be liminated while lowering shapes - std.alloc is supported by the upstream LLVM lowering.
2020-05-19 03:50:16 +08:00
def LowerAllocMemRefOps : Pass<"lower-alloc-memref-ops", "FuncOp"> {
let summary = "Lower AllocMemRefOp's";
let constructor = "mlir::NPCOMP::createLowerAllocMemRefOpsPass()";
}
Lower to LLVM dialect. With this commit, we finish conversion to LLVM dialect, and should be ready for subsequent commits to convert to an LLVM module and let LLVM codegen to native machine code. This required a custom "lower to LLVM" pass to support lowering tcp.abort_if to a runtime call. In the future, this pass will grow to do type conversions for our own runtime types as we add those.
2020-05-21 09:48:53 +08:00
def LowerToLLVM : Pass<"e2e-lower-to-llvm", "ModuleOp"> {
let summary = "Lower everything to LLVM";
let constructor = "mlir::NPCOMP::createLowerToLLVMPass();";
}
Initial TCF/TCP E2E seed. Very much WIP. This is enough to get tcf.add down to approximately the "linalg.generic on buffers" level of abstraction. (but there are nuances)
2020-05-07 09:41:54 +08:00
#endif // NPCOMP_E2E_PASSES