← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/innobase/trx/trx0purge.c

  • Committer: Brian Aker
  • Date: 2008-11-04 15:39:09 UTC
  • mfrom: (575.1.2 devel)
  • Revision ID: brian@tangent.org-20081104153909-c72hn65udxs1ccal
Merge of Monty's work

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innobase/trx/trx0purge.c
27
27
#include "os0thread.h"
28
28
 
29
29
/* The global data structure coordinating a purge */
30
 
trx_purge_t*    purge_sys = NULL;
 
30
UNIV_INTERN trx_purge_t*        purge_sys = NULL;
31
31
 
32
32
/* A dummy undo record used as a return value when we have a whole undo log
33
33
which needs no purge */
34
 
trx_undo_rec_t  trx_purge_dummy_rec;
 
34
UNIV_INTERN trx_undo_rec_t      trx_purge_dummy_rec;
35
35
 
36
36
/*********************************************************************
37
37
Checks if trx_id is >= purge_view: then it is guaranteed that its update
38
38
undo log still exists in the system. */
39
 
 
 
39
UNIV_INTERN
40
40
ibool
41
41
trx_purge_update_undo_must_exist(
42
42
/*=============================*/
192
192
/************************************************************************
193
193
Creates the global purge system control structure and inits the history
194
194
mutex. */
195
 
 
 
195
UNIV_INTERN
196
196
void
197
197
trx_purge_sys_create(void)
198
198
/*======================*/
236
236
/************************************************************************
237
237
Adds the update undo log as the first log in the history list. Removes the
238
238
update undo log segment from the rseg slot if it is too big for reuse. */
239
 
 
 
239
UNIV_INTERN
240
240
void
241
241
trx_purge_add_update_undo_to_history(
242
242
/*=================================*/
261
261
 
262
262
        ut_ad(mutex_own(&(rseg->mutex)));
263
263
 
264
 
        rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr);
 
264
        rseg_header = trx_rsegf_get(rseg->space, rseg->zip_size,
 
265
                                    rseg->page_no, mtr);
265
266
 
266
267
        undo_header = undo_page + undo->hdr_offset;
267
268
        seg_header  = undo_page + TRX_UNDO_SEG_HDR;
343
344
        mtr_start(&mtr);
344
345
        mutex_enter(&(rseg->mutex));
345
346
 
346
 
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
 
347
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->zip_size,
 
348
                                 rseg->page_no, &mtr);
347
349
 
348
 
        undo_page = trx_undo_page_get(rseg->space, hdr_addr.page, &mtr);
 
350
        undo_page = trx_undo_page_get(rseg->space, rseg->zip_size,
 
351
                                      hdr_addr.page, &mtr);
349
352
        seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
350
353
        log_hdr = undo_page + hdr_addr.boffset;
351
354
 
445
448
        mtr_start(&mtr);
446
449
        mutex_enter(&(rseg->mutex));
447
450
 
448
 
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
 
451
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->zip_size,
 
452
                                 rseg->page_no, &mtr);
449
453
 
450
454
        hdr_addr = trx_purge_get_log_from_hist(
451
455
                flst_get_last(rseg_hdr + TRX_RSEG_HISTORY, &mtr));
459
463
                return;
460
464
        }
461
465
 
462
 
        undo_page = trx_undo_page_get(rseg->space, hdr_addr.page, &mtr);
 
466
        undo_page = trx_undo_page_get(rseg->space, rseg->zip_size,
 
467
                                      hdr_addr.page, &mtr);
463
468
 
464
469
        log_hdr = undo_page + hdr_addr.boffset;
465
470
 
511
516
        mtr_start(&mtr);
512
517
        mutex_enter(&(rseg->mutex));
513
518
 
514
 
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->page_no, &mtr);
 
519
        rseg_hdr = trx_rsegf_get(rseg->space, rseg->zip_size,
 
520
                                 rseg->page_no, &mtr);
515
521
 
516
522
        hdr_addr = prev_hdr_addr;
517
523
 
535
541
        trx_purge_arr_get_biggest(purge_sys->arr, &limit_trx_no,
536
542
                                  &limit_undo_no);
537
543
 
