refactor: remove unused runtime convenience APIs

Author: whjthu

csrc/pybind11/runtime/analyzer.hpp

@@ -4,32 +4,20 @@
 #include "runtime/utils.hpp"
 #include "context.hpp"
 #include "device.hpp"
-#include "device_event.hpp"
 #include "dtype.hpp"
-#include "graph.hpp"
-#include "io.hpp"
-#include "ops.hpp"
+#include "ops/add.hpp"
+#include "ops/cat.hpp"
 #include "tensor.hpp"
 
-#ifdef ENABLE_MUTUAL_AWARENESS
-#include "analyzer.hpp"
-#endif
-
 namespace infinilm::runtime {
 
 void bind_runtime(pybind11::module_ &m) {
     context::bind(m);
     device::bind(m);
-    device_event::bind(m);
     dtype::bind(m);
-    ops::bind(m);
+    ops::bind_add(m);
+    ops::bind_cat(m);
     tensor::bind(m);
-    io::bind(m);
-    ::infinilm::execution::graph::bind(m);
-
-#ifdef ENABLE_MUTUAL_AWARENESS
-    ::infinilm::execution::trace::pybind::bind(m);
-#endif
 }
 
 } // namespace infinilm::runtime

csrc/pybind11/runtime/bindings.cc

@@ -28,22 +28,6 @@ inline void bind_add(py::module &m) {
           py::arg("b"),
           R"doc(Addition of two tensors.)doc");
 
-    m.def("add_",
-          [](Tensor c, const Tensor &a, const Tensor &b) {
-              {
-                  if (!c) throw std::invalid_argument("Add output is null");
-                  auto owner = c->allocation_owner();
-                  if (!owner || owner->device() != c->device()) owner = context::resolveRuntime(c->device());
-                  auto &ops_runtime = *owner;
-                  infinilm::execution::submit<infini::ops::Add>(
-                      ops_runtime, infini::ops::Add::DefaultConfig(ops_runtime.device().type()), a, b, c);
-                  INFINILM_TRACE_OP(Add, c);
-              }
-          },
-          py::arg("c"),
-          py::arg("a"),
-          py::arg("b"),
-          R"doc(In-place tensor addition.)doc");
 }
 
 } // namespace infinilm::runtime::ops

csrc/pybind11/runtime/device_event.hpp

@@ -40,29 +40,6 @@ inline void bind_cat(py::module &m) {
           py::arg("dim") = 0,
           R"doc(opertor: torch.cat, out-of-place mode)doc");
 
-    m.def("cat_",
-          [](Tensor out, std::vector<Tensor> tensors, int dim) {
-              if (!out) throw std::invalid_argument("Cat output is null");
-              auto owner = out->allocation_owner();
-              if (!owner || owner->device() != out->device()) owner = context::resolveRuntime(out->device());
-              auto &runtime = *owner;
-              const auto rank = out->ndim();
-              if (!rank || dim < -static_cast<int64_t>(rank) || dim >= static_cast<int64_t>(rank))
-                  throw std::invalid_argument("Cat dimension is outside the output rank");
-              const auto axis = static_cast<size_t>(dim < 0 ? dim + static_cast<int64_t>(rank) : dim);
-              infinilm::execution::tensor_checks::cat::validate(runtime, out, tensors, {nullptr, axis, 0});
-              tensors.erase(std::remove_if(tensors.begin(), tensors.end(),
-                  infinilm::execution::tensor_checks::cat::empty_vector), tensors.end());
-              if (out->numel()) {
-                  infinilm::execution::submit<infini::ops::Cat>(runtime,
-                      infini::ops::Cat::DefaultConfig(runtime.device().type()),
-                      tensors, static_cast<int64_t>(axis), out);
-              }
-          },
-          py::arg("out"),
-          py::arg("tensors"),
-          py::arg("dim") = 0,
-          R"doc(opertor: torch.cat, in-place mode)doc");
 }
 
 } // namespace infinilm::runtime::ops

csrc/pybind11/runtime/graph.hpp

@@ -44,9 +44,6 @@ inline void bind(py::module &m) {
         .def("is_pinned", [](const Tensor &tensor) { return tensor->is_pinned(); })
         .def("info", [](const Tensor &tensor) { return tensor->info(); })
 
-        .def("debug", [](const Tensor &tensor) { return tensor->debug(); })
-        .def("debug", [](const Tensor &tensor, const std::string &filename) { return tensor->debug(filename); })
-
         .def("copy_", [](Tensor &tensor, const Tensor &other) { tensor->copy_from(other); })
         .def("to", [](const Tensor &tensor, const Device &device) { return tensor->to(device); })
         .def("contiguous", [](const Tensor &tensor) { return tensor->contiguous(); })