← Back to branch summary

~mysql/mysql-server/mysql-6.0

« back to all changes in this revision

Viewing changes to innobase/fsp/ts/del.c

  • Committer: monty at mysql
  • Date: 2001-02-17 12:19:19 UTC
  • mto: (554.1.1)
  • mto: This revision was merged to the branch mainline in revision 556.
  • Revision ID: sp1r-monty@donna.mysql.com-20010217121919-07904
Added Innobase to source distribution

Show diffs side-by-side

added added

removed removed

Lines of Context:
innobase/fsp/ts/del.c
 
1
/************************************************************************
 
2
The test module for the file system and buffer manager
 
3
 
 
4
(c) 1995 Innobase Oy
 
5
 
 
6
Created 11/16/1995 Heikki Tuuri
 
7
*************************************************************************/
 
8
 
 
9
#include "string.h"
 
10
 
 
11
#include "os0thread.h"
 
12
#include "os0file.h"
 
13
#include "ut0ut.h"
 
14
#include "ut0byte.h"
 
15
#include "sync0sync.h"
 
16
#include "mem0mem.h"
 
17
#include "fil0fil.h"
 
18
#include "..\buf0buf.h"
 
19
#include "..\buf0buf.h1"
 
20
#include "..\buf0buf.h2"
 
21
#include "..\buf0flu.h"
 
22
#include "..\buf0lru.h"
 
23
#include "mtr0buf.h"
 
24
#include "mtr0log.h"
 
25
#include "fsp0fsp.h"
 
26
#include "log0log.h"
 
27
 
 
28
os_file_t       files[1000];
 
29
 
 
30
mutex_t         ios_mutex;
 
31
ulint           ios;
 
32
ulint           n[5];
 
33
 
 
34
 
 
35
/************************************************************************
 
36
Io-handler thread function. */
 
37
 
 
38
ulint
 
39
handler_thread(
 
40
/*===========*/
 
41
        void*   arg)
 
42
{
 
43
        ulint   segment;
 
44
        void*   mess;
 
45
        ulint   i;
 
46
        bool    ret;
 
47
        
 
48
        segment = *((ulint*)arg);
 
49
 
 
50
        printf("Thread %lu starts\n", segment);
 
51
 
 
52
        for (i = 0;; i++) {
 
53
                ret = fil_aio_wait(segment, &mess);
 
54
                ut_a(ret);
 
55
 
 
56
                buf_page_io_complete((buf_block_t*)mess);
 
57
                
 
58
                mutex_enter(&ios_mutex);
 
59
                ios++;
 
60
                mutex_exit(&ios_mutex);
 
61
                
 
62
        }
 
63
 
 
64
        return(0);
 
65
}
 
66
 
 
67
/************************************************************************
 
68
Creates the test database files. */
 
69
 
 
70
void 
 
71
create_db(void)
 
72
/*===========*/
 
