MS-517 Update resource_mgr_test in scheduler

Former-commit-id: 1ec8d4869bb1d863a2bd98d64180d19a77f3313b

cpp/CHANGELOG.md

@@ -98,6 +98,7 @@ Please mark all change in change log and use the ticket from JIRA.
 - MS-505 - Install core unit test and add to coverage
 - MS-508 - Update normal_test in scheduler
 - MS-511 - Update resource_test in scheduler
+- MS-517 - Update resource_mgr_test in scheduler
 
 ## New Feature
 - MS-343 - Implement ResourceMgr

cpp/src/scheduler/ResourceMgr.cpp

@@ -59,7 +59,7 @@ ResourceMgr::Add(ResourcePtr &&resource) {
     return ret;
 }
 
-void
+bool
 ResourceMgr::Connect(const std::string &name1, const std::string &name2, Connection &connection) {
     auto res1 = GetResource(name1);
     auto res2 = GetResource(name2);
@@ -67,7 +67,9 @@ ResourceMgr::Connect(const std::string &name1, const std::string &name2, Connect
         res1->AddNeighbour(std::static_pointer_cast<Node>(res2), connection);
         // TODO: enable when task balance supported
 //        res2->AddNeighbour(std::static_pointer_cast<Node>(res1), connection);
+        return true;
     }
+    return false;
 }
 
 void
@@ -78,7 +80,7 @@ ResourceMgr::Clear() {
 }
 
 std::vector<ResourcePtr>
