src/ceph/src/dmclock/test/test_dmclock_client.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Copyright (C) 2016 Red Hat Inc.
   5  */
   6
   7
   8 #include <chrono>
   9 #include <mutex>
  10 #include <functional>
  11 #include <iostream>
  12
  13
  14 #include "dmclock_client.h"
  15 #include "dmclock_util.h"
  16 #include "gtest/gtest.h"
  17
  18
  19 namespace dmc = crimson::dmclock;
  20
  21
  22 namespace crimson {
  23   namespace dmclock {
  24
  25     /*
  26      * Allows us to test the code provided with the mutex provided locked.
  27      */
  28     static void test_locked(std::mutex& mtx, std::function<void()> code) {
  29       std::lock_guard<std::mutex> l(mtx);
  30       code();
  31     }
  32
  33
  34     TEST(dmclock_client, server_erase) {
  35       using ServerId = int;
  36       // using ClientId = int;
  37
  38       ServerId server = 101;
  39       // ClientId client = 3;
  40
  41       // dmc::PhaseType resp_params = dmc::PhaseType::reservation;
  42
  43       dmc::ServiceTracker<ServerId> st(std::chrono::seconds(2),
  44                                        std::chrono::seconds(3));
  45
  46       auto lock_st = [&](std::function<void()> code) {
  47         test_locked(st.data_mtx, code);
  48       };
  49
  50       /* The timeline should be as follows:
  51        *
  52        *     0 seconds : request created
  53        *
  54        *     1 seconds : map is size 1
  55        *
  56        * 2 seconds : clean notes first mark; +2 is base for further calcs
  57        *
  58        * 4 seconds : clean does nothing except makes another mark
  59        *
  60        *   5 seconds : when we're secheduled to erase (+2 + 3)
  61        *
  62        *     5 seconds : since the clean job hasn't run yet, map still size 1
  63        *
  64        * 6 seconds : clean erases server
  65        *
  66        *     7 seconds : verified server is gone (map size 0)
  67        */
  68
  69       lock_st([&] () {
  70           EXPECT_EQ(0u, st.server_map.size()) <<
  71             "server map initially has size 0";
  72         });
  73
  74       std::this_thread::sleep_for(std::chrono::seconds(1));
  75
  76       // call for side effects
  77       (void) st.get_req_params(server);
  78
  79       lock_st([&] () {
  80           EXPECT_EQ(1u, st.server_map.size()) <<
  81             "server map has size 1 after first request";
  82         });
  83
  84       std::this_thread::sleep_for(std::chrono::seconds(4));
  85
  86       lock_st([&] () {
  87           EXPECT_EQ(1u, st.server_map.size()) <<
  88             "server map has size 1 just before erase";
  89         });
  90
  91       std::this_thread::sleep_for(std::chrono::seconds(2));
  92
  93       lock_st([&] () {
  94           EXPECT_EQ(0u, st.server_map.size()) <<
  95             "server map has size 0 just after erase";
  96         });
  97     } // TEST
  98
  99
 100     TEST(dmclock_client, delta_rho_values) {
 101       using ServerId = int;
 102       // using ClientId = int;
 103
 104       ServerId server1 = 101;
 105       ServerId server2 = 7;
 106       // ClientId client = 3;
 107
 108       // RespParams<ServerId> resp_params(server, dmc::PhaseType::reservation);
 109
 110       dmc::ServiceTracker<ServerId> st(std::chrono::seconds(2),
 111                                        std::chrono::seconds(3));
 112
 113       auto rp1 = st.get_req_params(server1);
 114
 115       EXPECT_EQ(1u, rp1.delta) <<
 116         "delta should be 1 with no intervening responses by" <<
 117         "other servers";
 118       EXPECT_EQ(1u, rp1.rho) <<
 119         "rho should be 1 with no intervening reservation responses by" <<
 120         "other servers";
 121
 122       auto rp2 = st.get_req_params(server1);
 123
 124       EXPECT_EQ(1u, rp2.delta) <<
 125         "delta should be 1 with no intervening responses by" <<
 126         "other servers";
 127       EXPECT_EQ(1u, rp2.rho) <<
 128         "rho should be 1 with no intervening reservation responses by" <<
 129         "other servers";
 130
 131       st.track_resp(server1, dmc::PhaseType::priority);
 132
 133       auto rp3 = st.get_req_params(server1);
 134
 135       EXPECT_EQ(1u, rp3.delta) <<
 136         "delta should be 1 with no intervening responses by" <<
 137         "other servers";
 138       EXPECT_EQ(1u, rp3.rho) <<
 139         "rho should be 1 with no intervening reservation responses by" <<
 140         "other servers";
 141
 142       st.track_resp(server2, dmc::PhaseType::priority);
 143
 144       auto rp4 = st.get_req_params(server1);
 145
 146       EXPECT_EQ(2u, rp4.delta) <<
 147         "delta should be 2 with one intervening priority response by " <<
 148         "another server";
 149       EXPECT_EQ(1u, rp4.rho) <<
 150         "rho should be 1 with one intervening priority responses by " <<
 151         "another server";
 152
 153       auto rp5 = st.get_req_params(server1);
 154
 155       EXPECT_EQ(1u, rp5.delta) <<
 156         "delta should be 1 with no intervening responses by" <<
 157         "other servers";
 158       EXPECT_EQ(1u, rp5.rho) <<
 159         "rho should be 1 with no intervening reservation responses by" <<
 160         "other servers";
 161
 162       st.track_resp(server2, dmc::PhaseType::reservation);
 163
 164       auto rp6 = st.get_req_params(server1);
 165
 166       EXPECT_EQ(2u, rp6.delta) <<
 167         "delta should be 2 with one intervening reservation response by " <<
 168         "another server";
 169       EXPECT_EQ(2u, rp6.rho) <<
 170         "rho should be 2 with one intervening reservation responses by " <<
 171         "another server";
 172
 173       // auto rp6_b = st.get_req_params(server2);
 174
 175       st.track_resp(server2, dmc::PhaseType::reservation);
 176       st.track_resp(server1, dmc::PhaseType::priority);
 177       st.track_resp(server2, dmc::PhaseType::priority);
 178       st.track_resp(server2, dmc::PhaseType::reservation);
 179       st.track_resp(server1, dmc::PhaseType::reservation);
 180       st.track_resp(server1, dmc::PhaseType::priority);
 181       st.track_resp(server2, dmc::PhaseType::priority);
 182
 183       auto rp7 = st.get_req_params(server1);
 184
 185       EXPECT_EQ(5u, rp7.delta) <<
 186         "delta should be 5 with fourintervening responses by " <<
 187         "another server";
 188       EXPECT_EQ(3u, rp7.rho) <<
 189         "rho should be 3 with two intervening reservation responses by " <<
 190         "another server";
 191
 192       auto rp7b = st.get_req_params(server2);
 193
 194       EXPECT_EQ(4u, rp7b.delta) <<
 195         "delta should be 4 with three intervening responses by " <<
 196         "another server";
 197       EXPECT_EQ(2u, rp7b.rho) <<
 198         "rho should be 2 with one intervening reservation responses by " <<
 199         "another server";
 200
 201       auto rp8 = st.get_req_params(server1);
 202
 203       EXPECT_EQ(1u, rp8.delta) <<
 204         "delta should be 1 with no intervening responses by " <<
 205         "another server";
 206       EXPECT_EQ(1u, rp8.rho) <<
 207         "rho should be 1 with no intervening reservation responses by " <<
 208         "another server";
 209
 210       auto rp8b = st.get_req_params(server2);
 211       EXPECT_EQ(1u, rp8b.delta) <<
 212         "delta should be 1 with no intervening responses by " <<
 213         "another server";
 214       EXPECT_EQ(1u, rp8b.rho) <<
 215         "rho should be 1 with no intervening reservation responses by " <<
 216         "another server";
 217     } // TEST
 218   } // namespace dmclock
 219 } // namespace crimson