clean up Program api

Summary: Delete all the old deprecated functions. Mark the remaining ones deprecated

Differential Revision:
D48164916

Privacy Context Container: L1124100

fbshipit-source-id: f77696ce736c12e8e8b7dc6271fa7cb2fcd6f2f8

Author: JacobSzwejbka

exir/backend/test/demos/rpc/ExecutorBackend.cpp

@@ -64,31 +64,38 @@ class ExecutorBackend final : public PyTorchBackendInterface {
         ET_ALLOCATE_INSTANCE_OR_RETURN_ERROR(runtime_allocator, Program);
     new (client_program) Program(std::move(program_result.get()));
 
+    Result<MethodMeta> method_meta = client_program->method_meta("forward");
+    if (!method_meta.ok()) {
+      ET_LOG(Error, "error constructing method meta");
+      return method_meta.error();
+    }
+
     // Building all different allocators for the client executor
     auto client_const_allocator = ET_ALLOCATE_INSTANCE_OR_RETURN_ERROR(
         runtime_allocator, MemoryAllocator);
     new (client_const_allocator) MemoryAllocator(0, nullptr);
 
-    size_t num_non_const_buffers = client_program->num_non_const_buffers() - 1;
+    auto num_buffers = method_meta->num_non_const_buffers();
+    size_t num_non_const_buffers = num_buffers - 1;
 
     uint8_t** non_const_buffers = ET_ALLOCATE_LIST_OR_RETURN_ERROR(
         runtime_allocator, uint8_t*, num_non_const_buffers);
     MemoryAllocator* non_const_allocators = ET_ALLOCATE_LIST_OR_RETURN_ERROR(
         runtime_allocator, MemoryAllocator, num_non_const_buffers);
 
-    for (size_t id = 1; id < client_program->num_non_const_buffers(); ++id) {
-      const size_t buffer_size = client_program->get_non_const_buffer_size(id);
+    for (size_t id = 1; id < num_buffers; ++id) {
+      auto buffer_size = method_meta->non_const_buffer_size(id);
       uint8_t* buffer_i = ET_ALLOCATE_LIST_OR_RETURN_ERROR(
-          runtime_allocator, uint8_t, buffer_size);
+          runtime_allocator, uint8_t, buffer_size.get());
       non_const_buffers[id - 1] = buffer_i;
       new (&non_const_allocators[id - 1])
-          MemoryAllocator(static_cast<uint32_t>(buffer_size), buffer_i);
+          MemoryAllocator(static_cast<uint32_t>(buffer_size.get()), buffer_i);
     }
 
     auto client_non_const_allocator = ET_ALLOCATE_INSTANCE_OR_RETURN_ERROR(
         runtime_allocator, HierarchicalAllocator);
-    new (client_non_const_allocator) HierarchicalAllocator(
-        client_program->num_non_const_buffers() - 1, non_const_allocators);
+    new (client_non_const_allocator)
+        HierarchicalAllocator(num_non_const_buffers, non_const_allocators);
 
     // Allocate some memory from runtime allocator for the client executor, in
     // real case, like if it's an executor in dsp, it should allocate memory
@@ -113,46 +120,49 @@ class ExecutorBackend final : public PyTorchBackendInterface {
         client_runtime_allocator,
         client_temp_allocator);
 
-    // Construct the client executor
-    auto client_executor =
-        ET_ALLOCATE_INSTANCE_OR_RETURN_ERROR(runtime_allocator, Executor);
-    new (client_executor) Executor(client_program, client_memory_manager);
-
-    // Initialize the client executor
-    Error err = client_executor->init_execution_plan("forward");
-    if (err != Error::Ok) {
-      ET_LOG(Error, "Failed to init client executor: 0x%x", (unsigned int)err);
-      return err;
+    // Construct the client Method
+    Result<Method> method_res =
+        client_program->load_method("forward", client_memory_manager);
+    if (!method_res.ok()) {
+      ET_LOG(
+          Error,
+          "Failed to load client method: 0x%x",
+          (unsigned int)method_res.error());
+      return method_res.error();
     }
 
-    // Return the client executor so it will be passed to `execute()` as
+    auto client_method =
+        ET_ALLOCATE_INSTANCE_OR_RETURN_ERROR(runtime_allocator, Method);
+    new (client_method) Method(std::move(method_res.get()));
+
+    // Return the client method so it will be passed to `execute()` as
     // `handle`.
-    return client_executor;
+    return client_method;
   }
 
   Error execute(DelegateHandle* handle, EValue** args) const override {
-    Executor* client_executor = static_cast<Executor*>(handle);
-    auto& plan = client_executor->execution_plan();
-    auto plan_inputs_size = plan.inputs_size();
+    Method* client_method = static_cast<Method*>(handle);
+    auto num_inputs = client_method->inputs_size();
     Error status = Error::Ok;
 
     // Receive client executor input
-    for (size_t input_idx = 0; input_idx < plan_inputs_size; input_idx++) {
-      status = plan.set_input(*args[input_idx], input_idx);
+    for (size_t input_idx = 0; input_idx < num_inputs; input_idx++) {
+      status = client_method->set_input(*args[input_idx], input_idx);
     }
     // Execute client executor
-    status = plan.execute();
+    status = client_method->execute();
 
     // Send the client executor output
-    status = plan.get_outputs(args[plan_inputs_size], plan.outputs_size());
+    status = client_method->get_outputs(
+        args[num_inputs], client_method->outputs_size());
 
     return status;
   }
 
   void destroy(DelegateHandle* handle) const override {
     if (handle != nullptr) {
-      Executor* client_executor = static_cast<Executor*>(handle);
-      client_executor->~Executor();
+      Method* client_executor = static_cast<Method*>(handle);
+      client_executor->~Method();
     }
   }
 };

extension/pybindings/module.cpp

@@ -555,7 +555,7 @@ void init_module_functions(py::module_& m) {
       .def("run_method", &PyModule::run_method)
       .def("forward", &PyModule::forward)
       .def_property_readonly_static("FORWARD_METHOD_INDEX", [](py::object) {
-        return torch::executor::Program::kForwardMethodIndex;
+        return 0; // TODO(T152881296) remove this
       });
   ;
 

runtime/executor/executor.h

@@ -37,11 +37,10 @@ class __ET_DEPRECATED Executor {
    * May only be called once for the lifetime of the Executor.
    *
    * @param[in] index The index of the entry point to use for this plan.
-   *     Defaults to using the `forward()` method.
+   *     Defaults to using the first method sorted alphabetically.
    * @retval Error::Ok on successful initialization.
    */
-  __ET_DEPRECATED __ET_NODISCARD Error
-  init_execution_plan(size_t index = Program::kForwardMethodIndex);
+  __ET_DEPRECATED __ET_NODISCARD Error init_execution_plan(size_t index = 0);
 
   /**
    * DEPRECATED: Use `Program::load_method()` instead.

runtime/executor/method.cpp

@@ -675,7 +675,7 @@ Method::set_input(const EValue& input_evalue, size_t input_idx) {
       "The %zu-th input of method should have the same type as the input_evalue, but get tag %u and tag %u",
       input_idx,
       e.tag,
-      input_evalue.tag);
+      (unsigned int)input_evalue.tag);
 
   if (e.isTensor()) {
     const auto& t_dst = e.toTensor();

runtime/executor/program.cpp

@@ -43,44 +43,6 @@ bool IsAligned(const void* data) {
   return addr % kMinimumAlignment == 0;
 }
 
-/**
- * Tries deserializing the data as a Program flabuffer file. Returns nullptr if
- * the file appears to be corrupt or incompatible.
- */
-const executorch_flatbuffer::Program* DeserializeFlatbufferData(
-    const void* data) {
-  if (Program::check_header(data, Program::kMinHeadBytes) !=
-      Program::HeaderStatus::CompatibleVersion) {
-    ET_LOG(
-        Error,
-        "Program identifier '%.4s' != expected '%.4s'",
-        flatbuffers::GetBufferIdentifier(data),
-        executorch_flatbuffer::ProgramIdentifier());
-    return nullptr;
-  }
-
-  // The provided pointer must start at an aligned address to ensure internal
-  // alignment of flatbuffer fields.
-  if (!IsAligned(data)) {
-    ET_LOG(
-        Error,
-        "Program data 0x%p must be aligned to %zu",
-        data,
-        kMinimumAlignment);
-    return nullptr;
-  }
-
-  const executorch_flatbuffer::Program* program =
-      executorch_flatbuffer::GetProgram(data);
-  if (program->segments()->size() > 0) {
-    ET_LOG(
-        Error,
-        "Program constructor does not support segments; use Program::Load()");
-    return nullptr;
-  }
-  return program;
-}
-
 Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
     const executorch_flatbuffer::Program* program,
     const char* method_name) {
@@ -97,16 +59,6 @@ Result<executorch_flatbuffer::ExecutionPlan*> get_execution_plan(
 
 } // namespace
 
-Program::Program(const void* serialized_content)
-    : Program(
-          /*loader=*/nullptr,
-          /*segment_base_offset=*/0,
-          FreeableBuffer(
-              /*data=*/nullptr,
-              /*size=*/0,
-              /*free_fn=*/nullptr),
-          DeserializeFlatbufferData(serialized_content)) {}
-
 /* static */ Result<Program> Program::Load(
     DataLoader* loader,
     Program::Verification verification) {
@@ -233,43 +185,24 @@ Result<MethodMeta> Program::method_meta(const char* method_name) const {
   return MethodMeta(plan.get());
 }
 
-const void* Program::get_constant_buffer_data(size_t buffer_index) const {
-  ET_CHECK(is_valid());
+Result<const void*> Program::get_constant_buffer_data(
+    size_t buffer_index) const {
   auto internal_program =
       static_cast<const executorch_flatbuffer::Program*>(internal_program_);
-  ET_CHECK_MSG(
-      buffer_index < constant_buffer_size(),
+  size_t size = internal_program->constant_buffer()->size();
+  ET_CHECK_OR_RETURN_ERROR(
+      buffer_index < size,
+      InvalidArgument,
       "Constant buffer %zu out of program buffer range %zu",
       buffer_index,
-      constant_buffer_size());
+      size);
 
   const auto& constant_buffer = *internal_program->constant_buffer();
 
   return static_cast<const void*>(
       constant_buffer[buffer_index]->storage()->data());
 }
 
-size_t Program::constant_buffer_size() const {
-  ET_CHECK(is_valid());
-  auto internal_program =
-      static_cast<const executorch_flatbuffer::Program*>(internal_program_);
-  return internal_program->constant_buffer()->size();
-}
-
-int64_t Program::get_non_const_buffer_size(
-    size_t buffer_index,
-    size_t execution_plan_index) const {
-  ET_CHECK(is_valid());
-  ET_CHECK_MSG(
-      execution_plan_index == Program::kForwardMethodIndex,
-      "Unsupported plan index %zu != %zu",
-      execution_plan_index,
-      Program::kForwardMethodIndex);
-  auto res = this->get_non_const_buffer_size(buffer_index, "forward");
-  ET_CHECK(res.ok());
-  return res.get();
-}
-
 Result<int64_t> Program::get_non_const_buffer_size(
     size_t buffer_index,
     const char* method_name) const {
@@ -289,18 +222,6 @@ Result<int64_t> Program::get_non_const_buffer_size(
   return (*(plan.get()->non_const_buffer_sizes()))[buffer_index];
 }
 
-size_t Program::num_non_const_buffers(size_t execution_plan_index) const {
-  ET_CHECK(is_valid());
-  ET_CHECK_MSG(
-      execution_plan_index == Program::kForwardMethodIndex,
-      "Unsupported plan index %zu != %zu",
-      execution_plan_index,
-      Program::kForwardMethodIndex);
-  auto res = this->num_non_const_buffers("forward");
-  ET_CHECK(res.ok());
-  return res.get();
-}
-
 Result<size_t> Program::num_non_const_buffers(const char* method_name) const {
   auto plan = get_execution_plan(internal_program_, method_name);
   if (!plan.ok()) {
@@ -309,18 +230,6 @@ Result<size_t> Program::num_non_const_buffers(const char* method_name) const {
   return plan.get()->non_const_buffer_sizes()->size();
 }
 
-const char* Program::get_output_flattening_encoding(
-    size_t execution_plan_index) const {
-  ET_CHECK(is_valid());
-  ET_CHECK_MSG(
-      execution_plan_index == Program::kForwardMethodIndex,
-      "Executor only supports a single execution plan at this time, but received a query about plan #%zu",
-      execution_plan_index);
-  auto res = this->get_output_flattening_encoding("forward");
-  ET_CHECK(res.ok());
-  return res.get();
-}
-
 Result<const char*> Program::get_output_flattening_encoding(
     const char* method_name) const {
   auto plan = get_execution_plan(internal_program_, method_name);
@@ -334,7 +243,6 @@ Error Program::get_backend_delegate_data(
     size_t index,
     const void** out_data,
     size_t* out_size) const {
-  ET_CHECK(is_valid());
   const auto* data_list =
       static_cast<const executorch_flatbuffer::Program*>(internal_program_)
           ->backend_delegate_data();