73
{
 
74
        ulint                   i;
 
75
        buf_block_t*            block;
 
76
        byte*                   frame;
 
77
        ulint                   j;
 
78
        ulint                   tm, oldtm;
 
79
        mtr_t                   mtr; 
 
80
        
 
81
        oldtm = ut_clock();
 
82
 
 
83
        for (i = 0; i < 1; i++) {
 
84
                for (j = 0; j < 4096; j++) {
 
85
                        mtr_start(&mtr);
 
86
                        if (j == 0) {
 
87
                                fsp_header_init(i, 4096, &mtr);
 
88
 
 
89
                                block = mtr_page_get(i, j, NULL, &mtr);
 
90
                        } else { 
 
91
                                block = mtr_page_create(i, j, &mtr);
 
92
                        }
 
93
 
 
94
                        frame = buf_block_get_frame(block);
 
95
 
 
96
                        mtr_page_x_lock(block, &mtr);
 
97
 
 
98
                        mlog_write_ulint(frame + FIL_PAGE_PREV,
 
99
                                        j - 1, MLOG_4BYTES, &mtr);
 
100
                        
 
101
                        mlog_write_ulint(frame + FIL_PAGE_NEXT,
 
102
                                        j + 1, MLOG_4BYTES, &mtr);
 
103
                        
 
104
                        mlog_write_ulint(frame + FIL_PAGE_OFFSET,
 
105
                                        j, MLOG_4BYTES, &mtr);
 
106
                        
 
107
                        mtr_commit(&mtr);
 
108
                }
 
109
        }
 
110
 
 
111
        tm = ut_clock();
 
112
        printf("Wall clock time for test %lu milliseconds\n", tm - oldtm);
 
113
 
 
114
        /* Flush the pool of dirty pages by reading low-offset pages */
 
115
        for (i = 0; i < 1000; i++) {
 
116
 
 
117
                mtr_start(&mtr);
 
118
                block = mtr_page_get(0, i, NULL, &mtr);
 
119
 
 
120
                frame = buf_block_get_frame(block);
 
121
 
 
122
                mtr_page_s_lock(block, &mtr);
 
123
 
 
124
                ut_a(mtr_read_ulint(frame + FIL_PAGE_OFFSET, MLOG_4BYTES,
 
125
                                   &mtr) == i);
 
126
                        
 
127
                mtr_commit(&mtr);
 
128
        }
 
129
 
 
130
        os_thread_sleep(1000000);
 
131
 
 
132
        ut_a(buf_all_freed());
 
133
}
 
134
        
 
135
/*************************************************************************
 
136
Creates the files for the file system test and inserts them to
 
137
the file system. */
 
138
 
 
139
void
 
140
create_files(void)
 
141
/*==============*/
 
142
{
 
143
        bool            ret;
 
144
        ulint           i, k;
 
145
        char            name[20];
 
146
        os_thread_t     thr[5];
 
147
        os_thread_id_t  id[5];
 
148
 
 
149
        strcpy(name, "j:\\tsfile1");
 
150
 
 
151
        for (k = 0; k < 1; k++) {
 
152
        for (i = 0; i < 4; i++) {
 
153
 
 
154
                name[9] = (char)((ulint)'0' + i);
 
155
        
 
156
                files[i] = os_file_create(name, OS_FILE_CREATE,
 
157
                                        OS_FILE_TABLESPACE, &ret);
 
158
 
 
159
                if (ret == FALSE) {
 
160
                        ut_a(os_file_get_last_error() ==
 
161
                                                OS_FILE_ALREADY_EXISTS);
 
162
        
 
163
                        files[i] = os_file_create(
 
164
                                name, OS_FILE_OPEN,
 
165
                                                OS_FILE_TABLESPACE, &ret);
 
166
 
 
167
                        ut_a(ret);
 
168
                }
 
169
 
 
170
                ret = os_file_set_size(files[i], 4096 * 8192, 0);
 
171
                ut_a(ret);              
 
172
                
 
173
                ret = os_file_close(files[i]);
 
174
                ut_a(ret);
 
175
 
 
176
                if (i == 0) {
 
177
                        fil_space_create("noname", k, OS_FILE_TABLESPACE);
 
178
                }
 
179
 
 
180
                ut_a(fil_validate());
 
181
 
 
182
                fil_node_create(name, 4096, k);
 
183
        }
 
184
        }
 
185
 
 
186
        ios = 0;
 
187
 
 
188
        mutex_create(&ios_mutex);
 
189
        
 
190
        for (i = 0; i < 5; i++) {
 
191
                n[i] = i;
 
192
 
 
193
                thr[i] = os_thread_create(handler_thread, n + i, id + i);
 
194
        }
 
195
}
 
196
 
 
197
/************************************************************************
 
198
Reads the test database files. */
 
199
 
 
200
void 
 
201
test1(void)
 
202
/*=======*/
 
