source4/torture/local/dbspeed.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    local test for tdb/ldb speed
   5
   6    Copyright (C) Andrew Tridgell 2004
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "system/filesys.h"
  24 #include "tdb_compat.h"
  25 #include <ldb.h>
  26 #include <ldb_errors.h>
  27 #include "ldb_wrap.h"
  28 #include "lib/tdb_wrap/tdb_wrap.h"
  29 #include "torture/smbtorture.h"
  30 #include "torture/local/proto.h"
  31 #include "param/param.h"
  32
  33 float tdb_speed;
  34
  35 static bool tdb_add_record(struct tdb_wrap *tdbw, const char *p1,
  36                            const char *p2, int i)
  37 {
  38         TDB_DATA key, data;
  39         int ret;
  40
  41         key.dptr = (uint8_t *)talloc_asprintf(tdbw, "%s%u", p1, i);
  42         key.dsize = strlen((char *)key.dptr)+1;
  43         data.dptr = (uint8_t *)talloc_asprintf(tdbw, "%s%u", p2, i+10000);
  44         data.dsize = strlen((char *)data.dptr)+1;
  45
  46         ret = tdb_store(tdbw->tdb, key, data, TDB_INSERT);
  47
  48         talloc_free(key.dptr);
  49         talloc_free(data.dptr);
  50         return ret == 0;
  51 }
  52
  53 /*
  54   test tdb speed
  55 */
  56 static bool test_tdb_speed(struct torture_context *torture, const void *_data)
  57 {
  58         struct timeval tv;
  59         struct tdb_wrap *tdbw;
  60         int timelimit = torture_setting_int(torture, "timelimit", 10);
  61         int i, count;
  62         TALLOC_CTX *tmp_ctx = talloc_new(torture);
  63
  64         unlink("test.tdb");
  65
  66         torture_comment(torture, "Testing tdb speed for sidmap\n");
  67
  68         tdbw = tdb_wrap_open(tmp_ctx, "test.tdb", 10000,
  69                              lpcfg_tdb_flags(torture->lp_ctx, 0),
  70                              O_RDWR|O_CREAT|O_TRUNC, 0600);
  71         if (!tdbw) {
  72                 torture_result(torture, TORTURE_FAIL, "Failed to open test.tdb");
  73                 goto failed;
  74         }
  75
  76         torture_comment(torture, "Adding %d SID records\n", torture_entries);
  77
  78         for (i=0;i<torture_entries;i++) {
  79                 if (!tdb_add_record(tdbw,
  80                                     "S-1-5-21-53173311-3623041448-2049097239-",
  81                                     "UID ", i)) {
  82                         torture_result(torture, TORTURE_FAIL, "Failed to add SID %d!", i);
  83                         goto failed;
  84                 }
  85                 if (!tdb_add_record(tdbw,
  86                                     "UID ",
  87                                     "S-1-5-21-53173311-3623041448-2049097239-", i)) {
  88                         torture_result(torture, TORTURE_FAIL, "Failed to add UID %d!", i);
  89                         goto failed;
  90                 }
  91         }
  92
  93         torture_comment(torture, "Testing for %d seconds\n", timelimit);
  94
  95         tv = timeval_current();
  96
  97         for (count=0;timeval_elapsed(&tv) < timelimit;count++) {
  98                 TDB_DATA key, data;
  99                 i = random() % torture_entries;
 100                 key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "S-1-5-21-53173311-3623041448-2049097239-%u", i);
 101                 key.dsize = strlen((char *)key.dptr)+1;
 102                 data = tdb_fetch_compat(tdbw->tdb, key);
 103                 talloc_free(key.dptr);
 104                 if (data.dptr == NULL) {
 105                         torture_result(torture, TORTURE_FAIL, "Failed to find SID %d!", i);
 106                         goto failed;
 107                 }
 108                 free(data.dptr);
 109                 key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "UID %u", i);
 110                 key.dsize = strlen((char *)key.dptr)+1;
 111                 data = tdb_fetch_compat(tdbw->tdb, key);
 112                 talloc_free(key.dptr);
 113                 if (data.dptr == NULL) {
 114                         torture_result(torture, TORTURE_FAIL, "Failed to find UID %d!", i);
 115                         goto failed;
 116                 }
 117                 free(data.dptr);
 118         }
 119
 120         tdb_speed = count/timeval_elapsed(&tv);
 121         torture_comment(torture, "tdb speed %.2f ops/sec\n", tdb_speed);
 122
 123         talloc_free(tmp_ctx);
 124         unlink("test.tdb");
 125         return true;
 126
 127 failed:
 128         talloc_free(tmp_ctx);
 129         unlink("test.tdb");
 130         return false;
 131 }
 132
 133
 134 static bool ldb_add_record(struct ldb_context *ldb, unsigned rid)
 135 {
 136         struct ldb_message *msg;
 137         int ret;
 138
 139         msg = ldb_msg_new(ldb);
 140         if (msg == NULL) {
 141                 return false;
 142         }
 143
 144         msg->dn = ldb_dn_new_fmt(msg, ldb, "SID=S-1-5-21-53173311-3623041448-2049097239-%u", rid);
 145         if (msg->dn == NULL) {
 146                 talloc_free(msg);
 147                 return false;
 148         }
 149
 150         ret = ldb_msg_add_fmt(msg, "UID", "%u", rid);
 151         if (ret != LDB_SUCCESS) {
 152                 talloc_free(msg);
 153                 return false;
 154         }
 155
 156         ret = ldb_add(ldb, msg);
 157
 158         talloc_free(msg);
 159
 160         return ret == LDB_SUCCESS;
 161 }
 162
 163
 164 /*
 165   test ldb speed
 166 */
 167 static bool test_ldb_speed(struct torture_context *torture, const void *_data)
 168 {
 169         struct timeval tv;
 170         struct ldb_context *ldb;
 171         int timelimit = torture_setting_int(torture, "timelimit", 10);
 172         int i, count;
 173         TALLOC_CTX *tmp_ctx = talloc_new(torture);
 174         struct ldb_ldif *ldif;
 175         const char *init_ldif = "dn: @INDEXLIST\n" \
 176                 "@IDXATTR: UID\n";
 177         float ldb_speed;
 178
 179         unlink("./test.ldb");
 180
 181         torture_comment(torture, "Testing ldb speed for sidmap\n");
 182
 183         ldb = ldb_wrap_connect(tmp_ctx, torture->ev, torture->lp_ctx, "tdb://test.ldb",
 184                                 NULL, NULL, LDB_FLG_NOSYNC);
 185         if (!ldb) {
 186                 torture_result(torture, TORTURE_FAIL, "Failed to open test.ldb");
 187                 goto failed;
 188         }
 189
 190         /* add an index */
 191         ldif = ldb_ldif_read_string(ldb, &init_ldif);
 192         if (ldif == NULL) {
 193                 torture_result(torture, TORTURE_FAIL, "Didn't get LDIF data!");
 194                 goto failed;
 195         }
 196         if (ldb_add(ldb, ldif->msg) != LDB_SUCCESS) {
 197                 torture_result(torture, TORTURE_FAIL, "Couldn't apply LDIF data!");
 198                 talloc_free(ldif);
 199                 goto failed;
 200         }
 201         talloc_free(ldif);
 202
 203         torture_comment(torture, "Adding %d SID records\n", torture_entries);
 204
 205         for (i=0;i<torture_entries;i++) {
 206                 if (!ldb_add_record(ldb, i)) {
 207                         torture_result(torture, TORTURE_FAIL, "Failed to add SID %d", i);
 208                         goto failed;
 209                 }
 210         }
 211
 212         if (talloc_total_blocks(tmp_ctx) > 100) {
 213                 torture_result(torture, TORTURE_FAIL, "memory leak in ldb add");
 214                 goto failed;
 215         }
 216
 217         torture_comment(torture, "Testing for %d seconds\n", timelimit);
 218
 219         tv = timeval_current();
 220
 221         for (count=0;timeval_elapsed(&tv) < timelimit;count++) {
 222                 struct ldb_dn *dn;
 223                 struct ldb_result *res;
 224
 225                 i = random() % torture_entries;
 226                 dn = ldb_dn_new_fmt(tmp_ctx, ldb, "SID=S-1-5-21-53173311-3623041448-2049097239-%u", i);
 227                 if (ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL) != LDB_SUCCESS || res->count != 1) {
 228                         torture_result(torture, TORTURE_FAIL, "Failed to find SID %d!", i);
 229                         goto failed;
 230                 }
 231                 talloc_free(res);
 232                 talloc_free(dn);
 233                 if (ldb_search(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "(UID=%u)", i) != LDB_SUCCESS || res->count != 1) {
 234                         torture_result(torture, TORTURE_FAIL, "Failed to find UID %d!", i);
 235                         goto failed;
 236                 }
 237                 talloc_free(res);
 238         }
 239
 240         if (talloc_total_blocks(tmp_ctx) > 100) {
 241                 torture_result(torture, TORTURE_FAIL, "memory leak in ldb search");
 242                 goto failed;
 243         }
 244
 245         ldb_speed = count/timeval_elapsed(&tv);
 246         torture_comment(torture, "ldb speed %.2f ops/sec\n", ldb_speed);
 247
 248         torture_comment(torture, "ldb/tdb speed ratio is %.2f%%\n", (100*ldb_speed/tdb_speed));
 249
 250         talloc_free(tmp_ctx);
 251         unlink("./test.ldb");
 252         return true;
 253
 254 failed:
 255         talloc_free(tmp_ctx);
 256         unlink("./test.ldb");
 257         return false;
 258 }
 259
 260 struct torture_suite *torture_local_dbspeed(TALLOC_CTX *mem_ctx)
 261 {
 262         struct torture_suite *s = torture_suite_create(mem_ctx, "dbspeed");
 263         torture_suite_add_simple_tcase_const(s, "tdb_speed", test_tdb_speed,
 264                         NULL);
 265         torture_suite_add_simple_tcase_const(s, "ldb_speed", test_ldb_speed,
 266                         NULL);
 267         return s;
 268 }