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