Make executor_runner use MethodMeta (#318)

Summary:
Pull Request resolved: #318

Using MethodMeta lets us avoid the off-by-one hack used by the (deprecated) Program versions of the buffer iterators.

While I'm here, stop using runtime_allocator to create the outputs list: it's not legal to touch the runtime_allocator after the Method is created.

Reviewed By: JacobSzwejbka

Differential Revision: D48762562

fbshipit-source-id: a06121c0841e97180c535162b1cd8854357aa2fb

Author: dbort

examples/executor_runner/executor_runner.cpp

@@ -75,14 +75,21 @@ int main(int argc, char** argv) {
   ET_LOG(Info, "Model file %s is loaded.", model_path);
 
   // Use the first method in the program.
-  const size_t plan_index = 0;
   const char* method_name = nullptr;
   {
-    const auto method_name_result = program->get_method_name(plan_index);
+    const auto method_name_result = program->get_method_name(0);
     ET_CHECK_MSG(method_name_result.ok(), "Program has no methods");
     method_name = *method_name_result;
   }
-  ET_LOG(Info, "Running method %s", method_name);
+  ET_LOG(Info, "Using method %s", method_name);
+
+  // MethodMeta describes the memory requirements of the method.
+  Result<MethodMeta> method_meta = program->method_meta(method_name);
+  ET_CHECK_MSG(
+      method_meta.ok(),
+      "Failed to get method_meta for %s: 0x%x",
+      method_name,
+      (unsigned int)method_meta.error());
 
   //
   // The runtime does not use malloc/new; it allocates all memory using the
@@ -116,20 +123,9 @@ int main(int argc, char** argv) {
   // have more than one for, e.g., slow/large DRAM and fast/small SRAM.
   std::vector<std::unique_ptr<uint8_t[]>> non_const_buffers;
   std::vector<MemoryAllocator> non_const_allocators;
-  size_t num_non_const_buffers = 0;
-  {
-    auto result = program->num_non_const_buffers(method_name);
-    ET_CHECK_MSG(
-        result.ok(),
-        "Failed to get number of non-const buffers for method %s: 0x%x",
-        method_name,
-        (unsigned int)result.error());
-    num_non_const_buffers = *result;
-  }
-  // Note that this loop starts at ID 1, because ID 0 is reserved. But, the
-  // HierarchicalAllocator indices are zero-based, so it's later adjusted by -1.
-  for (size_t id = 1; id < num_non_const_buffers; ++id) {
-    auto buffer_size = program->get_non_const_buffer_size(id, method_name);
+  size_t num_non_const_buffers = method_meta->num_non_const_buffers();
+  for (size_t id = 0; id < num_non_const_buffers; ++id) {
+    auto buffer_size = method_meta->non_const_buffer_size(id);
     ET_CHECK_MSG(
         buffer_size.ok(),
         "Failed to get size of non-const buffer %zu for method %s: 0x%x",
@@ -139,8 +135,6 @@ int main(int argc, char** argv) {
     ET_LOG(
         Info, "Setting up non-const buffer %zu, size %zu.", id, *buffer_size);
     non_const_buffers.push_back(std::make_unique<uint8_t[]>(*buffer_size));
-    // Since the list of allocators began empty, buffer ID N will live at index
-    // N-1.
     non_const_allocators.push_back(
         MemoryAllocator(*buffer_size, non_const_buffers.back().get()));
     non_const_allocators.back().enable_profiling("non_const_allocators");
@@ -194,19 +188,17 @@ int main(int argc, char** argv) {
       status);
   ET_LOG(Info, "Model executed successfully.");
 
-  auto output_list =
-      runtime_allocator.allocateList<EValue>(method->outputs_size());
-  status = method->get_outputs(output_list, method->outputs_size());
+  // Print the outputs.
+  std::vector<EValue> outputs(method->outputs_size());
+  status = method->get_outputs(outputs.data(), outputs.size());
   ET_CHECK(status == Error::Ok);
-  // The following code assumes all output EValues are floating point
-  // tensors. We need to handle other types of EValues and tensor
-  // dtypes. Furthermore, we need a util to print tensors in a more
-  // interpretable (e.g. size, dtype) and readable way.
-  // TODO for the above at T159700776
-  for (size_t i = 0; i < method->outputs_size(); i++) {
-    auto output_tensor = output_list[i].toTensor();
+  for (EValue& output : outputs) {
+    // TODO(T159700776): This assumes that all outputs are fp32 tensors. Add
+    // support for other EValues and Tensor dtypes, and print tensors in a more
+    // readable way.
+    auto output_tensor = output.toTensor();
     auto data_output = output_tensor.const_data_ptr<float>();
-    for (size_t j = 0; j < output_list[i].toTensor().numel(); ++j) {
+    for (size_t j = 0; j < output_tensor.numel(); ++j) {
       ET_LOG(Info, "%f", data_output[j]);
     }
   }