203
{
 
204
        ulint                   i, j, k;
 
205
        buf_block_t*            block;
 
206
        byte*                   frame;
 
207
        ulint                   tm, oldtm;
 
208
 
 
209
        buf_flush_batch(BUF_FLUSH_LIST, 1000);
 
210
 
 
211
        os_thread_sleep(1000000);
 
212
 
 
213
        buf_all_freed();
 
214
        
 
215
        oldtm = ut_clock();
 
216
        
 
217
        for (k = 0; k < 1; k++) {
 
218
        for (i = 0; i < 1; i++) {
 
219
                for (j = 0; j < 409; j++) {
 
220
                        block = buf_page_get(i, j, NULL);
 
221
 
 
222
                        frame = buf_block_get_frame(block);
 
223
 
 
224
                        buf_page_s_lock(block);
 
225
 
 
226
                        ut_a(*((ulint*)(frame + 16)) == j);
 
227
                        
 
228
                        buf_page_s_unlock(block);
 
229
 
 
230
                        buf_page_release(block);
 
231
                }
 
232
        }
 
233
        }
 
234
 
 
235
        tm = ut_clock();
 
236
        printf("Wall clock time for test %lu milliseconds\n", tm - oldtm);
 
237
 
 
238
}
 
239
 
 
240
/************************************************************************
 
241
Reads the test database files. */
 
242
 
 
243
void 
 
244
test2(void)
 
245
/*=======*/
 
246
{
 
247
        ulint                   i, j, k, rnd;
 
248
        buf_block_t*            block;
 
249
        byte*                   frame;
 
250
        ulint                   tm, oldtm;
 
251
 
 
252
        oldtm = ut_clock();
 
253
 
 
254
        rnd = 123;
 
255
 
 
256
        for (k = 0; k < 100; k++) {
 
257
                rnd += 23651;
 
258
                rnd = rnd % 4096;
 
259
        
 
260
                i = rnd / 4096; 
 
261
                j = rnd % 2048;
 
262
                
 
263
                block = buf_page_get(i, j, NULL);
 
264
 
 
265
                frame = buf_block_get_frame(block);
 
266
 
 
267
                buf_page_s_lock(block);
 
268
 
 
269
                ut_a(*((ulint*)(frame + 16)) == j);
 
270
                        
 
271
                buf_page_s_unlock(block);
 
272
 
 
273
                buf_page_release(block);
 
274
        }
 
275
 
 
276
        tm = ut_clock();
 
277
        printf("Wall clock time for random read %lu milliseconds\n",
 
278
                tm - oldtm);
 
279
}
 
280
 
 
281
/************************************************************************
 
282
Reads the test database files. */
 
283
 
 
284
void 
 
285
test4(void)
 
286
/*=======*/
 
