src/ceph/src/test/osd/TestMClockOpClassQueue.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
   7 #include "global/global_context.h"
   8 #include "global/global_init.h"
   9 #include "common/common_init.h"
  10
  11 #include "osd/mClockOpClassQueue.h"
  12
  13
  14 int main(int argc, char **argv) {
  15   std::vector<const char*> args(argv, argv+argc);
  16   auto cct = global_init(nullptr, args, CEPH_ENTITY_TYPE_OSD,
  17                          CODE_ENVIRONMENT_UTILITY,
  18                          CINIT_FLAG_NO_DEFAULT_CONFIG_FILE);
  19   common_init_finish(g_ceph_context);
  20
  21   ::testing::InitGoogleTest(&argc, argv);
  22   return RUN_ALL_TESTS();
  23 }
  24
  25
  26 class MClockOpClassQueueTest : public testing::Test {
  27 public:
  28   mClockOpClassQueue q;
  29
  30   entity_inst_t client1;
  31   entity_inst_t client2;
  32   entity_inst_t client3;
  33
  34   MClockOpClassQueueTest() :
  35     q(g_ceph_context),
  36     client1(entity_name_t(CEPH_ENTITY_TYPE_OSD, 1), entity_addr_t()),
  37     client2(entity_name_t(CEPH_ENTITY_TYPE_OSD, 2), entity_addr_t()),
  38     client3(entity_name_t(CEPH_ENTITY_TYPE_CLIENT, 1), entity_addr_t())
  39   {}
  40
  41 #if 0 // more work needed here
  42   Request create_client_op(epoch_t e, const entity_inst_t& owner) {
  43     return Request(spg_t(), PGQueueable(OpRequestRef(), e));
  44   }
  45 #endif
  46
  47   Request create_snaptrim(epoch_t e, const entity_inst_t& owner) {
  48     return Request(spg_t(),
  49                    PGQueueable(PGSnapTrim(e),
  50                                12, 12,
  51                                utime_t(), owner, e));
  52   }
  53
  54   Request create_scrub(epoch_t e, const entity_inst_t& owner) {
  55     return Request(spg_t(),
  56                    PGQueueable(PGScrub(e),
  57                                12, 12,
  58                                utime_t(), owner, e));
  59   }
  60
  61   Request create_recovery(epoch_t e, const entity_inst_t& owner) {
  62     return Request(spg_t(),
  63                    PGQueueable(PGRecovery(e, 64),
  64                                12, 12,
  65                                utime_t(), owner, e));
  66   }
  67 };
  68
  69
  70 TEST_F(MClockOpClassQueueTest, TestSize) {
  71   ASSERT_TRUE(q.empty());
  72   ASSERT_EQ(0u, q.length());
  73
  74   q.enqueue(client1, 12, 0, create_snaptrim(100, client1));
  75   q.enqueue_strict(client2, 12, create_snaptrim(101, client2));
  76   q.enqueue(client2, 12, 0, create_snaptrim(102, client2));
  77   q.enqueue_strict(client3, 12, create_snaptrim(103, client3));
  78   q.enqueue(client1, 12, 0, create_snaptrim(104, client1));
  79
  80   ASSERT_FALSE(q.empty());
  81   ASSERT_EQ(5u, q.length());
  82
  83   std::list<Request> reqs;
  84
  85   reqs.push_back(q.dequeue());
  86   reqs.push_back(q.dequeue());
  87   reqs.push_back(q.dequeue());
  88
  89   ASSERT_FALSE(q.empty());
  90   ASSERT_EQ(2u, q.length());
  91
  92   q.enqueue_front(client2, 12, 0, reqs.back());
  93   reqs.pop_back();
  94
  95   q.enqueue_strict_front(client3, 12, reqs.back());
  96   reqs.pop_back();
  97
  98   q.enqueue_strict_front(client2, 12, reqs.back());
  99   reqs.pop_back();
 100
 101   ASSERT_FALSE(q.empty());
 102   ASSERT_EQ(5u, q.length());
 103
 104   for (int i = 0; i < 5; ++i) {
 105     (void) q.dequeue();
 106   }
 107
 108   ASSERT_TRUE(q.empty());
 109   ASSERT_EQ(0u, q.length());
 110 }
 111
 112
 113 TEST_F(MClockOpClassQueueTest, TestEnqueue) {
 114   q.enqueue(client1, 12, 0, create_snaptrim(100, client1));
 115   q.enqueue(client2, 12, 0, create_snaptrim(101, client2));
 116   q.enqueue(client2, 12, 0, create_snaptrim(102, client2));
 117   q.enqueue(client3, 12, 0, create_snaptrim(103, client3));
 118   q.enqueue(client1, 12, 0, create_snaptrim(104, client1));
 119
 120   Request r = q.dequeue();
 121   ASSERT_EQ(100u, r.second.get_map_epoch());
 122
 123   r = q.dequeue();
 124   ASSERT_EQ(101u, r.second.get_map_epoch());
 125
 126   r = q.dequeue();
 127   ASSERT_EQ(102u, r.second.get_map_epoch());
 128
 129   r = q.dequeue();
 130   ASSERT_EQ(103u, r.second.get_map_epoch());
 131
 132   r = q.dequeue();
 133   ASSERT_EQ(104u, r.second.get_map_epoch());
 134 }
 135
 136
 137 TEST_F(MClockOpClassQueueTest, 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(MClockOpClassQueueTest, 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 }