538
 
        if (ut_dulint_cmp(limit_trx_no, ut_dulint_zero) == 0) {
 
544
        if (ut_dulint_is_zero(limit_trx_no)) {
539
545
 
540
546
                limit_trx_no = purge_sys->purge_trx_no;
541
547
                limit_undo_no = purge_sys->purge_undo_no;
611
617
 
612
618
        mtr_start(&mtr);
613
619
 
614
 
        undo_page = trx_undo_page_get_s_latched(rseg->space,
 
620
        undo_page = trx_undo_page_get_s_latched(rseg->space, rseg->zip_size,
615
621
                                                rseg->last_page_no, &mtr);
616
622
        log_hdr = undo_page + rseg->last_offset;
617
623
        seg_hdr = undo_page + TRX_UNDO_SEG_HDR;
663
669
        /* Read the trx number and del marks from the previous log header */
664
670
        mtr_start(&mtr);
665
671
 
666
 
        log_hdr = trx_undo_page_get_s_latched(rseg->space,
 
672
        log_hdr = trx_undo_page_get_s_latched(rseg->space, rseg->zip_size,
667
673
                                              prev_log_addr.page, &mtr)
668
674
                + prev_log_addr.boffset;
669
675
 
698
704
        trx_rseg_t*     min_rseg;
699
705
        dulint          min_trx_no;
700
706
        ulint           space = 0;   /* remove warning (??? bug ???) */
 
707
        ulint           zip_size = 0;
701
708
        ulint           page_no = 0; /* remove warning (??? bug ???) */
702
709
        ulint           offset = 0;  /* remove warning (??? bug ???) */
703
710
        mtr_t           mtr;
723
730
                                min_rseg = rseg;
724
731
                                min_trx_no = rseg->last_trx_no;
725
732
                                space = rseg->space;
 
733
                                zip_size = rseg->zip_size;
726
734
                                ut_a(space == 0); /* We assume in purge of
727
735
                                                  externally stored fields
728
736
                                                  that space id == 0 */
748
756
 
749
757
                rec = &trx_purge_dummy_rec;
750
758
        } else {
751
 
                rec = trx_undo_get_first_rec(space, page_no, offset,
 
759
                rec = trx_undo_get_first_rec(space, zip_size, page_no, offset,
752
760
                                             RW_S_LATCH, &mtr);
753
761
                if (rec == NULL) {
754
762
                        /* Undo log empty */
773
781
        } else {
774
782
                purge_sys->purge_undo_no = trx_undo_rec_get_undo_no(rec);
775
783
 
776
 
                purge_sys->page_no = buf_frame_get_page_no(rec);
777
 
                purge_sys->offset = rec - buf_frame_align(rec);
 
784
                purge_sys->page_no = page_get_page_no(page_align(rec));
 
785
                purge_sys->offset = page_offset(rec);
778
786
        }
779
787
 
780
788
        mtr_commit(&mtr);
799
807
        ulint           offset;
800
808
        ulint           page_no;
801
809
        ulint           space;
 
810
        ulint           zip_size;
802
811
        ulint           type;
803
812
        ulint           cmpl_info;
804
813
        mtr_t           mtr;
807
816
        ut_ad(purge_sys->next_stored);
808
817
 
809
818
        space = purge_sys->rseg->space;
 
819
        zip_size = purge_sys->rseg->zip_size;
810
820
        page_no = purge_sys->page_no;
811
821
        offset = purge_sys->offset;
812
822
 
825
835
 
826
836
        mtr_start(&mtr);
827
837
 
828
 
        undo_page = trx_undo_page_get_s_latched(space, page_no, &mtr);
 
838
        undo_page = trx_undo_page_get_s_latched(space, zip_size,
 
839
                                                page_no, &mtr);
829
840
        rec = undo_page + offset;
830
841
 
831
842
        rec2 = rec;
876
887
 
877
888
                mtr_start(&mtr);
878
889
 
879
 
                undo_page = trx_undo_page_get_s_latched(space, page_no, &mtr);
 
890
                undo_page = trx_undo_page_get_s_latched(space, zip_size,
 
891
                                                        page_no, &mtr);
880
892
 
881
893
                rec = undo_page + offset;
882
894
        } else {
883
 
                page = buf_frame_align(rec2);
 
895
                page = page_align(rec2);
884
896
 
885
897
                purge_sys->purge_undo_no = trx_undo_rec_get_undo_no(rec2);
886
 
                purge_sys->page_no = buf_frame_get_page_no(page);
 
898
                purge_sys->page_no = page_get_page_no(page);
887
899
                purge_sys->offset = rec2 - page;
888
900
 
889
901
                if (undo_page != page) {
902
914
/************************************************************************
903
915
Fetches the next undo log record from the history list to purge. It must be
904
916
released with the corresponding release function. */
905
 
 
 
917
UNIV_INTERN
906
918
trx_undo_rec_t*
907
919
trx_purge_fetch_next_rec(
908
920
/*=====================*/
997
1009
 
998
1010
/***********************************************************************
999
1011
Releases a reserved purge undo record. */
1000
 
 
 
1012
UNIV_INTERN
1001
1013
void
1002
1014
trx_purge_rec_release(
1003
1015
/*==================*/
1016
1028
 
1017
1029
/***********************************************************************
1018
1030
This function runs a purge batch. */
1019
 
 
 
1031
UNIV_INTERN
1020
1032
ulint
1021
1033
trx_purge(void)
1022
1034
/*===========*/
1124
1136
 
1125
1137
/**********************************************************************
1126
1138
Prints information of the purge system to stderr. */
1127
 
 
 
1139
UNIV_INTERN
1128
1140
void
1129
1141
trx_purge_sys_print(void)
1130
1142
/*=====================*/
1132
1144
        fprintf(stderr, "InnoDB: Purge system view:\n");
1133
1145
        read_view_print(purge_sys->view);
1134
1146
 
1135
 
        fprintf(stderr, "InnoDB: Purge trx n:o %lu %lu, undo n_o %lu %lu\n",
1136
 
                (ulong) ut_dulint_get_high(purge_sys->purge_trx_no),
1137
 
                (ulong) ut_dulint_get_low(purge_sys->purge_trx_no),
1138
 
                (ulong) ut_dulint_get_high(purge_sys->purge_undo_no),
1139
 
                (ulong) ut_dulint_get_low(purge_sys->purge_undo_no));
 
1147
        fprintf(stderr, "InnoDB: Purge trx n:o " TRX_ID_FMT
 
1148
                ", undo n:o " TRX_ID_FMT "\n",
 
1149
                TRX_ID_PREP_PRINTF(purge_sys->purge_trx_no),
 
1150
                TRX_ID_PREP_PRINTF(purge_sys->purge_undo_no));
1140
1151
        fprintf(stderr,
1141
1152
                "InnoDB: Purge next stored %lu, page_no %lu, offset %lu,\n"
1142
1153
                "InnoDB: Purge hdr_page_no %lu, hdr_offset %lu\n",