287
{
 
288
        ulint                   i, j, k, rnd;
 
289
        buf_block_t*            block;
 
290
        byte*                   frame;
 
291
        ulint                   tm, oldtm;
 
292
 
 
293
        /* Flush the pool of high-offset pages */
 
294
        for (i = 0; i < 1000; i++) {
 
295
                
 
296
                block = buf_page_get(0, i, NULL);
 
297
 
 
298
                frame = buf_block_get_frame(block);
 
299
 
 
300
                buf_page_s_lock(block);
 
301
 
 
302
                ut_a(*((ulint*)(frame + 16)) == i);
 
303
                        
 
304
                buf_page_s_unlock(block);
 
305
 
 
306
                buf_page_release(block);
 
307
        }
 
308
 
 
309
        printf("Test starts\n");
 
310
        
 
311
        oldtm = ut_clock();
 
312
 
 
313
        rnd = 123;
 
314
 
 
315
        for (k = 0; k < 400; k++) {
 
316
 
 
317
                rnd += 4357;
 
318
        
 
319
                i = 0;
 
320
                j = 1001 + rnd % 3000;
 
321
                
 
322
                block = buf_page_get(i, j, NULL);
 
323
 
 
324
                frame = buf_block_get_frame(block);
 
325
 
 
326
                buf_page_s_lock(block);
 
327
 
 
328
                ut_a(*((ulint*)(frame + 16)) == j);
 
329
                        
 
330
                buf_page_s_unlock(block);
 
331
 
 
332
                buf_page_release(block);
 
333
        }
 
334
 
 
335
        tm = ut_clock();
 
336
        printf(
 
337
           "Wall clock time for %lu random no read-ahead %lu milliseconds\n",
 
338
                k, tm - oldtm);
 
339
 
 
340
        /* Flush the pool of high-offset pages */
 
341
        for (i = 0; i < 1000; i++) {
 
342
                
 
343
                block = buf_page_get(0, i, NULL);
 
344
 
 
345
                frame = buf_block_get_frame(block);
 
346
 
 
347
                buf_page_s_lock(block);
 
348
 
 
349
                ut_a(*((ulint*)(frame + 16)) == i);
 
350
                        
 
351
                buf_page_s_unlock(block);
 
352
 
 
353
                buf_page_release(block);
 
354
        }
 
355
 
 
356
        printf("Test starts\n");
 
357
 
 
358
        oldtm = ut_clock();
 
359
 
 
360
        rnd = 123;
 
361
 
 
362
        for (k = 0; k < 400; k++) {
 
363
 
 
364
                rnd += 4357;
 
365
        
 
366
                i = 0;
 
367
                j = 1001 + rnd % 400;
 
368
                
 
369
                block = buf_page_get(i, j, NULL);
 
370
 
 
371
                frame = buf_block_get_frame(block);
 
372
 
 
373
                buf_page_s_lock(block);
 
374
 
 
375
                ut_a(*((ulint*)(frame + 16)) == j);
 
376
                        
 
377
                buf_page_s_unlock(block);
 
378
 
 
379
                buf_page_release(block);
 
380
        }
 
381
 
 
382
        tm = ut_clock();
 
383
        printf(
 
384
           "Wall clock time for %lu random read-ahead %lu milliseconds\n",
 
385
                k, tm - oldtm);
 
386
 
 
387
}
 
388
 
 
389
/************************************************************************
 
390
Tests speed of CPU algorithms. */
 
391
 
 
392
void 
 
393
test3(void)
 
394
/*=======*/
 
395
{
 
396
        ulint                   i, j;
 
397
        buf_block_t*            block;
 
398
        ulint                   tm, oldtm;
 
399
 
 
400
        for (i = 0; i < 400; i++) {
 
401
                
 
402
                block = buf_page_get(0, i, NULL);
 
403
 
 
404
                buf_page_release(block);
 
405
        }
 
406
 
 
407
        os_thread_sleep(2000000);
 
408
 
 
409
        oldtm = ut_clock();
 
410
 
 
411
        for (j = 0; j < 500; j++) {
 
412
        for (i = 0; i < 200; i++) {
 
413
                
 
414
                block = buf_page_get(0, i, NULL);
 
415
 
 
416
/*
 
417
                buf_page_s_lock(block);
 
418
 
 
419
                buf_page_s_unlock(block);
 
420
*/
 
421
 
 
422
                buf_page_release(block);
 
423
 
 
424
        }
 
425
        }
 
426
 
 
427
        tm = ut_clock();
 
428
        printf("Wall clock time for %lu page get-release %lu milliseconds\n",
 
429
                        i * j, tm - oldtm);
 
430
 
 
431
        oldtm = ut_clock();
 
432
 
 
433
        for (j = 0; j < 500; j++) {
 
434
        for (i = 0; i < 200; i++) {
 
435
                
 
436
                buf_page_get(0, i, NULL);
 
437
/*
 
438
                buf_page_s_lock(block);
 
439
 
 
440
                buf_page_s_unlock(block);
 
441
*/
 
442
                buf_page_release(block);
 
443
        }
 
444
        }
 
445
 
 
446
        tm = ut_clock();
 
447
        printf("Wall clock time for %lu block get-release %lu milliseconds\n",
 
448
                        i * j, tm - oldtm);
 
449
 
 
450
 
 
451
        oldtm = ut_clock();
 
452
 
 
453
        for (i = 0; i < 100000; i++) {
 
454
                block = buf_block_alloc();
 
455
                buf_block_free(block);
 
456
        }
 
457
 
 
458
        tm = ut_clock();
 
459
        printf("Wall clock time for %lu block alloc-free %lu milliseconds\n",
 
460
                        i, tm - oldtm);
 
461
 
 
462
        ha_print_info(buf_pool->page_hash);
 
463
}
 
