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/E2E.h

61 lines
2.0 KiB
C
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
//===------------------------------------------------------------*- C++ -*-===//
//
// This file is licensed 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_E2E_H
#define NPCOMP_E2E_E2E_H
#include "mlir/Pass/Pass.h"
#include "mlir/Pass/PassManager.h"
namespace mlir {
namespace NPCOMP {
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
// Look in createE2ELoweringPipeline for more information about how these
// passes fit together.
//
// Pass summaries are in Passes.td.
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
std::unique_ptr<OperationPass<FuncOp>> createLowerBroadcastToToLoopsPass();
std::unique_ptr<OperationPass<FuncOp>>
createLowerLinalgOnTensorToLinalgOnMemrefPass();
std::unique_ptr<OperationPass<FuncOp>>
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
std::unique_ptr<OperationPass<FuncOp>> 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
std::unique_ptr<OperationPass<FuncOp>> 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
std::unique_ptr<OperationPass<FuncOp>> createLowerRankedShapesPass();
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
std::unique_ptr<OperationPass<FuncOp>> createLowerToMemRefABIPass();
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
std::unique_ptr<OperationPass<FuncOp>> 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
std::unique_ptr<OperationPass<ModuleOp>> 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
void createLowerToHybridTensorMemRefPipeline(OpPassManager &pm);
Add ability to run without optimizations. The default is to only do the bare minimum needed for correctness, since that stresses the layering of the system maximally.
2020-06-02 10:30:13 +08:00
struct E2ELoweringPipelineOptions
: public PassPipelineOptions<E2ELoweringPipelineOptions> {
// If this option is true, then perform optimizations.
// If this option is false, only do the bare minimum for correctness.
Option<bool> optimize{*this, "optimize", llvm::cl::desc("Do optimizations."),
llvm::cl::init(false)};
};
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
// The main pipeline that encapsulates the full E2E lowering.
Add ability to run without optimizations. The default is to only do the bare minimum needed for correctness, since that stresses the layering of the system maximally.
2020-06-02 10:30:13 +08:00
void createE2ELoweringPipeline(OpPassManager &pm,
const E2ELoweringPipelineOptions &options);
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
} // namespace NPCOMP
} // namespace mlir
#endif // NPCOMP_E2E_E2E_H