mirror of
https://github.com/zebrajr/pytorch.git
synced 2025-12-07 12:21:27 +01:00
125e2d02e5
Test Plan: revert-hammer
Differential Revision:
D30417370 (b9fc656cf2)
Original commit changeset: 84ce7a578a36
fbshipit-source-id: cd23774cdc3273fd72f8a05f1900eaf36f373e6b
113 lines
3.2 KiB
C++
113 lines
3.2 KiB
C++
#include <torch/csrc/jit/codegen/fuser/interface.h>
|
|
|
|
#include <torch/csrc/jit/codegen/fuser/compiler.h>
|
|
#include <torch/csrc/jit/codegen/fuser/executor.h>
|
|
#include <torch/csrc/jit/codegen/fuser/fallback.h>
|
|
#include <torch/csrc/jit/codegen/fuser/kernel_cache.h>
|
|
|
|
#include <c10/util/Flags.h>
|
|
#include <stdexcept>
|
|
|
|
C10_DEFINE_bool(torch_jit_enable_cpu_fusion, false, "enable cpu fusion");
|
|
|
|
namespace torch {
|
|
namespace jit {
|
|
|
|
namespace detail {
|
|
|
|
// Note: CPU fusion is currently disabled due to test flakiness
|
|
#if defined(FBCODE_CAFFE2)
|
|
bool cpu_fuser_enabled = true;
|
|
#else
|
|
bool cpu_fuser_enabled = false;
|
|
#endif
|
|
|
|
bool gpu_fuser_enabled = true;
|
|
|
|
} // namespace detail
|
|
|
|
int64_t registerFusion(const Node* fusion_group) {
|
|
return fuser::registerFusion(fusion_group);
|
|
}
|
|
|
|
void runFusion(const int64_t key, Stack& stack) {
|
|
const auto result = fuser::runFusion(key, stack);
|
|
if (!result)
|
|
fuser::runFallback(key, stack);
|
|
}
|
|
|
|
bool canFuseOnCPU() {
|
|
return fuser::hasFusionBackend(DeviceType::CPU) &&
|
|
(detail::cpu_fuser_enabled || FLAGS_torch_jit_enable_cpu_fusion);
|
|
}
|
|
|
|
bool canFuseOnGPU() {
|
|
return fuser::hasFusionBackend(DeviceType::CUDA) && detail::gpu_fuser_enabled;
|
|
}
|
|
|
|
void overrideCanFuseOnCPU(bool value) {
|
|
detail::cpu_fuser_enabled = value;
|
|
}
|
|
|
|
void overrideCanFuseOnGPU(bool value) {
|
|
detail::gpu_fuser_enabled = value;
|
|
}
|
|
|
|
// Uses the above interface by stuffing the graph into a node and treating that
|
|
// node as a fusion group.
|
|
std::vector<at::Tensor> debugLaunchGraph(
|
|
Graph& graph,
|
|
at::ArrayRef<at::Tensor> inputs) {
|
|
// Creates a fusion group node
|
|
auto wrapper_graph = std::make_shared<Graph>();
|
|
Node* fusion_group = wrapper_graph->insertNode(
|
|
wrapper_graph->createWithSubgraph(prim::FusionGroup));
|
|
fusion_group->g_(attr::Subgraph, graph.copy());
|
|
for (size_t i = 0; i < graph.inputs().size(); ++i) {
|
|
fusion_group->addInput(wrapper_graph->addInput());
|
|
}
|
|
for (size_t i = 0; i < graph.outputs().size(); ++i) {
|
|
wrapper_graph->registerOutput(fusion_group->addOutput());
|
|
}
|
|
|
|
// Creates the stack, registers and runs the fusion
|
|
Stack stack = fmap<IValue>(inputs);
|
|
const auto key = fuser::registerFusion(fusion_group);
|
|
fuser::runFusion(key, stack);
|
|
return fmap(stack, [](const IValue& iv) { return iv.toTensor(); });
|
|
}
|
|
|
|
std::string debugGetFusedKernelCode(
|
|
Graph& graph,
|
|
at::ArrayRef<at::Tensor> inputs) {
|
|
// Creates a fusion group node
|
|
auto wrapper_graph = std::make_shared<Graph>();
|
|
Node* fusion_group = wrapper_graph->insertNode(
|
|
wrapper_graph->createWithSubgraph(prim::FusionGroup));
|
|
fusion_group->g_(attr::Subgraph, graph.copy());
|
|
for (size_t i = 0; i < graph.inputs().size(); ++i) {
|
|
fusion_group->addInput(wrapper_graph->addInput());
|
|
}
|
|
for (size_t i = 0; i < graph.outputs().size(); ++i) {
|
|
wrapper_graph->registerOutput(fusion_group->addOutput());
|
|
}
|
|
|
|
// Creates the stack, registers and runs the fusion
|
|
Stack stack = fmap<IValue>(inputs);
|
|
const auto key = fuser::registerFusion(fusion_group);
|
|
|
|
std::string code;
|
|
if (!fuser::runFusion(key, stack, &code)) {
|
|
throw std::runtime_error("Could not run fusion for graph");
|
|
}
|
|
|
|
return code;
|
|
}
|
|
|
|
size_t nCompiledKernels() {
|
|
return fuser::nCompiledKernels();
|
|
}
|
|
|
|
} // namespace jit
|
|
} // namespace torch
|