464
 
 
465
/************************************************************************
 
466
Frees the spaces in the file system. */
 
467
 
 
468
void
 
469
free_system(void)
 
470
/*=============*/
 
471
{
 
472
        ulint   i;
 
473
 
 
474
        for (i = 0; i < 1; i++) {
 
475
                fil_space_free(i);
 
476
        }
 
477
}
 
478
 
 
479
/************************************************************************
 
480
Test for file space management. */
 
481
 
 
482
void
 
483
test5(void)
 
484
/*=======*/
 
485
{
 
486
        mtr_t           mtr;
 
487
        ulint           seg_page;
 
488
        ulint           new_page;
 
489
        ulint           seg_page2;
 
490
        ulint           new_page2;
 
491
        buf_block_t*    block;
 
492
        bool            finished;
 
493
        ulint           i;
 
494
        ulint           reserved;
 
495
        ulint           used;
 
496
        ulint           tm, oldtm;
 
497
 
 
498
        os_thread_sleep(1000000);
 
499
 
 
500
        buf_validate();
 
501
 
 
502
        buf_print();
 
503
        
 
504
        mtr_start(&mtr);
 
505
 
 
506
        seg_page = fseg_create(0, 0, 1000, 555, &mtr);
 
507
 
 
508
        mtr_commit(&mtr);
 
509
 
 
510
        os_thread_sleep(1000000);
 
511
        buf_validate();
 
512
        printf("Segment created: header page %lu\n", seg_page);
 
513
 
 
514
        mtr_start(&mtr);
 
515
 
 
516
        block = mtr_page_get(0, seg_page, NULL, &mtr);
 
517
        
 
518
        new_page = fseg_alloc_free_page(buf_block_get_frame(block) + 1000,
 
519
                                        2, FSP_UP, &mtr);       
 
520
        
 
521
        mtr_commit(&mtr);
 
522
 
 
523
        buf_validate();
 
524
        buf_print();
 
525
        printf("Segment page allocated %lu\n", new_page);
 
526
 
 
527
        finished = FALSE;
 
528
 
 
529
        while (!finished) {
 
530
        
 
531
                mtr_start(&mtr);
 
532
 
 
533
                block = mtr_page_get(0, seg_page, NULL, &mtr);
 
534
        
 
535
                finished = fseg_free_step(
 
536
                        buf_block_get_frame(block) + 1000, &mtr);       
 
537
        
 
538
                mtr_commit(&mtr);
 
539
        }
 
540
 
 
541
        /***********************************************/
 
542
        os_thread_sleep(1000000);
 
543
        buf_validate();
 
544
        buf_print();
 
545
        mtr_start(&mtr);
 
546
 
 
547
        seg_page = fseg_create(0, 0, 1000, 557, &mtr);
 
548
 
 
549
        mtr_commit(&mtr);
 
550
 
 
551
        ut_a(seg_page == 1);
 
552
        
 
553
        printf("Segment created: header page %lu\n", seg_page);
 
554
 
 
555
        new_page = seg_page;
 
556
        for (i = 0; i < 1023; i++) {
 
557
 
 
558
                mtr_start(&mtr);
 
559
 
 
560
                block = mtr_page_get(0, seg_page, NULL, &mtr);
 
561
        
 
562
                new_page = fseg_alloc_free_page(
 
563
                                        buf_block_get_frame(block) + 1000,
 
564
                                        new_page + 1, FSP_UP, &mtr);
 
565
                if (i < FSP_EXTENT_SIZE - 1) {
 
566
                        ut_a(new_page == 2 + i);
 
567
                } else {
 
568
                        ut_a(new_page == i + FSP_EXTENT_SIZE + 1);
 
569
                }       
 
570
 
 
571
                printf("%lu %lu; ", i, new_page);
 
572
                if (i % 10 == 0) {
 
573
                        printf("\n");
 
574
                }
 
575
        
 
576
                mtr_commit(&mtr);
 
577
        }
 
578
 
 
579
        buf_print();
 
580
        buf_validate();
 
581
 
 
582
        mtr_start(&mtr);
 
583
 
 
584
        block = mtr_page_get(0, seg_page, NULL, &mtr);
 
585
 
 
586
        mtr_page_s_lock(block, &mtr);
 
587
        
 
588
        reserved = fseg_n_reserved_pages(buf_block_get_frame(block) + 1000,
 
589
                                        &used, &mtr);
 
590
 
 
591
        ut_a(used == 1024);     
 
592
        ut_a(reserved >= 1024); 
 
593
 
 
594
        printf("Pages used in segment %lu reserved by segment %lu \n",
 
595
                used, reserved);
 
596
        
 
597
        mtr_commit(&mtr);
 
598
 
 
599
        finished = FALSE;
 
600
 
 
601
        while (!finished) {
 
602
 
 
603
                mtr_start(&mtr);
 
604
 
 
605
                block = mtr_page_get(0, seg_page, NULL, &mtr);
 
606
        
 
607
                finished = fseg_free_step(
 
608
                        buf_block_get_frame(block) + 1000, &mtr);       
 
609
        
 
610
                mtr_commit(&mtr);
 
611
        }
 
612
 
 
613
        buf_print();
 
614
        buf_validate();
 
615
 
 
616
        /***********************************************/
 
617
 
 
618
        mtr_start(&mtr);
 
619
 
 
620
        seg_page = fseg_create(0, 0, 1000, 557, &mtr);
 
621
 
 
622
        mtr_commit(&mtr);
 
623
 
 
624
        ut_a(seg_page == 1);
 
625
 
 
626
        mtr_start(&mtr);
 
627
 
 
628
        seg_page2 = fseg_create(0, 0, 1000, 558, &mtr);
 
629
 
 
630
        mtr_commit(&mtr);
 
631
 
 
632
        ut_a(seg_page2 == 2);
 
633
        
 
634
        new_page = seg_page;
 
635
        new_page2 = seg_page2;
 
636
 
 
637
        for (;;) {
 
638
 
 
639
                mtr_start(&mtr);
 
640
 
 
641
                block = mtr_page_get(0, seg_page, NULL, &mtr);
 
642
        
 
643
                new_page = fseg_alloc_free_page(
 
644
                                        buf_block_get_frame(block) + 1000,
 
645
                                        new_page + 1, FSP_UP, &mtr);
 
646
 
 
647
                printf("1:%lu %lu; ", i, new_page);
 
648
                if (i % 10 == 0) {
 
649
                        printf("\n");
 
650
                }
 
651
        
 
652
                new_page = fseg_alloc_free_page(
 
653
                                        buf_block_get_frame(block) + 1000,
 
654
                                        new_page + 1, FSP_UP, &mtr);
 
655
 
 
656
                printf("1:%lu %lu; ", i, new_page);
 
657
                if (i % 10 == 0) {
 
658
                        printf("\n");
 
659
                }
 
660
 
 
661
                mtr_commit(&mtr);
 
662
 
 
663
                mtr_start(&mtr);
 
664
 
 
665
                block = mtr_page_get(0, seg_page2, NULL, &mtr);
 
666
        
 
667
                new_page2 = fseg_alloc_free_page(
 
668
                                        buf_block_get_frame(block) + 1000,
 
669
                                        new_page2 + 1, FSP_UP, &mtr);
 
670
 
 
671
                printf("2:%lu %lu; ", i, new_page2);
 
672
                if (i % 10 == 0) {
 
673
                        printf("\n");
 
674
                }
 
675
        
 
676
                mtr_commit(&mtr);
 
677
 
 
678
                if (new_page2 == FIL_NULL) {
 
679
                        break;
 
680
                }
 
681
        }
 
682
 
 
683
        mtr_start(&mtr);
 
684
 
 
685
        block = mtr_page_get(0, seg_page, NULL, &mtr);
 
686
 
 
687
        mtr_page_s_lock(block, &mtr);
 
688
        
 
689
        reserved = fseg_n_reserved_pages(buf_block_get_frame(block) + 1000,
 
690
                                        &used, &mtr);
 
691
 
 
692
        printf("Pages used in segment 1 %lu, reserved by segment %lu \n",
 
693
                used, reserved);
 
694
        
 
695
        mtr_commit(&mtr);
 
696
 
 
697
        mtr_start(&mtr);
 
698
 
 
699
        block = mtr_page_get(0, seg_page2, NULL, &mtr);
 
700
 
 
701
        mtr_page_s_lock(block, &mtr);
 
702
        
 
703
        reserved = fseg_n_reserved_pages(buf_block_get_frame(block) + 1000,
 
704
                                        &used, &mtr);
 
705
 
 
706
        printf("Pages used in segment 2 %lu, reserved by segment %lu \n",
 
707
                used, reserved);
 
708
        
 
709
        mtr_commit(&mtr);
 
710
        
 
711
        for (;;) {
 
712
 
 
713
                mtr_start(&mtr);
 
714
 
 
715
                block = mtr_page_get(0, seg_page, NULL, &mtr);
 
716
        
 
717
                fseg_free_step(
 
718
                              buf_block_get_frame(block) + 1000, &mtr);
 
719
        
 
720
                block = mtr_page_get(0, seg_page2, NULL, &mtr);
 
721
        
 
722
                finished = fseg_free_step(
 
723
                              buf_block_get_frame(block) + 1000, &mtr);
 
724
 
 
725
                mtr_commit(&mtr);
 
726
 
 
727
                if (finished) {
 
728
                        break;
 
729
                }
 
730
        }
 
731
 
 
732
        mtr_start(&mtr);
 
733
 
 
734
        seg_page2 = fseg_create(0, 0, 1000, 558, &mtr);
 
735
 
 
736
        mtr_commit(&mtr);
 
737
 
 
738
        i = 0;
 
739
        for (;;) {
 
740
                mtr_start(&mtr);
 
741
 
 
742
                block = mtr_page_get(0, seg_page2, NULL, &mtr);
 
743
        
 
744
                new_page2 = fseg_alloc_free_page(
 
745
                                        buf_block_get_frame(block) + 1000,
 
746
                                        557, FSP_DOWN, &mtr);
 
747
 
 
748
                printf("%lu %lu; ", i, new_page2);
 
749
                mtr_commit(&mtr);
 
750
 
 
751
                if (new_page2 == FIL_NULL) {
 
752
                        break;
 
753
                }
 
754
                i++;
 
755
        }
 
756
 
 
757
        for (;;) {
 
758
 
 
759
                mtr_start(&mtr);
 
760
 
 
761
                block = mtr_page_get(0, seg_page, NULL, &mtr);
 
762
        
 
763
                finished = fseg_free_step(
 
764
                              buf_block_get_frame(block) + 1000, &mtr);
 
765
        
 
766
                mtr_commit(&mtr);
 
767
 
 
768
                if (finished) {
 
769
                        break;
 
770
                }
 
771
        }
 
772
 
 
773
        for (;;) {
 
774
 
 
775
                mtr_start(&mtr);
 
776
 
 
777
                block = mtr_page_get(0, seg_page2, NULL, &mtr);
 
778
        
 
779
                finished = fseg_free_step(
 
780
                              buf_block_get_frame(block) + 1000, &mtr);
 
781
        
 
782
                mtr_commit(&mtr);
 
783
 
 
784
                if (finished) {
 
785
                        break;
 
786
                }
 
787
        }
 
788
 
 
789
        
 
790
        /***************************************/
 
791
        
 
792
        oldtm = ut_clock();
 
793
 
 
794
    for (i = 0; i < 1000; i++) {        
 
795
        mtr_start(&mtr);
 
796
 
 
797
        seg_page = fseg_create(0, 0, 1000, 555, &mtr);
 
798
 
 
799
        mtr_commit(&mtr);
 
800
 
 
801
        mtr_start(&mtr);
 
802
 
 
803
        block = mtr_page_get(0, seg_page, NULL, &mtr);
 
804
        
 
805
        new_page = fseg_alloc_free_page(buf_block_get_frame(block) + 1000,
 
806
                                        2, FSP_UP, &mtr);       
 
807
        
 
808
        mtr_commit(&mtr);
 
809
 
 
810
        finished = FALSE;
 
811
 
 
812
        while (!finished) {
 
813
        
 
814
                mtr_start(&mtr);
 
815
 
 
816
                block = mtr_page_get(0, seg_page, NULL, &mtr);
 
817
        
 
818
                finished = fseg_free_step(
 
819
                        buf_block_get_frame(block) + 1000, &mtr);       
 
820
        
 
821
                mtr_commit(&mtr);
 
822
        }
 
823
    }
 
824
 
 
825
        tm = ut_clock();
 
826
        printf("Wall clock time for %lu seg crea+free %lu millisecs\n",
 
827
                        i, tm - oldtm);
 
828
 
 
829
        buf_validate();
 
830
 
 
831
        buf_flush_batch(BUF_FLUSH_LIST, 500);
 
832
 
 
833
        os_thread_sleep(1000000);
 
834
        
 
835
        buf_all_freed();
 
836
}       
 
