misc/db_perf/test_db_perf.cpp

   1 /*
   2  *  Copyright (c) 2020 - 2021 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   4  *  Contact: Dongsun Lee <ds73.lee@samsung.com>
   5  *
   6  *  Licensed under the Apache License, Version 2.0 (the "License");
   7  *  you may not use this file except in compliance with the License.
   8  *  You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  *  Unless required by applicable law or agreed to in writing, software
  13  *  distributed under the License is distributed on an "AS IS" BASIS,
  14  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  *  See the License for the specific language governing permissions and
  16  *  limitations under the License
  17  */
  18 #include <chrono>
  19
  20 #define BOOST_TEST_MODULE KEY_MANAGER_DB_PREF
  21 #include <boost/test/results_reporter.hpp>
  22 #include <boost/test/unit_test.hpp>
  23 #include <boost/test/unit_test_log.hpp>
  24
  25 #include <colour_log_formatter.h>
  26 #include <dpl/log/log.h>
  27 #include <log-setup.h>
  28 #include <DBFixture.h>
  29
  30
  31 using namespace CKM;
  32
  33 namespace {
  34 constexpr unsigned OWNERS = 30;
  35 constexpr unsigned NAMES_PER_OWNER = 15;
  36 constexpr unsigned NAMES = OWNERS * NAMES_PER_OWNER;
  37
  38 struct TestConfig {
  39         TestConfig()
  40         {
  41                 boost::unit_test::unit_test_log.set_threshold_level(
  42                         boost::unit_test::log_test_units);
  43                 boost::unit_test::results_reporter::set_level(boost::unit_test::SHORT_REPORT);
  44                 boost::unit_test::unit_test_log.set_formatter(new CKM::colour_log_formatter);
  45         }
  46         ~TestConfig()
  47         {
  48         }
  49 };
  50
  51 struct LogSetup {
  52         LogSetup()
  53         {
  54                 SetupClientLogSystem();
  55                 Singleton<Log::LogSystem>::Instance().SetTag("CKM_DB_PERF_TESTS");
  56         }
  57         ~LogSetup() {}
  58 };
  59
  60 using namespace std::chrono;
  61
  62 class Perf {
  63 public:
  64         Perf(const char *operation_name, long iterations = 0) {
  65                 m_operation = std::string(operation_name ? operation_name : "unknown");
  66                 BOOST_TEST_MESSAGE("\t<performance> running " << m_operation <<
  67                                    " performance test...");
  68                 m_start_time = high_resolution_clock::now();
  69                 m_iterations = iterations;
  70         }
  71
  72         ~Perf() {
  73                 auto end_time = high_resolution_clock::now();
  74                 auto time_elapsed_ms = duration_cast<milliseconds>(end_time - m_start_time).count();
  75                 BOOST_TEST_MESSAGE("\t<performance> time elapsed: " << time_elapsed_ms <<
  76                                    "[ms], number of " << m_operation << ": " << m_iterations);
  77
  78                 if (m_iterations > 0)
  79                         BOOST_TEST_MESSAGE("\t<performance> average time per " << m_operation << ": " <<
  80                                            time_elapsed_ms / m_iterations << "[ms]");
  81         }
  82
  83         void setIterations(long iterations) {
  84                 m_iterations = iterations;
  85         }
  86
  87 private:
  88         std::string m_operation;
  89         std::chrono::high_resolution_clock::time_point m_start_time;
  90         long m_iterations;
  91 };
  92
  93 }
  94
  95 BOOST_GLOBAL_FIXTURE(TestConfig);
  96 BOOST_GLOBAL_FIXTURE(LogSetup);
  97
  98 BOOST_FIXTURE_TEST_SUITE(DBCRYPTO_PERF_TEST, DBFixture)
  99
 100 BOOST_AUTO_TEST_CASE(DBperfAddNames)
 101 {
 102         constexpr unsigned ITERATIONS = 1000;
 103
 104         // actual test
 105         Perf perf("saveRow", ITERATIONS);
 106         {
 107                 generate_db(ITERATIONS, NAMES_PER_OWNER);
 108         }
 109 }
 110
 111 BOOST_AUTO_TEST_CASE(DBperfLookupAliasByOwner)
 112 {
 113         constexpr unsigned ITERATIONS = 1000;
 114
 115         // prepare data
 116         generate_db(NAMES, NAMES_PER_OWNER);
 117
 118         Name name;
 119         ClientId owner;
 120
 121         // actual test - successful lookup
 122         Perf perf("getRow", ITERATIONS * NAMES_PER_OWNER);
 123
 124         unsigned seed = 0;
 125
 126         for (unsigned t = 0; t < ITERATIONS; t++) {
 127                 int owner_num = rand_r(&seed) % OWNERS;
 128                 generate_owner(owner_num, owner);
 129
 130                 unsigned start_name = owner_num * NAMES_PER_OWNER;
 131
 132                 for (unsigned name_num = start_name;
 133                                 name_num < (start_name + NAMES_PER_OWNER); name_num++) {
 134                         generate_name(name_num, name);
 135                         read_row_expect_success(name, owner);
 136
 137                 }
 138         }
 139 }
 140
 141 BOOST_AUTO_TEST_CASE(DBperfLookupAliasRandomOwnership)
 142 {
 143         constexpr unsigned ITERATIONS = 10000;
 144
 145         // prepare data
 146         generate_db(NAMES, NAMES_PER_OWNER);
 147
 148         Name name;
 149         ClientId owner;
 150
 151         // actual test - random lookup
 152         Perf perf("getRow", ITERATIONS);
 153         unsigned seed = 0;
 154
 155         for (unsigned t = 0; t < ITERATIONS; t++) {
 156                 int name_idx = rand_r(&seed) % NAMES;
 157                 generate_name(name_idx, name);
 158                 generate_owner(name_idx / NAMES_PER_OWNER, owner);
 159
 160                 read_row_expect_success(name, owner);
 161         }
 162 }
 163
 164 BOOST_AUTO_TEST_CASE(DBperfAddPermissions)
 165 {
 166         constexpr unsigned ITERATIONS = 200;
 167
 168         // prepare data
 169         generate_db(ITERATIONS, NAMES_PER_OWNER);
 170
 171         // actual test - add access rights
 172         Perf perf("setPermission");
 173         perf.setIterations(add_full_access_rights(ITERATIONS, NAMES_PER_OWNER));
 174 }
 175
 176 BOOST_AUTO_TEST_CASE(DBperfAliasRemovalWithFullPermissions)
 177 {
 178         // prepare data
 179         generate_db(NAMES, NAMES_PER_OWNER);
 180         add_full_access_rights(NAMES, NAMES_PER_OWNER);
 181
 182         // actual test - random lookup
 183         Name name;
 184         ClientId owner;
 185         {
 186                 Perf perf("deleteRow", NAMES);
 187
 188                 for (unsigned t = 0; t < NAMES; t++) {
 189                         generate_name(t, name);
 190                         generate_owner(t / NAMES_PER_OWNER, owner);
 191
 192                         BOOST_REQUIRE_NO_THROW(m_db.deleteRow(name, owner));
 193                 }
 194         }
 195
 196         // verify everything has been removed
 197         for (unsigned l = 0; l < OWNERS; l++) {
 198                 generate_owner(l, owner);
 199                 AliasInfoVector expect_no_data;
 200                 BOOST_REQUIRE_NO_THROW(m_db.listInfos(owner, expect_no_data,
 201                                                                                           DataType::BINARY_DATA));
 202                 BOOST_REQUIRE(0 == expect_no_data.size());
 203         }
 204 }
 205
 206 BOOST_AUTO_TEST_CASE(DBperfGetAliasList)
 207 {
 208         constexpr unsigned ITERATIONS = 1000;
 209
 210         // prepare data
 211         generate_db(NAMES, NAMES_PER_OWNER);
 212         add_full_access_rights(NAMES, NAMES_PER_OWNER);
 213
 214         ClientId owner;
 215         unsigned seed = 0;
 216
 217         // actual test - random lookup
 218         Perf perf("listInfos", ITERATIONS);
 219
 220         for (unsigned t = 0; t < ITERATIONS; t++) {
 221                 AliasInfoVector ret_list;
 222                 generate_owner(rand_r(&seed) % OWNERS, owner);
 223
 224                 BOOST_REQUIRE_NO_THROW(m_db.listInfos(owner, ret_list, DataType::BINARY_DATA));
 225                 BOOST_REQUIRE(NAMES == ret_list.size());
 226                 ret_list.clear();
 227         }
 228 }
 229 BOOST_AUTO_TEST_SUITE_END()