ceph/src/test/osd/TestMClockClientQueue.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2
   3 #include <iostream>
   4
   5 #include "gtest/gtest.h"
   6 #include "global/global_init.h"
   7 #include "common/common_init.h"
   8
   9 #include "osd/mClockClientQueue.h"
  10
  11
  12 int main(int argc, char **argv) {
  13   std::vector<const char*> args(argv, argv+argc);
  14   auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD,
  15                          CODE_ENVIRONMENT_UTILITY,
  16                          CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
  17   common_init_finish(g_ceph_context);
  18
  19   ::testing::InitGoogleTest(&argc, argv);
  20   return RUN_ALL_TESTS();
  21 }
  22
  23
  24 class MClockClientQueueTest : public testing::Test {
  25 public:
  26   mClockClientQueue q;
  27
  28   entity_inst_t client1;
  29   entity_inst_t client2;
  30   entity_inst_t client3;
  31
  32   MClockClientQueueTest() :
  33     q(g_ceph_context),
  34     client1(entity_name_t(CEPH_ENTITY_TYPE_OSD, 1), entity_addr_t()),
  35     client2(entity_name_t(CEPH_ENTITY_TYPE_OSD, 2), entity_addr_t()),
  36     client3(entity_name_t(CEPH_ENTITY_TYPE_CLIENT, 1), entity_addr_t())
  37   {}
  38
  39 #if 0 // more work needed here
  40   Request create_client_op(epoch_t e, const entity_inst_t& owner) {
  41     return Request(spg_t(), PGQueueable(OpRequestRef(), e));
  42   }
  43 #endif
  44
  45   Request create_snaptrim(epoch_t e, const entity_inst_t& owner) {
  46     return Request(spg_t(),
  47                    PGQueueable(PGSnapTrim(e),
  48                                12, 12,
  49                                utime_t(), owner, e));
  50   }
  51
  52   Request create_scrub(epoch_t e, const entity_inst_t& owner) {
  53     return Request(spg_t(),
  54                    PGQueueable(PGScrub(e),
  55                                12, 12,
  56                                utime_t(), owner, e));
  57   }
  58
  59   Request create_recovery(epoch_t e, const entity_inst_t& owner) {
  60     return Request(spg_t(),
  61                    PGQueueable(PGRecovery(e, 64),
  62                                12, 12,
  63                                utime_t(), owner, e));
  64   }
  65 };
  66
  67
  68 TEST_F(MClockClientQueueTest, TestSize) {
  69   ASSERT_TRUE(q.empty());
  70   ASSERT_EQ(0u, q.length());
  71
  72   q.enqueue(client1, 12, 0, create_snaptrim(100, client1));
  73   q.enqueue_strict(client2, 12, create_snaptrim(101, client2));
  74   q.enqueue(client2, 12, 0, create_snaptrim(102, client2));
  75   q.enqueue_strict(client3, 12, create_snaptrim(103, client3));
  76   q.enqueue(client1, 12, 0, create_snaptrim(104, client1));
  77
  78   ASSERT_FALSE(q.empty());
  79   ASSERT_EQ(5u, q.length());
  80
  81   std::list<Request> reqs;
  82
  83   reqs.push_back(q.dequeue());
  84   reqs.push_back(q.dequeue());
  85   reqs.push_back(q.dequeue());
  86
  87   ASSERT_FALSE(q.empty());
  88   ASSERT_EQ(2u, q.length());
  89
  90   q.enqueue_front(client2, 12, 0, reqs.back());
  91   reqs.pop_back();
  92
  93   q.enqueue_strict_front(client3, 12, reqs.back());
  94   reqs.pop_back();
  95
  96   q.enqueue_strict_front(client2, 12, reqs.back());
  97   reqs.pop_back();
  98
  99   ASSERT_FALSE(q.empty());
 100   ASSERT_EQ(5u, q.length());
 101
 102   for (int i = 0; i < 5; ++i) {
 103     (void) q.dequeue();
 104   }
 105
 106   ASSERT_TRUE(q.empty());
 107   ASSERT_EQ(0u, q.length());
 108 }
 109
 110
 111 TEST_F(MClockClientQueueTest, TestEnqueue) {
 112   q.enqueue(client1, 12, 0, create_snaptrim(100, client1));
 113   q.enqueue(client2, 12, 0, create_snaptrim(101, client2));
 114   q.enqueue(client2, 12, 0, create_snaptrim(102, client2));
 115   q.enqueue(client3, 12, 0, create_snaptrim(103, client3));
 116   q.enqueue(client1, 12, 0, create_snaptrim(104, client1));
 117
 118   Request r = q.dequeue();
 119   ASSERT_EQ(100u, r.second.get_map_epoch());
 120
 121   r = q.dequeue();
 122   ASSERT_EQ(101u, r.second.get_map_epoch());
 123
 124   r = q.dequeue();
 125   ASSERT_EQ(103u, r.second.get_map_epoch());
 126
 127   r = q.dequeue();
 128   ASSERT_TRUE(r.second.get_map_epoch() == 102u ||
 129               r.second.get_map_epoch() == 104u);
 130
 131   r = q.dequeue();
 132   ASSERT_TRUE(r.second.get_map_epoch() == 102u ||
 133               r.second.get_map_epoch() == 104u);
 134 }
 135
 136
 137 TEST_F(MClockClientQueueTest, TestEnqueueStrict) {
 138   q.enqueue_strict(client1, 12, create_snaptrim(100, client1));
 139   q.enqueue_strict(client2, 13, create_snaptrim(101, client2));
 140   q.enqueue_strict(client2, 16, create_snaptrim(102, client2));
 141   q.enqueue_strict(client3, 14, create_snaptrim(103, client3));
 142   q.enqueue_strict(client1, 15, create_snaptrim(104, client1));
 143
 144   Request r = q.dequeue();
 145   ASSERT_EQ(102u, r.second.get_map_epoch());
 146
 147   r = q.dequeue();
 148   ASSERT_EQ(104u, r.second.get_map_epoch());
 149
 150   r = q.dequeue();
 151   ASSERT_EQ(103u, r.second.get_map_epoch());
 152
 153   r = q.dequeue();
 154   ASSERT_EQ(101u, r.second.get_map_epoch());
 155
 156   r = q.dequeue();
 157   ASSERT_EQ(100u, r.second.get_map_epoch());
 158 }
 159
 160
 161 TEST_F(MClockClientQueueTest, TestRemoveByClass) {
 162   q.enqueue(client1, 12, 0, create_snaptrim(100, client1));
 163   q.enqueue_strict(client2, 12, create_snaptrim(101, client2));
 164   q.enqueue(client2, 12, 0, create_snaptrim(102, client2));
 165   q.enqueue_strict(client3, 12, create_snaptrim(103, client3));
 166   q.enqueue(client1, 12, 0, create_snaptrim(104, client1));
 167
 168   std::list<Request> filtered_out;
 169   q.remove_by_class(client2, &filtered_out);
 170
 171   ASSERT_EQ(2u, filtered_out.size());
 172   while (!filtered_out.empty()) {
 173     auto e = filtered_out.front().second.get_map_epoch() ;
 174     ASSERT_TRUE(e == 101 || e == 102);
 175     filtered_out.pop_front();
 176   }
 177
 178   ASSERT_EQ(3u, q.length());
 179   Request r = q.dequeue();
 180   ASSERT_EQ(103u, r.second.get_map_epoch());
 181
 182   r = q.dequeue();
 183   ASSERT_EQ(100u, r.second.get_map_epoch());
 184
 185   r = q.dequeue();
 186   ASSERT_EQ(104u, r.second.get_map_epoch());
 187 }