framework: set task priority according to sched conf for classic policy (#1940)

cyber/scheduler/policy/scheduler_classic.cc

@@ -47,10 +47,16 @@ SchedulerClassic::SchedulerClassic() {
   apollo::cyber::proto::CyberConfig cfg;
   // FIXME: later, we will add grp support for classic policy.
   if (PathExists(cfg_file) && GetProtoFromFile(cfg_file, &cfg)) {
-    proc_num_ = cfg.scheduler_conf().classic_conf().groups(0).processor_num();
-    affinity_ = cfg.scheduler_conf().classic_conf().groups(0).affinity();
-    ParseCpuset(cfg.scheduler_conf().classic_conf().groups(0).cpuset(),
-                &cpuset_);
+    auto& groups = cfg.scheduler_conf().classic_conf().groups();
+    proc_num_ = groups[0].processor_num();
+    affinity_ = groups[0].affinity();
+    ParseCpuset(groups[0].cpuset(), &cpuset_);
+
+    for (auto& group : groups) {
+      for (auto& task : group.tasks()) {
+        cr_tasks[task.name()] = task;
+      }
+    }
   } else {
     // fallback default sched config. To avoid every process launchs
     // too many threads, limit to 2 cpus for process w/o explicit config.
@@ -91,10 +97,13 @@ bool SchedulerClassic::DispatchTask(const std::shared_ptr<CRoutine> cr) {
     id_cr_[cr->id()] = cr;
   }
 
+  if (cr_tasks.find(cr->name()) != cr_tasks.end()) {
+    cr->set_priority(cr_tasks[cr->name()].prio());
+  }
+
   // Check if task prio is reasonable.
   if (cr->priority() >= MAX_PRIO) {
-    AWARN << cr->name()
-          << " prio great than MAX_PRIO.";
+    AWARN << cr->name() << " prio great than MAX_PRIO.";
     cr->set_priority(MAX_PRIO - 1);
   }
 

cyber/scheduler/policy/scheduler_classic.h

@@ -20,6 +20,7 @@
 #include <memory>
 #include <string>
 #include <vector>
+#include <map>
 
 #include "cyber/scheduler/scheduler.h"
 
@@ -27,6 +28,8 @@ namespace apollo {
 namespace cyber {
 namespace scheduler {
 
+using apollo::cyber::proto::ClassicTask;
+
 class SchedulerClassic : public Scheduler {
  public:
   SchedulerClassic();
@@ -39,6 +42,7 @@ class SchedulerClassic : public Scheduler {
   void CreateProcessor();
   bool DispatchTask(const std::shared_ptr<CRoutine>) override;
   bool NotifyProcessor(uint64_t crid) override;
+  std::map<std::string, ClassicTask> cr_tasks;
 
   std::string affinity_;
   std::vector<int> cpuset_;

cyber/scheduler/scheduler_policy_test.cc

@@ -20,6 +20,9 @@
 #include "cyber/scheduler/policy/choreography.h"
 #include "cyber/scheduler/policy/classic.h"
 #include "cyber/scheduler/processor.h"
+#include "cyber/scheduler/policy/scheduler_classic.h"
+#include "cyber/scheduler/policy/scheduler_choreography.h"
+#include "cyber/common/global_data.h"
 
 namespace apollo {
 namespace cyber {
@@ -53,6 +56,12 @@ TEST(SchedulerPolicyTest, classic) {
   ctx->ShutDown();
 }
 
+TEST(SchedulerPolicyTest, sched_classic) {
+  GlobalData::Instance()->SetProcessGroup("example_classic_sched");
+  Scheduler* sched1 = new SchedulerClassic();
+  sched1->ShutDown();
+}
+
 }  // namespace scheduler
 }  // namespace cyber
 }  // namespace apollo

cyber/scheduler/scheduler_test.cc

@@ -28,17 +28,19 @@ namespace apollo {
 namespace cyber {
 namespace scheduler {
 
-auto sched = Scheduler::Instance();
-
 void proc() {}
 
 TEST(SchedulerTest, create_task) {
+  GlobalData::Instance()->SetProcessGroup("example_classic_sched");
+  auto sched = Scheduler::Instance();
   cyber::Init("scheduler_test");
-  std::string croutine_name = "DriverProc";
+  // read example_classic_sched.conf task 'ABC' prio
+  std::string croutine_name = "ABC";
 
   EXPECT_TRUE(sched->CreateTask(&proc, croutine_name));
   // create a croutine with the same name
   EXPECT_FALSE(sched->CreateTask(&proc, croutine_name));
+
   auto task_id = GlobalData::RegisterTaskName(croutine_name);
   EXPECT_TRUE(sched->NotifyTask(task_id));
   EXPECT_TRUE(sched->RemoveTask(croutine_name));
@@ -49,6 +51,7 @@ TEST(SchedulerTest, create_task) {
 }
 
 TEST(SchedulerTest, notify_task) {
+  auto sched = Scheduler::Instance();
   cyber::Init("scheduler_test");
   std::string name = "croutine";
   auto id = GlobalData::RegisterTaskName(name);