-ResourceMgr::GetComputeResource() {
+ResourceMgr::GetComputeResources() {
     std::vector<ResourcePtr> result;
     for (auto &resource : resources_) {
         if (resource->HasExecutor()) {
@@ -109,7 +111,12 @@ ResourceMgr::GetResource(const std::string &name) {
 }
 
 uint64_t
-ResourceMgr::GetNumOfComputeResource() {
+ResourceMgr::GetNumOfResource() const {
+    return resources_.size();
+}
+
+uint64_t
+ResourceMgr::GetNumOfComputeResource() const {
     uint64_t count = 0;
     for (auto &res : resources_) {
         if (res->HasExecutor()) {

cpp/src/scheduler/ResourceMgr.h

@@ -35,7 +35,7 @@ public:
     ResourceWPtr
     Add(ResourcePtr &&resource);
 
-    void
+    bool
     Connect(const std::string &res1, const std::string &res2, Connection &connection);
 
     void
@@ -60,7 +60,7 @@ public:
     }
 
     std::vector<ResourcePtr>
-    GetComputeResource();
+    GetComputeResources();
 
     ResourcePtr
     GetResource(ResourceType type, uint64_t device_id);
@@ -69,7 +69,10 @@ public:
     GetResource(const std::string &name);
 
     uint64_t
-    GetNumOfComputeResource();
+    GetNumOfResource() const;
+
+    uint64_t
+    GetNumOfComputeResource() const;
 
     uint64_t
     GetNumGpuResource() const;

cpp/src/scheduler/Scheduler.cpp

@@ -151,7 +151,7 @@ Scheduler::OnLoadCompleted(const EventPtr &event) {
                 // if this resource is disk, assign it to smallest cost resource
                 if (self->type() == ResourceType::DISK) {
                     // step 1: calculate shortest path per resource, from disk to compute resource
-                    auto compute_resources = res_mgr_.lock()->GetComputeResource();
+                    auto compute_resources = res_mgr_.lock()->GetComputeResources();
                     std::vector<std::vector<std::string>> paths;
                     std::vector<uint64_t> transport_costs;
                     for (auto &res : compute_resources) {

cpp/unittest/CMakeLists.txt

@@ -46,5 +46,5 @@ add_subdirectory(server)
 add_subdirectory(db)
 add_subdirectory(knowhere)
 add_subdirectory(metrics)
-#add_subdirectory(scheduler)
+add_subdirectory(scheduler)
 #add_subdirectory(storage)
\ No newline at end of file

cpp/unittest/scheduler/normal_test.cpp

@@ -11,7 +11,7 @@
 using namespace zilliz::milvus::engine;
 
 
-TEST(normal_test, inst_test) {
+TEST(normal_test, DISABLED_inst_test) {
     // ResourceMgr only compose resources, provide unified event
     auto res_mgr = ResMgrInst::GetInstance();
 

cpp/unittest/scheduler/resource_mgr_test.cpp

+/*******************************************************************************
+ * Copyright 上海赜睿信息科技有限公司(Zilliz) - All Rights Reserved
+ * Unauthorized copying of this file, via any medium is strictly prohibited.
+ * Proprietary and confidential.
+ ******************************************************************************/
+
+#include "scheduler/resource/CpuResource.h"
+#include "scheduler/resource/GpuResource.h"
+#include "scheduler/resource/DiskResource.h"
+#include "scheduler/resource/TestResource.h"
+#include "scheduler/task/TestTask.h"
+#include "scheduler/ResourceMgr.h"
+#include <gtest/gtest.h>
+
+
+namespace zilliz {
+namespace milvus {
+namespace engine {
+
+
+/************ ResourceMgrBaseTest ************/
+class ResourceMgrBaseTest : public testing::Test {
+protected:
+    void
+    SetUp() override {
+        empty_mgr_ = std::make_shared<ResourceMgr>();
+        mgr1_ = std::make_shared<ResourceMgr>();
+        disk_res = std::make_shared<DiskResource>("disk", 0, true, false);
+        cpu_res = std::make_shared<CpuResource>("cpu", 1, true, false);
+        gpu_res = std::make_shared<GpuResource>("gpu", 2, true, true);
+        mgr1_->Add(ResourcePtr(disk_res));
+        mgr1_->Add(ResourcePtr(cpu_res));
+        mgr1_->Add(ResourcePtr(gpu_res));
+    }
+
+    void
+    TearDown() override {
+    }
+
+    ResourceMgrPtr empty_mgr_;
+    ResourceMgrPtr mgr1_;
+    ResourcePtr disk_res;
+    ResourcePtr cpu_res;
+    ResourcePtr gpu_res;
+};
+
+TEST_F(ResourceMgrBaseTest, add) {
+    auto resource = std::make_shared<TestResource>("test", 0, true, true);
+    auto ret = empty_mgr_->Add(ResourcePtr(resource));
+    ASSERT_EQ(ret.lock(), resource);
+}
+
+TEST_F(ResourceMgrBaseTest, add_disk) {
+    auto resource = std::make_shared<DiskResource>("disk", 0, true, true);
+    auto ret = empty_mgr_->Add(ResourcePtr(resource));
+    ASSERT_EQ(ret.lock(), resource);
+}
+
+TEST_F(ResourceMgrBaseTest, connect) {
+    auto resource1 = std::make_shared<TestResource>("resource1", 0, true, true);
+    auto resource2 = std::make_shared<TestResource>("resource2", 2, true, true);
+    empty_mgr_->Add(resource1);
+    empty_mgr_->Add(resource2);
+    Connection io("io", 500.0);
+    ASSERT_TRUE(empty_mgr_->Connect("resource1", "resource2", io));
+}
+
+
+TEST_F(ResourceMgrBaseTest, invalid_connect) {
+    auto resource1 = std::make_shared<TestResource>("resource1", 0, true, true);
+    auto resource2 = std::make_shared<TestResource>("resource2", 2, true, true);
+    empty_mgr_->Add(resource1);
+    empty_mgr_->Add(resource2);
+    Connection io("io", 500.0);
+    ASSERT_FALSE(empty_mgr_->Connect("xx", "yy", io));
+}
+
+
+TEST_F(ResourceMgrBaseTest, clear) {
+    ASSERT_EQ(mgr1_->GetNumOfResource(), 3);
+    mgr1_->Clear();
+    ASSERT_EQ(mgr1_->GetNumOfResource(), 0);
+}
+
+TEST_F(ResourceMgrBaseTest, get_disk_resources) {
+    auto disks = mgr1_->GetDiskResources();
+    ASSERT_EQ(disks.size(), 1);
+    ASSERT_EQ(disks[0].lock(), disk_res);
+}
+
+TEST_F(ResourceMgrBaseTest, get_all_resources) {
+    bool disk = false, cpu = false, gpu = false;
+    auto resources = mgr1_->GetAllResources();
+    ASSERT_EQ(resources.size(), 3);
+    for (auto &res : resources) {
+        if (res->type() == ResourceType::DISK) disk = true;
+        if (res->type() == ResourceType::CPU) cpu = true;
+        if (res->type() == ResourceType::GPU) gpu = true;
+    }
+
+    ASSERT_TRUE(disk);
+    ASSERT_TRUE(cpu);
+    ASSERT_TRUE(gpu);
+}
+
+TEST_F(ResourceMgrBaseTest, get_compute_resources) {
+    auto compute_resources = mgr1_->GetComputeResources();
+    ASSERT_EQ(compute_resources.size(), 1);
+    ASSERT_EQ(compute_resources[0], gpu_res);
+}
+
+TEST_F(ResourceMgrBaseTest, get_resource_by_type_and_deviceid) {
+    auto cpu = mgr1_->GetResource(ResourceType::CPU, 1);
+    ASSERT_EQ(cpu, cpu_res);
+
+    auto invalid = mgr1_->GetResource(ResourceType::GPU, 1);
+    ASSERT_EQ(invalid, nullptr);
+}
+
+TEST_F(ResourceMgrBaseTest, get_resource_by_name) {
+    auto disk = mgr1_->GetResource("disk");
+    ASSERT_EQ(disk, disk_res);
+
+    auto invalid = mgr1_->GetResource("invalid");
+    ASSERT_EQ(invalid, nullptr);
+}
+
+TEST_F(ResourceMgrBaseTest, get_num_of_resource) {
+    ASSERT_EQ(empty_mgr_->GetNumOfResource(), 0);
+    ASSERT_EQ(mgr1_->GetNumOfResource(), 3);
+}
+
+TEST_F(ResourceMgrBaseTest, get_num_of_compute_resource) {
+    ASSERT_EQ(empty_mgr_->GetNumOfComputeResource(), 0);
+    ASSERT_EQ(mgr1_->GetNumOfComputeResource(), 1);
+}
+
+TEST_F(ResourceMgrBaseTest, get_num_of_gpu_resource) {
+    ASSERT_EQ(empty_mgr_->GetNumGpuResource(), 0);
+    ASSERT_EQ(mgr1_->GetNumGpuResource(), 1);
+}
+
+TEST_F(ResourceMgrBaseTest, dump) {
+    ASSERT_FALSE(mgr1_->Dump().empty());
+}
+
+TEST_F(ResourceMgrBaseTest, dump_tasktables) {
+    ASSERT_FALSE(mgr1_->DumpTaskTables().empty());
+}
+
+/************ ResourceMgrAdvanceTest ************/
+
+class ResourceMgrAdvanceTest : public testing::Test {
+    protected:
+    void
+    SetUp() override {
+        mgr1_ = std::make_shared<ResourceMgr>();
+        disk_res = std::make_shared<DiskResource>("disk", 0, true, false);
+        mgr1_->Add(ResourcePtr(disk_res));
+        mgr1_->Start();
+    }
+
+    void
+    TearDown() override {
+        mgr1_->Stop();
+    }
+
+    ResourceMgrPtr mgr1_;
+    ResourcePtr disk_res;
+};
+
+TEST_F(ResourceMgrAdvanceTest, register_subscriber) {
+    bool flag = false;
+    auto callback = [&](EventPtr event) {
+        flag = true;
+    };
+    mgr1_->RegisterSubscriber(callback);
+    TableFileSchemaPtr dummy = nullptr;
+    disk_res->task_table().Put(std::make_shared<TestTask>(dummy));
+    sleep(1);
+    ASSERT_TRUE(flag);
+}
+
+
+}
+}
+}

cpp/unittest/scheduler/scheduler_test.cpp

@@ -19,229 +19,229 @@ namespace zilliz {
 namespace milvus {
 namespace engine {
 
-class MockVecIndex : public engine::VecIndex {
-public:
-    virtual server::KnowhereError BuildAll(const long &nb,
-                                           const float *xb,
-                                           const long *ids,
-                                           const engine::Config &cfg,
-                                           const long &nt = 0,
-                                           const float *xt = nullptr) {
-
-    }
-
-    engine::VecIndexPtr Clone() override {
-        return zilliz::milvus::engine::VecIndexPtr();
-    }
-
-    int64_t GetDeviceId() override {
-        return 0;
-    }
-
-    engine::IndexType GetType() override {
-        return engine::IndexType::INVALID;
-    }
-
-    virtual server::KnowhereError Add(const long &nb,
-                                      const float *xb,
-                                      const long *ids,
-                                      const engine::Config &cfg = engine::Config()) {
-
-    }
-
-    virtual server::KnowhereError Search(const long &nq,
-                                         const float *xq,
-                                         float *dist,
-                                         long *ids,
-                                         const engine::Config &cfg = engine::Config()) {
-
-    }
-
-    engine::VecIndexPtr CopyToGpu(const int64_t &device_id, const engine::Config &cfg) override {
-
-    }
-
-    engine::VecIndexPtr CopyToCpu(const engine::Config &cfg) override {
-
-    }
-
-    virtual int64_t Dimension() {
-        return dimension_;
-    }
-
-    virtual int64_t Count() {
-        return ntotal_;
-    }
-
-    virtual zilliz::knowhere::BinarySet Serialize() {
-        zilliz::knowhere::BinarySet binset;
-        return binset;
-    }
-
-    virtual server::KnowhereError Load(const zilliz::knowhere::BinarySet &index_binary) {
-
-    }
-
-public:
-    int64_t dimension_ = 512;
-    int64_t ntotal_ = 0;
-};
-
-
-class SchedulerTest : public testing::Test {
-protected:
-    void
-    SetUp() override {
-        ResourcePtr cpu = ResourceFactory::Create("cpu", "CPU", 0, true, false);
-        ResourcePtr gpu_0 = ResourceFactory::Create("gpu0", "GPU", 0);
-        ResourcePtr gpu_1 = ResourceFactory::Create("gpu1", "GPU", 1);
-
-        res_mgr_ = std::make_shared<ResourceMgr>();
-        cpu_resource_ = res_mgr_->Add(std::move(cpu));
-        gpu_resource_0_ = res_mgr_->Add(std::move(gpu_0));
-        gpu_resource_1_ = res_mgr_->Add(std::move(gpu_1));
-
-        auto PCIE = Connection("IO", 11000.0);
-        res_mgr_->Connect("cpu", "gpu0", PCIE);
-        res_mgr_->Connect("cpu", "gpu1", PCIE);
-
-        scheduler_ = std::make_shared<Scheduler>(res_mgr_);
-
-        res_mgr_->Start();
-        scheduler_->Start();
-    }
-
-    void
-    TearDown() override {
-        scheduler_->Stop();
-        res_mgr_->Stop();
-    }
-
-    ResourceWPtr cpu_resource_;
-    ResourceWPtr gpu_resource_0_;
-    ResourceWPtr gpu_resource_1_;
-
-    ResourceMgrPtr res_mgr_;
-    std::shared_ptr<Scheduler> scheduler_;
-};
-
-void
-insert_dummy_index_into_gpu_cache(uint64_t device_id) {
-    MockVecIndex* mock_index = new MockVecIndex();
-    mock_index->ntotal_ = 1000;
-    engine::VecIndexPtr index(mock_index);
-
-    cache::DataObjPtr obj = std::make_shared<cache::DataObj>(index);
-
-    cache::GpuCacheMgr::GetInstance(device_id)->InsertItem("location",obj);
-}
-
-TEST_F(SchedulerTest, OnCopyCompleted) {
-    const uint64_t NUM = 10;
-    std::vector<std::shared_ptr<TestTask>> tasks;
-    TableFileSchemaPtr dummy = std::make_shared<meta::TableFileSchema>();
-    dummy->location_ = "location";
-
-    insert_dummy_index_into_gpu_cache(1);
-
-    for (uint64_t i = 0; i < NUM; ++i) {
-        auto task = std::make_shared<TestTask>(dummy);
-        task->label() = std::make_shared<DefaultLabel>();
-        tasks.push_back(task);
-        cpu_resource_.lock()->task_table().Put(task);
-    }
-
-    sleep(3);
-    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
-
-}
-
-TEST_F(SchedulerTest, PushTaskToNeighbourRandomlyTest) {
-    const uint64_t NUM = 10;
-    std::vector<std::shared_ptr<TestTask>> tasks;
-    TableFileSchemaPtr dummy1 = std::make_shared<meta::TableFileSchema>();
-    dummy1->location_ = "location";
-
-    tasks.clear();
-
-    for (uint64_t i = 0; i < NUM; ++i) {
-        auto task = std::make_shared<TestTask>(dummy1);
-        task->label() = std::make_shared<DefaultLabel>();
-        tasks.push_back(task);
-        cpu_resource_.lock()->task_table().Put(task);
-    }
-
-    sleep(3);
+//class MockVecIndex : public engine::VecIndex {
+//public:
+//    virtual server::KnowhereError BuildAll(const long &nb,
+//                                           const float *xb,
+//                                           const long *ids,
+//                                           const engine::Config &cfg,
+//                                           const long &nt = 0,
+//                                           const float *xt = nullptr) {
+//
+//    }
+//
+//    engine::VecIndexPtr Clone() override {
+//        return zilliz::milvus::engine::VecIndexPtr();
+//    }
+//
+//    int64_t GetDeviceId() override {
+//        return 0;
+//    }
+//
+//    engine::IndexType GetType() override {
+//        return engine::IndexType::INVALID;
+//    }
+//
+//    virtual server::KnowhereError Add(const long &nb,
+//                                      const float *xb,
+//                                      const long *ids,
+//                                      const engine::Config &cfg = engine::Config()) {
+//
+//    }
+//
+//    virtual server::KnowhereError Search(const long &nq,
+//                                         const float *xq,
+//                                         float *dist,
+//                                         long *ids,
+//                                         const engine::Config &cfg = engine::Config()) {
+//
+//    }
+//
+//    engine::VecIndexPtr CopyToGpu(const int64_t &device_id, const engine::Config &cfg) override {
+//
+//    }
+//
+//    engine::VecIndexPtr CopyToCpu(const engine::Config &cfg) override {
+//
+//    }
+//
+//    virtual int64_t Dimension() {
+//        return dimension_;
+//    }
+//
+//    virtual int64_t Count() {
+//        return ntotal_;
+//    }
+//
+//    virtual zilliz::knowhere::BinarySet Serialize() {
+//        zilliz::knowhere::BinarySet binset;
+//        return binset;
+//    }
+//
+//    virtual server::KnowhereError Load(const zilliz::knowhere::BinarySet &index_binary) {
+//
+//    }
+//
+//public:
+//    int64_t dimension_ = 512;
+//    int64_t ntotal_ = 0;
+//};
+//
+//
+//class SchedulerTest : public testing::Test {
+//protected:
+//    void
+//    SetUp() override {
+//        ResourcePtr cpu = ResourceFactory::Create("cpu", "CPU", 0, true, false);
+//        ResourcePtr gpu_0 = ResourceFactory::Create("gpu0", "GPU", 0);
+//        ResourcePtr gpu_1 = ResourceFactory::Create("gpu1", "GPU", 1);
+//
+//        res_mgr_ = std::make_shared<ResourceMgr>();
+//        cpu_resource_ = res_mgr_->Add(std::move(cpu));
+//        gpu_resource_0_ = res_mgr_->Add(std::move(gpu_0));
+//        gpu_resource_1_ = res_mgr_->Add(std::move(gpu_1));
+//
+//        auto PCIE = Connection("IO", 11000.0);
+//        res_mgr_->Connect("cpu", "gpu0", PCIE);
+//        res_mgr_->Connect("cpu", "gpu1", PCIE);
+//
+//        scheduler_ = std::make_shared<Scheduler>(res_mgr_);
+//
+//        res_mgr_->Start();
+//        scheduler_->Start();
+//    }
+//
+//    void
+//    TearDown() override {
+//        scheduler_->Stop();
+//        res_mgr_->Stop();
+//    }
+//
+//    ResourceWPtr cpu_resource_;
+//    ResourceWPtr gpu_resource_0_;
+//    ResourceWPtr gpu_resource_1_;
+//
+//    ResourceMgrPtr res_mgr_;
+//    std::shared_ptr<Scheduler> scheduler_;
+//};
+//
+//void
+//insert_dummy_index_into_gpu_cache(uint64_t device_id) {
+//    MockVecIndex* mock_index = new MockVecIndex();
+//    mock_index->ntotal_ = 1000;
+//    engine::VecIndexPtr index(mock_index);
+//
+//    cache::DataObjPtr obj = std::make_shared<cache::DataObj>(index);
+//
+//    cache::GpuCacheMgr::GetInstance(device_id)->InsertItem("location",obj);
+//}
+//
+//TEST_F(SchedulerTest, OnCopyCompleted) {
+//    const uint64_t NUM = 10;
+//    std::vector<std::shared_ptr<TestTask>> tasks;
+//    TableFileSchemaPtr dummy = std::make_shared<meta::TableFileSchema>();
+//    dummy->location_ = "location";
+//
+//    insert_dummy_index_into_gpu_cache(1);
+//
+//    for (uint64_t i = 0; i < NUM; ++i) {
+//        auto task = std::make_shared<TestTask>(dummy);
+//        task->label() = std::make_shared<DefaultLabel>();
+//        tasks.push_back(task);
+//        cpu_resource_.lock()->task_table().Put(task);
+//    }
+//
+//    sleep(3);
 //    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
-}
-
-class SchedulerTest2 : public testing::Test {
- protected:
-    void
-    SetUp() override {
-        ResourcePtr disk = ResourceFactory::Create("disk", "DISK", 0, true, false);
-        ResourcePtr cpu0 = ResourceFactory::Create("cpu0", "CPU", 0, true, false);
-        ResourcePtr cpu1 = ResourceFactory::Create("cpu1", "CPU", 1, true, false);
-        ResourcePtr cpu2 = ResourceFactory::Create("cpu2", "CPU", 2, true, false);
-        ResourcePtr gpu0 = ResourceFactory::Create("gpu0", "GPU", 0, true, true);
-        ResourcePtr gpu1 = ResourceFactory::Create("gpu1", "GPU", 1, true, true);
-
-        res_mgr_ = std::make_shared<ResourceMgr>();
-        disk_ = res_mgr_->Add(std::move(disk));
-        cpu_0_ = res_mgr_->Add(std::move(cpu0));
-        cpu_1_ = res_mgr_->Add(std::move(cpu1));
-        cpu_2_ = res_mgr_->Add(std::move(cpu2));
-        gpu_0_ = res_mgr_->Add(std::move(gpu0));
-        gpu_1_ = res_mgr_->Add(std::move(gpu1));
-        auto IO = Connection("IO", 5.0);
-        auto PCIE1 = Connection("PCIE", 11.0);
-        auto PCIE2 = Connection("PCIE", 20.0);
-        res_mgr_->Connect("disk", "cpu0", IO);
-        res_mgr_->Connect("cpu0", "cpu1", IO);
-        res_mgr_->Connect("cpu1", "cpu2", IO);
-        res_mgr_->Connect("cpu0", "cpu2", IO);
-        res_mgr_->Connect("cpu1", "gpu0", PCIE1);
-        res_mgr_->Connect("cpu2", "gpu1", PCIE2);
-
-        scheduler_ = std::make_shared<Scheduler>(res_mgr_);
-
-        res_mgr_->Start();
-        scheduler_->Start();
-    }
-
-    void
-    TearDown() override {
-        scheduler_->Stop();
-        res_mgr_->Stop();
-    }
-
-    ResourceWPtr disk_;
-    ResourceWPtr cpu_0_;
-    ResourceWPtr cpu_1_;
-    ResourceWPtr cpu_2_;
-    ResourceWPtr gpu_0_;
-    ResourceWPtr gpu_1_;
-    ResourceMgrPtr res_mgr_;
-
-    std::shared_ptr<Scheduler> scheduler_;
-};
-
-
-TEST_F(SchedulerTest2, SpecifiedResourceTest) {
-    const uint64_t NUM = 10;
-    std::vector<std::shared_ptr<TestTask>> tasks;
-    TableFileSchemaPtr dummy = std::make_shared<meta::TableFileSchema>();
-    dummy->location_ = "location";
-
-    for (uint64_t i = 0; i < NUM; ++i) {
-        std::shared_ptr<TestTask> task = std::make_shared<TestTask>(dummy);
-        task->label() = std::make_shared<SpecResLabel>(disk_);
-        tasks.push_back(task);
-        disk_.lock()->task_table().Put(task);
-    }
-
-//    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
-}
+//
+//}
+//
+//TEST_F(SchedulerTest, PushTaskToNeighbourRandomlyTest) {
+//    const uint64_t NUM = 10;
+//    std::vector<std::shared_ptr<TestTask>> tasks;
+//    TableFileSchemaPtr dummy1 = std::make_shared<meta::TableFileSchema>();
+//    dummy1->location_ = "location";
+//
+//    tasks.clear();
+//
+//    for (uint64_t i = 0; i < NUM; ++i) {
+//        auto task = std::make_shared<TestTask>(dummy1);
+//        task->label() = std::make_shared<DefaultLabel>();
+//        tasks.push_back(task);
+//        cpu_resource_.lock()->task_table().Put(task);
+//    }
+//
+//    sleep(3);
+////    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
+//}
+//
+//class SchedulerTest2 : public testing::Test {
+// protected:
+//    void
+//    SetUp() override {
+//        ResourcePtr disk = ResourceFactory::Create("disk", "DISK", 0, true, false);
+//        ResourcePtr cpu0 = ResourceFactory::Create("cpu0", "CPU", 0, true, false);
+//        ResourcePtr cpu1 = ResourceFactory::Create("cpu1", "CPU", 1, true, false);
+//        ResourcePtr cpu2 = ResourceFactory::Create("cpu2", "CPU", 2, true, false);
+//        ResourcePtr gpu0 = ResourceFactory::Create("gpu0", "GPU", 0, true, true);
+//        ResourcePtr gpu1 = ResourceFactory::Create("gpu1", "GPU", 1, true, true);
+//
+//        res_mgr_ = std::make_shared<ResourceMgr>();
+//        disk_ = res_mgr_->Add(std::move(disk));
+//        cpu_0_ = res_mgr_->Add(std::move(cpu0));
+//        cpu_1_ = res_mgr_->Add(std::move(cpu1));
+//        cpu_2_ = res_mgr_->Add(std::move(cpu2));
+//        gpu_0_ = res_mgr_->Add(std::move(gpu0));
+//        gpu_1_ = res_mgr_->Add(std::move(gpu1));
+//        auto IO = Connection("IO", 5.0);
+//        auto PCIE1 = Connection("PCIE", 11.0);
+//        auto PCIE2 = Connection("PCIE", 20.0);
+//        res_mgr_->Connect("disk", "cpu0", IO);
+//        res_mgr_->Connect("cpu0", "cpu1", IO);
+//        res_mgr_->Connect("cpu1", "cpu2", IO);
+//        res_mgr_->Connect("cpu0", "cpu2", IO);
+//        res_mgr_->Connect("cpu1", "gpu0", PCIE1);
+//        res_mgr_->Connect("cpu2", "gpu1", PCIE2);
+//
+//        scheduler_ = std::make_shared<Scheduler>(res_mgr_);
+//
+//        res_mgr_->Start();
+//        scheduler_->Start();
+//    }
+//
+//    void
+//    TearDown() override {
+//        scheduler_->Stop();
+//        res_mgr_->Stop();
+//    }
+//
+//    ResourceWPtr disk_;
+//    ResourceWPtr cpu_0_;
+//    ResourceWPtr cpu_1_;
+//    ResourceWPtr cpu_2_;
+//    ResourceWPtr gpu_0_;
+//    ResourceWPtr gpu_1_;
+//    ResourceMgrPtr res_mgr_;
+//
+//    std::shared_ptr<Scheduler> scheduler_;
+//};
+//
+//
+//TEST_F(SchedulerTest2, SpecifiedResourceTest) {
+//    const uint64_t NUM = 10;
+//    std::vector<std::shared_ptr<TestTask>> tasks;
+//    TableFileSchemaPtr dummy = std::make_shared<meta::TableFileSchema>();
+//    dummy->location_ = "location";
+//
+//    for (uint64_t i = 0; i < NUM; ++i) {
+//        std::shared_ptr<TestTask> task = std::make_shared<TestTask>(dummy);
+//        task->label() = std::make_shared<SpecResLabel>(disk_);
+//        tasks.push_back(task);
+//        disk_.lock()->task_table().Put(task);
+//    }
+//
+////    ASSERT_EQ(res_mgr_->GetResource(ResourceType::GPU, 1)->task_table().Size(), NUM);
+//}
 
 }
 }