Add order to functions in C Codegen

src/runtime/aot_executor/aot_executor.cc

@@ -132,6 +132,7 @@ PackedFunc AotExecutor::GetFunction(const std::string& name,
       *rv = this->GetInputIndex(args[0].operator String());
     });
   } else {
+    LOG(INFO) << "Unknown packed function: " << name;
     return PackedFunc();
   }
 }

src/runtime/aot_executor/aot_executor_factory.cc

@@ -60,6 +60,7 @@ PackedFunc AotExecutorFactory::GetFunction(
       *rv = Module(exec);
     });
   } else {
+    LOG(INFO) << "Unknown packed function: " << name;
     return PackedFunc();
   }
 }

src/runtime/hexagon/hexagon_module.cc

@@ -53,7 +53,7 @@ HexagonHostModuleNode::HexagonHostModuleNode(std::string data, std::string fmt,
 PackedFunc HexagonHostModuleNode::GetFunction(const std::string& name,
                                               const ObjectPtr<Object>& sptr_to_self) {
   LOG(FATAL) << "HexagonHostModuleNode::GetFunction is not implemented.";
-  return nullptr;
+  return PackedFunc();
 }
 
 std::string HexagonHostModuleNode::GetSource(const std::string& format) {

src/runtime/pipeline/pipeline_executor.cc

@@ -86,7 +86,6 @@ PackedFunc PipelineExecutor::GetFunction(const std::string& name,
     LOG(FATAL) << "Unknown packed function: " << name;
     return PackedFunc();
   }
-  return nullptr;
 }
 
 /*!

src/runtime/vm/executable.cc

@@ -105,7 +105,7 @@ PackedFunc Executable::GetFunction(const std::string& name, const ObjectPtr<Obje
     });
   } else {
     LOG(FATAL) << "Unknown packed function: " << name;
-    return PackedFunc(nullptr);
+    return PackedFunc();
   }
 }
 

src/target/source/codegen_c_host.cc

@@ -28,7 +28,9 @@
 #include <tvm/runtime/module.h>
 #include <tvm/target/codegen.h>
 
+#include <algorithm>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "../../support/str_escape.h"
@@ -78,6 +80,23 @@ void CodeGenCHost::AddFunction(const PrimFunc& f) {
   }
 }
 
+void CodeGenCHost::AddFunctionsOrdered(
+    std::vector<std::pair<tvm::GlobalVar, tvm::BaseFunc>> functions) {
+  std::sort(functions.begin(), functions.end(),
+            [](std::pair<tvm::GlobalVar, tvm::BaseFunc> kv_a,
+               std::pair<tvm::GlobalVar, tvm::BaseFunc> kv_b) {
+              std::string name_hint_a = kv_a.first->name_hint;
+              std::string name_hint_b = kv_b.first->name_hint;
+              return name_hint_a < name_hint_b;
+            });
+
+  for (auto& kv : functions) {
+    ICHECK(kv.second->IsInstance<PrimFuncNode>()) << "CodegenCHost: Can only take PrimFunc";
+    auto f = Downcast<PrimFunc>(kv.second);
+    AddFunction(f);
+  }
+}
+
 void CodeGenCHost::PrintFuncPrefix() {  // NOLINT(*)
   stream << "#ifdef __cplusplus\n"
          << "extern \"C\"\n"
@@ -351,22 +370,24 @@ runtime::Module BuildCHost(IRModule mod, Target target) {
   Map<String, LinkedParam> linked_params;
   PrimFunc aot_executor_fn;
 
+  std::vector<std::pair<tvm::GlobalVar, tvm::BaseFunc>> funcs;
   for (auto kv : mod->functions) {
     // Make sure that the executor function is the last one to be code generated so that all the
-    // symbols are available to tvm_run_func
+    // symbols are available to __tvm_main__
     auto fun_name = std::string(kv.first->name_hint);
     bool is_aot_executor_fn = kv.second->GetAttr<Bool>("runner_function", Bool(false)).value();
 
     if (is_aot_executor_fn) {
       aot_executor_fn = Downcast<PrimFunc>(kv.second);
       continue;
     }
-
-    ICHECK(kv.second->IsInstance<PrimFuncNode>()) << "CodegenCHost: Can only take PrimFunc";
-    auto f = Downcast<PrimFunc>(kv.second);
-    cg.AddFunction(f);
+    funcs.push_back(kv);
   }
 
+  // Add all functions except __tvm_main__
+  cg.AddFunctionsOrdered(funcs);
+
+  // Add __tvm_main__
   if (aot_executor_fn.defined()) {
     cg.AddFunction(aot_executor_fn);
   }

src/target/source/codegen_c_host.h

@@ -26,6 +26,7 @@
 
 #include <string>
 #include <unordered_map>
+#include <utility>
 #include <vector>
 
 #include "codegen_c.h"
@@ -42,7 +43,12 @@ class CodeGenCHost : public CodeGenC {
 
   void InitGlobalContext();
   void AddFunction(const PrimFunc& f);
-
+  /*!
+   * \brief Add functions from the (unordered) range to the current module in a deterministic order.
+   *
+   * \param functions A vector of unordered range of current module.
+   */
+  void AddFunctionsOrdered(std::vector<std::pair<tvm::GlobalVar, tvm::BaseFunc>> functions);
   void DefineModuleName();
 
   void PrintType(DataType t, std::ostream& os) final;  // NOLINT(*)

src/target/source/interface_c.cc

@@ -90,7 +90,8 @@ class InterfaceCNode : public runtime::ModuleNode {
   }
 
   PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self) final {
-    return PackedFunc(nullptr);
+    LOG(INFO) << "GetFunction is not implemented in InterfaceCNode";
+    return PackedFunc();
   }
 
  private:

src/target/source/source_module.cc

@@ -103,6 +103,7 @@ class CSourceModuleNode : public runtime::ModuleNode {
       return PackedFunc(
           [sptr_to_self, this](TVMArgs args, TVMRetValue* rv) { *rv = this->func_names_; });
     } else {
+      LOG(INFO) << "Unknown packed function: " << name;
       return PackedFunc(nullptr);
     }
   }
@@ -171,7 +172,8 @@ class CSourceCrtMetadataModuleNode : public runtime::ModuleNode {
 
   std::string GetFormat() { return fmt_; }
   PackedFunc GetFunction(const std::string& name, const ObjectPtr<Object>& sptr_to_self) final {
-    return PackedFunc(nullptr);
+    LOG(INFO) << "GetFunction is not implemented in CSourceCrtMetadataModuleNode";
+    return PackedFunc();
   }
 
   void SaveToFile(const std::string& file_name, const std::string& format) final {

tests/cpp/c_codegen_test.cc

@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+#include <tvm/driver/driver_api.h>
+#include <tvm/ir/type.h>
+#include <tvm/node/reflection.h>
+#include <tvm/runtime/metadata.h>
+#include <tvm/runtime/module.h>
+#include <tvm/target/target.h>
+#include <tvm/te/operation.h>
+
+TEST(CCodegen, FunctionOrder) {
+  using namespace tvm;
+  using namespace tvm::te;
+
+  std::string tvm_module_main = std::string(runtime::symbol::tvm_module_main);
+
+  tvm::Target target_c = tvm::Target("c -keys=cpu -link-params=0");
+
+  const int n = 4;
+  Array<PrimExpr> shape{n};
+
+  auto A = placeholder(shape, DataType::Float(32), "A");
+  auto B = placeholder(shape, DataType::Float(32), "B");
+
+  auto elemwise_add = compute(
+      A->shape, [&A, &B](PrimExpr i) { return A[i] + B[i]; }, "elemwise_add");
+
+  auto fcreate = [=]() {
+    With<Target> llvm_scope(target_c);
+    return create_schedule({elemwise_add->op});
+  };
+
+  auto args = Array<Tensor>({A, B, elemwise_add});
+
+  std::unordered_map<Tensor, Buffer> binds;
+  auto lowered = LowerSchedule(fcreate(), args, "elemwise_add", binds);
+  Map<tvm::Target, IRModule> inputs = {{target_c, lowered}};
+  runtime::Module module = build(inputs, Target());
+  Array<String> functions = module->GetFunction("get_func_names", false)();
+
+  ICHECK(functions.back().compare(tvm_module_main) == 0);
+}