lib/util: Add back control of mmap and hash size in tdb for top level build
[ira/wip.git] / 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/util/tdb_wrap.h"
29 #include "torture/smbtorture.h"
30 #include "param/param.h"
31
32 float tdb_speed;
33
34 static 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 */
55 static 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, torture->lp_ctx);
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_compat(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_compat(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
125 failed:
126         talloc_free(tmp_ctx);
127         unlink("test.tdb");
128         return false;
129 }
130
131
132 static 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 */
165 static 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
252 failed:
253         talloc_free(tmp_ctx);
254         unlink("./test.ldb");
255         return false;
256 }
257
258 struct 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 }