source: trunk/server/source4/torture/local/dbspeed.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 7.2 KB
Line 
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.h>
25#include <ldb.h>
26#include <ldb_errors.h>
27#include "ldb_wrap.h"
28#include "lib/util/tdb_wrap.h"
29#include "torture/smbtorture.h"
30#include "param/param.h"
31
32float tdb_speed;
33
34static bool tdb_add_record(struct tdb_wrap *tdbw, const char *fmt1,
35 const char *fmt2, int i)
36{
37 TDB_DATA key, data;
38 int ret;
39
40 key.dptr = (uint8_t *)talloc_asprintf(tdbw, fmt1, i);
41 key.dsize = strlen((char *)key.dptr)+1;
42 data.dptr = (uint8_t *)talloc_asprintf(tdbw, fmt2, i+10000);
43 data.dsize = strlen((char *)data.dptr)+1;
44
45 ret = tdb_store(tdbw->tdb, key, data, TDB_INSERT);
46
47 talloc_free(key.dptr);
48 talloc_free(data.dptr);
49 return ret == 0;
50}
51
52/*
53 test tdb speed
54*/
55static bool test_tdb_speed(struct torture_context *torture, const void *_data)
56{
57 struct timeval tv;
58 struct tdb_wrap *tdbw;
59 int timelimit = torture_setting_int(torture, "timelimit", 10);
60 int i, count;
61 TALLOC_CTX *tmp_ctx = talloc_new(torture);
62
63 unlink("test.tdb");
64
65 torture_comment(torture, "Testing tdb speed for sidmap\n");
66
67 tdbw = tdb_wrap_open(tmp_ctx, "test.tdb",
68 10000, 0, O_RDWR|O_CREAT|O_TRUNC, 0600);
69 if (!tdbw) {
70 torture_result(torture, TORTURE_FAIL, "Failed to open test.tdb");
71 goto failed;
72 }
73
74 torture_comment(torture, "Adding %d SID records\n", torture_entries);
75
76 for (i=0;i<torture_entries;i++) {
77 if (!tdb_add_record(tdbw,
78 "S-1-5-21-53173311-3623041448-2049097239-%u",
79 "UID %u", i)) {
80 torture_result(torture, TORTURE_FAIL, "Failed to add SID %d!", i);
81 goto failed;
82 }
83 if (!tdb_add_record(tdbw,
84 "UID %u",
85 "S-1-5-21-53173311-3623041448-2049097239-%u", i)) {
86 torture_result(torture, TORTURE_FAIL, "Failed to add UID %d!", i);
87 goto failed;
88 }
89 }
90
91 torture_comment(torture, "Testing for %d seconds\n", timelimit);
92
93 tv = timeval_current();
94
95 for (count=0;timeval_elapsed(&tv) < timelimit;count++) {
96 TDB_DATA key, data;
97 i = random() % torture_entries;
98 key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "S-1-5-21-53173311-3623041448-2049097239-%u", i);
99 key.dsize = strlen((char *)key.dptr)+1;
100 data = tdb_fetch(tdbw->tdb, key);
101 talloc_free(key.dptr);
102 if (data.dptr == NULL) {
103 torture_result(torture, TORTURE_FAIL, "Failed to find SID %d!", i);
104 goto failed;
105 }
106 free(data.dptr);
107 key.dptr = (uint8_t *)talloc_asprintf(tmp_ctx, "UID %u", i);
108 key.dsize = strlen((char *)key.dptr)+1;
109 data = tdb_fetch(tdbw->tdb, key);
110 talloc_free(key.dptr);
111 if (data.dptr == NULL) {
112 torture_result(torture, TORTURE_FAIL, "Failed to find UID %d!", i);
113 goto failed;
114 }
115 free(data.dptr);
116 }
117
118 tdb_speed = count/timeval_elapsed(&tv);
119 torture_comment(torture, "tdb speed %.2f ops/sec\n", tdb_speed);
120
121 talloc_free(tmp_ctx);
122 unlink("test.tdb");
123 return true;
124
125failed:
126 talloc_free(tmp_ctx);
127 unlink("test.tdb");
128 return false;
129}
130
131
132static bool ldb_add_record(struct ldb_context *ldb, unsigned rid)
133{
134 struct ldb_message *msg;
135 int ret;
136
137 msg = ldb_msg_new(ldb);
138 if (msg == NULL) {
139 return false;
140 }
141
142 msg->dn = ldb_dn_new_fmt(msg, ldb, "SID=S-1-5-21-53173311-3623041448-2049097239-%u", rid);
143 if (msg->dn == NULL) {
144 talloc_free(msg);
145 return false;
146 }
147
148 ret = ldb_msg_add_fmt(msg, "UID", "%u", rid);
149 if (ret != LDB_SUCCESS) {
150 talloc_free(msg);
151 return false;
152 }
153
154 ret = ldb_add(ldb, msg);
155
156 talloc_free(msg);
157
158 return ret == LDB_SUCCESS;
159}
160
161
162/*
163 test ldb speed
164*/
165static bool test_ldb_speed(struct torture_context *torture, const void *_data)
166{
167 struct timeval tv;
168 struct ldb_context *ldb;
169 int timelimit = torture_setting_int(torture, "timelimit", 10);
170 int i, count;
171 TALLOC_CTX *tmp_ctx = talloc_new(torture);
172 struct ldb_ldif *ldif;
173 const char *init_ldif = "dn: @INDEXLIST\n" \
174 "@IDXATTR: UID\n";
175 float ldb_speed;
176
177 unlink("./test.ldb");
178
179 torture_comment(torture, "Testing ldb speed for sidmap\n");
180
181 ldb = ldb_wrap_connect(tmp_ctx, torture->ev, torture->lp_ctx, "tdb://test.ldb",
182 NULL, NULL, LDB_FLG_NOSYNC);
183 if (!ldb) {
184 torture_result(torture, TORTURE_FAIL, "Failed to open test.ldb");
185 goto failed;
186 }
187
188 /* add an index */
189 ldif = ldb_ldif_read_string(ldb, &init_ldif);
190 if (ldif == NULL) {
191 torture_result(torture, TORTURE_FAIL, "Didn't get LDIF data!");
192 goto failed;
193 }
194 if (ldb_add(ldb, ldif->msg) != LDB_SUCCESS) {
195 torture_result(torture, TORTURE_FAIL, "Couldn't apply LDIF data!");
196 talloc_free(ldif);
197 goto failed;
198 }
199 talloc_free(ldif);
200
201 torture_comment(torture, "Adding %d SID records\n", torture_entries);
202
203 for (i=0;i<torture_entries;i++) {
204 if (!ldb_add_record(ldb, i)) {
205 torture_result(torture, TORTURE_FAIL, "Failed to add SID %d", i);
206 goto failed;
207 }
208 }
209
210 if (talloc_total_blocks(tmp_ctx) > 100) {
211 torture_result(torture, TORTURE_FAIL, "memory leak in ldb add");
212 goto failed;
213 }
214
215 torture_comment(torture, "Testing for %d seconds\n", timelimit);
216
217 tv = timeval_current();
218
219 for (count=0;timeval_elapsed(&tv) < timelimit;count++) {
220 struct ldb_dn *dn;
221 struct ldb_result *res;
222
223 i = random() % torture_entries;
224 dn = ldb_dn_new_fmt(tmp_ctx, ldb, "SID=S-1-5-21-53173311-3623041448-2049097239-%u", i);
225 if (ldb_search(ldb, tmp_ctx, &res, dn, LDB_SCOPE_BASE, NULL, NULL) != LDB_SUCCESS || res->count != 1) {
226 torture_result(torture, TORTURE_FAIL, "Failed to find SID %d!", i);
227 goto failed;
228 }
229 talloc_free(res);
230 talloc_free(dn);
231 if (ldb_search(ldb, tmp_ctx, &res, NULL, LDB_SCOPE_SUBTREE, NULL, "(UID=%u)", i) != LDB_SUCCESS || res->count != 1) {
232 torture_result(torture, TORTURE_FAIL, "Failed to find UID %d!", i);
233 goto failed;
234 }
235 talloc_free(res);
236 }
237
238 if (talloc_total_blocks(tmp_ctx) > 100) {
239 torture_result(torture, TORTURE_FAIL, "memory leak in ldb search");
240 goto failed;
241 }
242
243 ldb_speed = count/timeval_elapsed(&tv);
244 torture_comment(torture, "ldb speed %.2f ops/sec\n", ldb_speed);
245
246 torture_comment(torture, "ldb/tdb speed ratio is %.2f%%\n", (100*ldb_speed/tdb_speed));
247
248 talloc_free(tmp_ctx);
249 unlink("./test.ldb");
250 return true;
251
252failed:
253 talloc_free(tmp_ctx);
254 unlink("./test.ldb");
255 return false;
256}
257
258struct torture_suite *torture_local_dbspeed(TALLOC_CTX *mem_ctx)
259{
260 struct torture_suite *s = torture_suite_create(mem_ctx, "dbspeed");
261 torture_suite_add_simple_tcase_const(s, "tdb_speed", test_tdb_speed,
262 NULL);
263 torture_suite_add_simple_tcase_const(s, "ldb_speed", test_ldb_speed,
264 NULL);
265 return s;
266}
Note: See TracBrowser for help on using the repository browser.