From 02596df1ccf6f1663dd07e32e1114f8d1c814e5f Mon Sep 17 00:00:00 2001
From: Yifan Zhao <yifanz16@illinois.edu>
Date: Wed, 3 Feb 2021 23:44:14 -0600
Subject: [PATCH] Added a mode to generate 'inspected' binary in frontend
---
.../torch2hpvm/torch2hpvm/codegen_hpvm.py | 11 +-
.../projects/torch2hpvm/torch2hpvm/compile.py | 9 +-
.../torch2hpvm/template_hpvm_inspect.cpp.in | 151 ++++++++++++++++++
.../dnn_benchmarks/pytorch/test_tuning.py | 70 ++++++++
4 files changed, 234 insertions(+), 7 deletions(-)
create mode 100644 hpvm/projects/torch2hpvm/torch2hpvm/template_hpvm_inspect.cpp.in
create mode 100644 hpvm/test/dnn_benchmarks/pytorch/test_tuning.py
diff --git a/hpvm/projects/torch2hpvm/torch2hpvm/codegen_hpvm.py b/hpvm/projects/torch2hpvm/torch2hpvm/codegen_hpvm.py
index cdba5f327f..7a5ea0cb0f 100644
--- a/hpvm/projects/torch2hpvm/torch2hpvm/codegen_hpvm.py
+++ b/hpvm/projects/torch2hpvm/torch2hpvm/codegen_hpvm.py
@@ -6,10 +6,10 @@ import jinja2
from .graph_builder import DFG
from .graph_ir import DFGNode, TensorNode, WeightTensor
-TEMPLATE_FILE = "template_hpvm.cpp.in"
+PLAIN_TEMPLATE_FILE = "template_hpvm.cpp.in"
+INSPECT_TEMPLATE_FILE = "template_hpvm_inspect.cpp.in"
loader = jinja2.FileSystemLoader(searchpath=Path(__file__).parent)
template_env = jinja2.Environment(loader=loader, trim_blocks=True)
-template = template_env.get_template(TEMPLATE_FILE)
PathLike = Union[str, Path]
@@ -69,11 +69,14 @@ class HpvmCodeGen(CodeGen):
# Variable indicator is always int for hpvm gen
variables: Dict[DFGNode, Tuple[int, bool]]
- def __init__(self, dfg: DFG, prefix: PathLike, input_size: int, target: str):
+ def __init__(self, dfg: DFG, prefix: PathLike, input_size: int, target: str, inspectable: bool):
super().__init__(dfg, prefix, input_size)
if target not in ("tensor", "cudnn"):
raise ValueError(f"Unsupported target {target}")
self.target = target
+ self.template = template_env.get_template(
+ INSPECT_TEMPLATE_FILE if inspectable else PLAIN_TEMPLATE_FILE
+ )
def _emit_hpvm_node_edges(self, input_vars: List[DFGNode]) -> List[dict]:
ret = []
@@ -133,7 +136,7 @@ class HpvmCodeGen(CodeGen):
weights = self.emit_weights(self.weights)
with Path(output).open("w") as f:
f.write(
- template.render(
+ self.template.render(
nodes=nodes,
input_name=self.input_name,
input_size=self.input_size,
diff --git a/hpvm/projects/torch2hpvm/torch2hpvm/compile.py b/hpvm/projects/torch2hpvm/torch2hpvm/compile.py
index 5e27224298..25b3fff292 100644
--- a/hpvm/projects/torch2hpvm/torch2hpvm/compile.py
+++ b/hpvm/projects/torch2hpvm/torch2hpvm/compile.py
@@ -62,12 +62,15 @@ class ModelExporter:
self.weight_dir = self.output_dir / self.weight_dir_name
self.weight_dir.mkdir(exist_ok=True)
+ args3 = self.dfg, self.weight_dir, self.dataset_size
if target == "hpvm_tensor":
- self.codegen = HpvmCodeGen(self.dfg, self.weight_dir, self.dataset_size, "tensor")
+ self.codegen = HpvmCodeGen(*args3, "tensor", False)
+ elif target == "hpvm_tensor_inspect":
+ self.codegen = HpvmCodeGen(*args3, "tensor", True)
elif target == "hpvm_cudnn":
- self.codegen = HpvmCodeGen(self.dfg, self.weight_dir, self.dataset_size, "cudnn")
+ self.codegen = HpvmCodeGen(*args3, "cudnn", False)
elif target == "tensor":
- self.codegen = TensorCodeGen(self.dfg, self.weight_dir, self.dataset_size)
+ self.codegen = TensorCodeGen(*args3)
else:
raise ValueError(f"Target {target} not recognized")
diff --git a/hpvm/projects/torch2hpvm/torch2hpvm/template_hpvm_inspect.cpp.in b/hpvm/projects/torch2hpvm/torch2hpvm/template_hpvm_inspect.cpp.in
new file mode 100644
index 0000000000..d481da1944
--- /dev/null
+++ b/hpvm/projects/torch2hpvm/torch2hpvm/template_hpvm_inspect.cpp.in
@@ -0,0 +1,151 @@
+#include <string>
+#include <hpvm.h>
+#include <tensorTypes.h>
+#include <tensorUtils.h>
+
+// Linux C API for FIFO files
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+/**** Routines for Handling Piped Execution ***/
+bool fifo_wait(const std::string &filename) {
+ std::ifstream file{filename};
+ std::string line;
+ std::getline(file, line);
+ if (line == "next")
+ return true;
+ if (line == "stop")
+ return false;
+ std::cout << "Invalid fifo file content \"" << line << "\"\n";
+ abort();
+}
+
+void fifo_write_finished(const std::string &filename) {
+ std::ofstream file{filename};
+ file << "finished\n\0";
+}
+
+void make_fifo(const std::string &filename) {
+ if (mkfifo(filename.c_str(), 0666) == 0)
+ return;
+ if (errno == EEXIST) {
+ if (unlink(filename.c_str()) < 0) {
+ std::cout << "Error removing existing file: " << strerror(errno) << '\n';
+ abort();
+ }
+ make_fifo(filename);
+ }
+ std::cout << "Error making FIFO file: " << strerror(errno) << '\n';
+ abort();
+}
+
+{% for node in nodes %}
+void var_{{node.idx}}_node(
+{%- for n in range(node.input_size) -%}
+void *t{{n}}, size_t bytes_t{{n}}{{", " if not loop.last}}
+{%- endfor %}) {
+ __hpvm__hint(hpvm::{{target.upper()}}_TARGET);
+ __hpvm__attributes({{node.input_size}}, {% for n in range(node.input_size) -%}
+t{{n}}{{", " if not loop.last}}
+{%- endfor %}, 0);
+ __hpvm__node_id({{node.idx + 1}});
+ void *r = {{node.call_name}}({% for n in range(node.input_size) -%}
+t{{n}}{{", " if not loop.last}}
+{%- endfor %}{{", " if node.call_args}}{{node.call_args|join(", ")}});
+ __hpvm__return(2, r, (size_t) 0);
+}
+
+{% endfor -%}
+
+void root({%- for n in root_inputs -%}
+void *{{n}}, size_t {{n}}_bytes{{", " if not loop.last}}
+{%- endfor %}) {
+ __hpvm__hint(hpvm::CPU_TARGET);
+ __hpvm__attributes({{root_inputs|length}}, {% for n in root_inputs -%}
+{{n}}{{", " if not loop.last}}
+{%- endfor %}, 0);
+
+{% for node in nodes %}
+ void* var_{{node.idx}} = __hpvm__createNodeND(0, var_{{node.idx}}_node);
+{% for edge in node.edges %}
+{% if edge.is_bindin %}
+ __hpvm__bindIn(var_{{node.idx}}, {{edge.input_idx * 2}}, {{edge.edge_idx * 2}}, 0);
+ __hpvm__bindIn(var_{{node.idx}}, {{edge.input_idx * 2 + 1}}, {{edge.edge_idx * 2 + 1}}, 0);
+{% else %}
+ __hpvm__edge(var_{{edge.input_node}}, var_{{node.idx}}, 1, 0, {{edge.edge_idx * 2}}, 0);
+ __hpvm__edge(var_{{edge.input_node}}, var_{{node.idx}}, 1, 1, {{edge.edge_idx * 2 + 1}}, 0);
+{% endif %}
+{% endfor %}
+
+{% endfor %}
+ __hpvm__bindOut(var_{{root_output_idx}}, 0, 0, 0);
+ __hpvm__bindOut(var_{{root_output_idx}}, 1, 1, 0);
+}
+
+struct ret_t {
+ void* tensor;
+ size_t bytes;
+};
+
+typedef struct __attribute__((__packed__)) {
+{% for n in root_inputs %}
+ void *{{n}};
+ size_t {{n}}_bytes;
+{% endfor %}
+ struct ret_t r;
+} RootIn;
+
+
+const int batch_size = {{batch_size}}, input_size = {{input_size}}, batch_count = input_size / batch_size;
+
+int main(int argc, char *argv[]){
+ if (argc != 2) {
+ std::cout << "Usage: " << argv[0] << " {tune|test}\n";
+ return 1;
+ }
+ std::string arg1 = argv[1];
+ if (arg1 != "tune" && arg1 != "test") {
+ std::cout << "Usage: " << argv[0] << " {tune|test}\n";
+ return 1;
+ }
+
+ std::string dir_prefix = "{{prefix}}/";
+ std::string input_path = dir_prefix + arg1 + "_input.bin";
+ std::string labels_path = dir_prefix + arg1 + "_labels.bin";
+{% for w in weights %}
+ std::string {{w.name}}_path = dir_prefix + "{{w.filename}}";
+ void* {{w.name}} = readTrainedWeights({{w.name}}_path.c_str(), 0, {{w.shape|join(', ')}});
+{% endfor %}
+
+ RootIn* args = static_cast<RootIn*>(malloc(sizeof(RootIn)));
+ void* {{input_name}} = create4DTensor(0, nchw, batch_size, {{input_shape|join(', ')}});
+{% for n in root_inputs %}
+ args->{{n}} = {{n}};
+ args->{{n}}_bytes = 0;
+{% endfor %}
+
+ make_fifo("/tmp/hpvm_fifo");
+ while (fifo_wait("/tmp/hpvm_fifo")) {
+ __hpvm__init();
+ startMemTracking();
+ for (int i = 0; i < batch_count; i++){
+ int start = i * batch_size, end = start + batch_size;
+ copyInputBatch(input_path.c_str(), start, end, {{input_shape|join(', ')}}, {{input_name}});
+
+ void* dfg = __hpvm__launch(0, root, (void*) args);
+ __hpvm__wait(dfg);
+ void *result = static_cast<RootIn*>(args)->r.tensor;
+ hpvm_request_tensor(result, 0);
+
+ uint32_t* labels = readLabelsBatch3(labels_path.c_str(), start, end);
+ computeAccuracy3(labels, result);
+ freeBatchMemory();
+ }
+ __hpvm__cleanup();
+ fifo_write_finished("/tmp/hpvm_fifo");
+ }
+
+ return 0;
+}
diff --git a/hpvm/test/dnn_benchmarks/pytorch/test_tuning.py b/hpvm/test/dnn_benchmarks/pytorch/test_tuning.py
new file mode 100644
index 0000000000..1c4e8120ef
--- /dev/null
+++ b/hpvm/test/dnn_benchmarks/pytorch/test_tuning.py
@@ -0,0 +1,70 @@
+import shutil
+from pathlib import Path
+from subprocess import run
+import torch
+
+from torch2hpvm import BinDataset, ModelExporter
+from torch.nn import Module
+from predtuner.pipedbin import PipedBinaryApp
+
+
+import os
+import shutil
+import site
+from pathlib import Path
+from subprocess import run
+import torch
+
+from torch2hpvm import BinDataset, ModelExporter
+from torch.nn import Module
+
+site.addsitedir(os.path.dirname(__file__))
+import dnn
+
+benchmarks = [
+ (dnn.LeNet, 1, 28, 5000, "lenet_mnist"),
+ (dnn.AlexNet, 3, 32, 5000, "alexnet_cifar10"),
+ (dnn.AlexNet2, 3, 32, 5000, "alexnet2_cifar10"),
+ (dnn.AlexNetImageNet, 3, 224, 500, "alexnet_imagenet"),
+ (dnn.MobileNet, 3, 32, 5000, "mobilenet_cifar10"),
+ (dnn.ResNet18, 3, 32, 5000, "resnet18_cifar10"),
+ (dnn.ResNet50, 3, 224, 100, "resnet50_imagenet"),
+ (dnn.VGG16Cifar10, 3, 32, 5000, "vgg16_cifar10"),
+ (dnn.VGG16Cifar100, 3, 32, 5000, "vgg16_cifar100"),
+ (dnn.VGG16ImageNet, 3, 224, 100, "vgg16_imagenet"),
+]
+
+self_folder = Path(__file__).parent
+model_cls, nch, img_size, batch_size, pathname = benchmarks[0]
+codegen_dir = Path(f"/tmp/{pathname}_tune")
+print(f"Generating {pathname} to {codegen_dir}")
+if codegen_dir.exists():
+ shutil.rmtree(codegen_dir)
+
+params = self_folder / "../model_params" / pathname
+dataset_shape = 5000, nch, img_size, img_size
+bin_tuneset = BinDataset(
+ params / "tune_input.bin", params / "tune_labels.bin", dataset_shape
+)
+bin_testset = BinDataset(
+ params / "test_input.bin", params / "test_labels.bin", dataset_shape
+)
+model: Module = model_cls()
+checkpoint = self_folder / "../model_params" / f"{pathname}.pth.tar"
+model.load_state_dict(torch.load(checkpoint.as_posix()))
+
+exporter = ModelExporter(model, bin_tuneset, bin_testset, codegen_dir, target="hpvm_tensor_inspect")
+exporter.export_all(batch_size=batch_size)
+
+conf_file = self_folder / "../hpvm-c/benchmarks" / pathname / "data/tuner_confs.txt"
+build_dir = codegen_dir / "build"
+target_binary = build_dir / pathname
+run([
+ "approxhpvm.py", str(codegen_dir / ModelExporter.source_file_name), str(target_binary),
+ "-d", str(build_dir),
+ "-t", "tensor", "--conf-file", str(conf_file)
+], check=True)
+# run([str(target_binary), "test"], check=True)
+
+# build_dir = codegen_dir / "build"
+# print(PipedBinaryApp("test", codegen_dir / "ops.json", build_dir / "lenet_mnist", build_dir))
--
GitLab