837
 
 
838
 
 
839
/************************************************************************
 
840
Main test function. */
 
841
 
 
842
void 
 
843
main(void) 
 
844
/*======*/
 
845
{
 
846
        ulint   tm, oldtm;
 
847
        ulint   n;
 
848
 
 
849
        oldtm = ut_clock();
 
850
        
 
851
        os_aio_init(160, 5);
 
852
        sync_init();
 
853
        mem_init();
 
854
        fil_init(26);   /* Allow 25 open files at a time */
 
855
        buf_pool_init(1000, 1000);
 
856
        log_init();
 
857
        
 
858
        buf_validate();
 
859
 
 
860
        ut_a(fil_validate());
 
861
        
 
862
        create_files();
 
863
 
 
864
        create_db();
 
865
 
 
866
        buf_validate();
 
867
 
 
868
        test5();
 
869
/*
 
870
        test1();
 
871
 
 
872
        test3();
 
873
 
 
874
        test4();
 
875
 
 
876
        test2();
 
877
*/
 
878
        buf_validate();
 
879
 
 
880
        n = buf_flush_batch(BUF_FLUSH_LIST, 500);
 
881
 
 
882
        os_thread_sleep(1000000);
 
883
        
 
884
        buf_all_freed();
 
885
        
 
886
        free_system();  
 
887
        
 
888
        tm = ut_clock();
 
889
        printf("Wall clock time for test %lu milliseconds\n", tm - oldtm);
 
890
        printf("TESTS COMPLETED SUCCESSFULLY!\n");
 
891
}