The world's most popular open source database

MySQL 5.1: mysql/src/5.1-dbg/storage/innobase/include/trx0purge.h File Reference

mysql/src/5.1-dbg/storage/innobase/include/trx0purge.h File Reference

#include "univ.i"
#include "trx0types.h"
#include "mtr0mtr.h"
#include "trx0sys.h"
#include "que0types.h"
#include "page0page.h"
#include "usr0sess.h"
#include "fil0fil.h"

Include dependency graph for trx0purge.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.


Classes
struct	trx_purge_struct
Defines
#define	TRX_PURGE_ON 1
#define	TRX_STOP_PURGE 2
Functions
UNIV_INLINE fil_addr_t	trx_purge_get_log_from_hist (fil_addr_t node_addr)
ibool	trx_purge_update_undo_must_exist (dulint trx_id)
void	trx_purge_sys_create (void)
void	trx_purge_add_update_undo_to_history (trx_t trx, page_t undo_page, mtr_t *mtr)
trx_undo_rec_t *	trx_purge_fetch_next_rec (dulint roll_ptr, trx_undo_inf_t cell, mem_heap_t heap)
void	trx_purge_rec_release (trx_undo_inf_t *cell)
ulint	trx_purge (void)
void	trx_purge_sys_print (void)
Variables
trx_purge_t *	purge_sys
trx_undo_rec_t	trx_purge_dummy_rec

Define Documentation

#define TRX_PURGE_ON 1

Definition at line 162 of file trx0purge.h.

Referenced by trx_purge().

#define TRX_STOP_PURGE 2

Definition at line 163 of file trx0purge.h.

Referenced by trx_purge_fetch_next_rec(), and trx_purge_sys_create().

Function Documentation

ulint trx_purge ( void )

Definition at line 1035 of file trx0purge.c.

References trx_purge_struct::handle_limit, trx_purge_struct::heap, kernel_mutex, trx_purge_struct::latch, mem_heap_empty(), trx_purge_struct::mutex, mutex_enter, mutex_exit(), trx_struct::n_active_thrs, trx_purge_struct::n_pages_handled, NULL, purge_sys, que_fork_start_command(), que_run_threads(), trx_purge_struct::query, read_view_close(), read_view_oldest_copy_or_open_new(), trx_sys_struct::rseg_history_len, rw_lock_x_lock, rw_lock_x_unlock, srv_dml_needed_delay, srv_max_purge_lag, srv_print_thread_releases, trx_purge_struct::state, trx_purge_struct::trx, TRX_PURGE_ON, trx_sys, ut_ad, ut_dulint_create(), ut_error, UT_LIST_GET_LAST, and trx_purge_struct::view.

Referenced by srv_master_thread().

01037                                       : number of undo log pages handled in
01038                                 the batch */
01039 {
01040         que_thr_t*      thr;
01041 /*      que_thr_t*      thr2; */
01042         ulint           old_pages_handled;
01043 
01044         mutex_enter(&(purge_sys->mutex));
01045 
01046         if (purge_sys->trx->n_active_thrs > 0) {
01047 
01048                 mutex_exit(&(purge_sys->mutex));
01049 
01050                 /* Should not happen */
01051 
01052                 ut_error;
01053 
01054                 return(0);
01055         }
01056 
01057         rw_lock_x_lock(&(purge_sys->latch));
01058 
01059         mutex_enter(&kernel_mutex);
01060 
01061         /* Close and free the old purge view */
01062 
01063         read_view_close(purge_sys->view);
01064         purge_sys->view = NULL;
01065         mem_heap_empty(purge_sys->heap);
01066 
01067         /* Determine how much data manipulation language (DML) statements
01068         need to be delayed in order to reduce the lagging of the purge
01069         thread. */
01070         srv_dml_needed_delay = 0; /* in microseconds; default: no delay */
01071 
01072         /* If we cannot advance the 'purge view' because of an old
01073         'consistent read view', then the DML statements cannot be delayed.
01074         Also, srv_max_purge_lag <= 0 means 'infinity'. */
01075         if (srv_max_purge_lag > 0
01076                         && !UT_LIST_GET_LAST(trx_sys->view_list)) {
01077                 float   ratio = (float) trx_sys->rseg_history_len
01078                                 / srv_max_purge_lag;
01079                 if (ratio > ULINT_MAX / 10000) {
01080                         /* Avoid overflow: maximum delay is 4295 seconds */
01081                         srv_dml_needed_delay = ULINT_MAX;
01082                 } else if (ratio > 1) {
01083                         /* If the history list length exceeds the
01084                         innodb_max_purge_lag, the
01085                         data manipulation statements are delayed
01086                         by at least 5000 microseconds. */
01087                         srv_dml_needed_delay = (ulint) ((ratio - .5) * 10000);
01088                 }
01089         }
01090 
01091         purge_sys->view = read_view_oldest_copy_or_open_new(
01092                                                 ut_dulint_create(0, 0),
01093                                                         purge_sys->heap);
01094         mutex_exit(&kernel_mutex);
01095 
01096         rw_lock_x_unlock(&(purge_sys->latch));
01097 
01098         purge_sys->state = TRX_PURGE_ON;
01099 
01100         /* Handle at most 20 undo log pages in one purge batch */
01101 
01102         purge_sys->handle_limit = purge_sys->n_pages_handled + 20;
01103 
01104         old_pages_handled = purge_sys->n_pages_handled;
01105 
01106         mutex_exit(&(purge_sys->mutex));
01107 
01108         mutex_enter(&kernel_mutex);
01109 
01110         thr = que_fork_start_command(purge_sys->query);
01111 
01112         ut_ad(thr);
01113 
01114 /*      thr2 = que_fork_start_command(purge_sys->query);
01115 
01116         ut_ad(thr2); */
01117 
01118 
01119         mutex_exit(&kernel_mutex);
01120 
01121 /*      srv_que_task_enqueue(thr2); */
01122 
01123         if (srv_print_thread_releases) {
01124 
01125                 fputs("Starting purge\n", stderr);
01126         }
01127 
01128         que_run_threads(thr);
01129 
01130         if (srv_print_thread_releases) {
01131 
01132                 fprintf(stderr,
01133                 "Purge ends; pages handled %lu\n",
01134                 (ulong) purge_sys->n_pages_handled);
01135         }
01136 
01137         return(purge_sys->n_pages_handled - old_pages_handled);
01138 }

Here is the call graph for this function:

Here is the caller graph for this function:

void trx_purge_add_update_undo_to_history	(	trx_t *	trx,
		page_t *	undo_page,
		mtr_t *	mtr
	)

Definition at line 243 of file trx0purge.c.

References trx_undo_struct::del_marks, FALSE, FIL_NULL, flst_add_first(), flst_get_len(), trx_undo_struct::hdr_offset, trx_undo_struct::hdr_page_no, trx_undo_struct::id, kernel_mutex, trx_rseg_struct::last_del_marks, trx_rseg_struct::last_offset, trx_rseg_struct::last_page_no, trx_rseg_struct::last_trx_no, MLOG_2BYTES, MLOG_4BYTES, mlog_write_dulint(), mlog_write_ulint(), mtr_read_ulint(), trx_rseg_struct::mutex, mutex_enter, mutex_exit(), trx_struct::no, trx_rseg_struct::page_no, trx_undo_struct::rseg, trx_sys_struct::rseg_history_len, trx_undo_struct::size, trx_rseg_struct::space, trx_undo_struct::state, TRX_RSEG_HISTORY, TRX_RSEG_HISTORY_SIZE, TRX_RSEG_N_SLOTS, trx_rsegf_get(), trx_rsegf_set_nth_undo(), trx_sys, TRX_UNDO_CACHED, TRX_UNDO_DEL_MARKS, TRX_UNDO_HISTORY_NODE, TRX_UNDO_PAGE_HDR, TRX_UNDO_PAGE_LIST, TRX_UNDO_SEG_HDR, TRX_UNDO_TRX_NO, trx_struct::update_undo, ut_ad, and ut_error.

Referenced by trx_undo_update_cleanup().

00245                                      : transaction */
00246         page_t* undo_page,      /* in: update undo log header page,
00247                                 x-latched */
00248         mtr_t*  mtr)            /* in: mtr */
00249 {
00250         trx_undo_t*     undo;
00251         trx_rseg_t*     rseg;
00252         trx_rsegf_t*    rseg_header;
00253         trx_usegf_t*    seg_header;
00254         trx_ulogf_t*    undo_header;
00255         trx_upagef_t*   page_header;
00256         ulint           hist_size;
00257 
00258         undo = trx->update_undo;
00259 
00260         ut_ad(undo);
00261 
00262         rseg = undo->rseg;
00263 #ifdef UNIV_SYNC_DEBUG
00264         ut_ad(mutex_own(&(rseg->mutex)));
00265 #endif /* UNIV_SYNC_DEBUG */
00266 
00267         rseg_header = trx_rsegf_get(rseg->space, rseg->page_no, mtr);
00268 
00269         undo_header = undo_page + undo->hdr_offset;
00270         seg_header  = undo_page + TRX_UNDO_SEG_HDR;
00271         page_header = undo_page + TRX_UNDO_PAGE_HDR;
00272 
00273         if (undo->state != TRX_UNDO_CACHED) {
00274                 /* The undo log segment will not be reused */
00275 
00276                 if (undo->id >= TRX_RSEG_N_SLOTS) {
00277                         fprintf(stderr,
00278                         "InnoDB: Error: undo->id is %lu\n", (ulong) undo->id);
00279                         ut_error;
00280                 }
00281 
00282                 trx_rsegf_set_nth_undo(rseg_header, undo->id, FIL_NULL, mtr);
00283 
00284                 hist_size = mtr_read_ulint(rseg_header + TRX_RSEG_HISTORY_SIZE,
00285                                                         MLOG_4BYTES, mtr);
00286                 ut_ad(undo->size ==
00287                         flst_get_len(seg_header + TRX_UNDO_PAGE_LIST, mtr));
00288 
00289                 mlog_write_ulint(rseg_header + TRX_RSEG_HISTORY_SIZE,
00290                                 hist_size + undo->size, MLOG_4BYTES, mtr);
00291         }
00292 
00293         /* Add the log as the first in the history list */
00294         flst_add_first(rseg_header + TRX_RSEG_HISTORY,
00295                                 undo_header + TRX_UNDO_HISTORY_NODE, mtr);
00296         mutex_enter(&kernel_mutex);
00297         trx_sys->rseg_history_len++;
00298         mutex_exit(&kernel_mutex);
00299 
00300         /* Write the trx number to the undo log header */
00301         mlog_write_dulint(undo_header + TRX_UNDO_TRX_NO, trx->no, mtr);
00302         /* Write information about delete markings to the undo log header */
00303 
00304         if (!undo->del_marks) {
00305                 mlog_write_ulint(undo_header + TRX_UNDO_DEL_MARKS, FALSE,
00306                                                         MLOG_2BYTES, mtr);
00307         }
00308 
00309         if (rseg->last_page_no == FIL_NULL) {
00310 
00311                 rseg->last_page_no = undo->hdr_page_no;
00312                 rseg->last_offset = undo->hdr_offset;
00313                 rseg->last_trx_no = trx->no;
00314                 rseg->last_del_marks = undo->del_marks;
00315         }
00316 }

Here is the call graph for this function:

Here is the caller graph for this function:

trx_undo_rec_t* trx_purge_fetch_next_rec	(	dulint *	roll_ptr,
		trx_undo_inf_t **	cell,
		mem_heap_t *	heap
	)

Definition at line 922 of file trx0purge.c.

Referenced by row_purge().

00924                                       : copy of an undo log record or
00925                                 pointer to the dummy undo log record
00926                                 &trx_purge_dummy_rec, if the whole undo log
00927                                 can skipped in purge; NULL if none left */
00928         dulint*         roll_ptr,/* out: roll pointer to undo record */
00929         trx_undo_inf_t** cell,  /* out: storage cell for the record in the
00930                                 purge array */
00931         mem_heap_t*     heap)   /* in: memory heap where copied */
00932 {
00933         trx_undo_rec_t* undo_rec;
00934 
00935         mutex_enter(&(purge_sys->mutex));
00936 
00937         if (purge_sys->state == TRX_STOP_PURGE) {
00938                 trx_purge_truncate_if_arr_empty();
00939 
00940                 mutex_exit(&(purge_sys->mutex));
00941 
00942                 return(NULL);
00943         }
00944 
00945         if (!purge_sys->next_stored) {
00946                 trx_purge_choose_next_log();
00947 
00948                 if (!purge_sys->next_stored) {
00949                         purge_sys->state = TRX_STOP_PURGE;
00950 
00951                         trx_purge_truncate_if_arr_empty();
00952 
00953                         if (srv_print_thread_releases) {
00954                                 fprintf(stderr,
00955         "Purge: No logs left in the history list; pages handled %lu\n",
00956                                         (ulong) purge_sys->n_pages_handled);
00957                         }
00958 
00959                         mutex_exit(&(purge_sys->mutex));
00960 
00961                         return(NULL);
00962                 }
00963         }
00964 
00965         if (purge_sys->n_pages_handled >= purge_sys->handle_limit) {
00966 
00967                 purge_sys->state = TRX_STOP_PURGE;
00968 
00969                 trx_purge_truncate_if_arr_empty();
00970 
00971                 mutex_exit(&(purge_sys->mutex));
00972 
00973                 return(NULL);
00974         }
00975 
00976         if (ut_dulint_cmp(purge_sys->purge_trx_no,
00977                                 purge_sys->view->low_limit_no) >= 0) {
00978                 purge_sys->state = TRX_STOP_PURGE;
00979 
00980                 trx_purge_truncate_if_arr_empty();
00981 
00982                 mutex_exit(&(purge_sys->mutex));
00983 
00984                 return(NULL);
00985         }
00986 
00987 /*      fprintf(stderr, "Thread %lu purging trx %lu undo record %lu\n",
00988                 os_thread_get_curr_id(),
00989                 ut_dulint_get_low(purge_sys->purge_trx_no),
00990                 ut_dulint_get_low(purge_sys->purge_undo_no)); */
00991 
00992         *roll_ptr = trx_undo_build_roll_ptr(FALSE, (purge_sys->rseg)->id,
00993                                                         purge_sys->page_no,
00994                                                         purge_sys->offset);
00995 
00996         *cell = trx_purge_arr_store_info(purge_sys->purge_trx_no,
00997                                          purge_sys->purge_undo_no);
00998 
00999         ut_ad(ut_dulint_cmp(purge_sys->purge_trx_no,
01000                         (purge_sys->view)->low_limit_no) < 0);
01001 
01002         /* The following call will advance the stored values of purge_trx_no
01003         and purge_undo_no, therefore we had to store them first */
01004 
01005         undo_rec = trx_purge_get_next_rec(heap);
01006 
01007         mutex_exit(&(purge_sys->mutex));
01008 
01009         return(undo_rec);
01010 }

Here is the call graph for this function:

Here is the caller graph for this function:

UNIV_INLINE fil_addr_t trx_purge_get_log_from_hist ( fil_addr_t node_addr )

Referenced by trx_purge_rseg_get_next_history_log(), trx_purge_truncate_rseg_history(), and trx_rseg_mem_create().

Here is the caller graph for this function:

void trx_purge_rec_release ( trx_undo_inf_t * cell )

Definition at line 1016 of file trx0purge.c.

References trx_purge_struct::arr, trx_purge_struct::mutex, mutex_enter, mutex_exit(), purge_sys, and trx_purge_arr_remove_info().

Referenced by row_purge().

01018                                      : storage cell */
01019 {
01020         trx_undo_arr_t* arr;
01021 
01022         mutex_enter(&(purge_sys->mutex));
01023 
01024         arr = purge_sys->arr;
01025 
01026         trx_purge_arr_remove_info(cell);
01027 
01028         mutex_exit(&(purge_sys->mutex));
01029 }

Here is the call graph for this function:

Here is the caller graph for this function:

void trx_purge_sys_create ( void )

Definition at line 197 of file trx0purge.c.

References trx_purge_struct::arr, FALSE, trx_purge_struct::heap, kernel_mutex, trx_purge_struct::latch, mem_alloc, mem_heap_create, trx_purge_struct::mutex, mutex_create, trx_purge_struct::n_pages_handled, trx_purge_struct::next_stored, purge_sys, trx_purge_struct::purge_trx_no, trx_purge_struct::purge_undo_no, trx_purge_struct::query, read_view_oldest_copy_or_open_new(), rw_lock_create, trx_purge_struct::sess, sess_open(), trx_purge_struct::state, SYNC_PURGE_LATCH, SYNC_PURGE_SYS, trx_purge_struct::trx, sess_struct::trx, TRX_PURGE, trx_purge_graph_build(), trx_start_low(), TRX_STOP_PURGE, trx_undo_arr_create(), trx_struct::type, ut_a, ut_ad, ut_dulint_create(), ut_dulint_zero, and trx_purge_struct::view.

00199 {
00200 #ifdef UNIV_SYNC_DEBUG
00201         ut_ad(mutex_own(&kernel_mutex));
00202 #endif /* UNIV_SYNC_DEBUG */
00203 
00204         purge_sys = mem_alloc(sizeof(trx_purge_t));
00205 
00206         purge_sys->state = TRX_STOP_PURGE;
00207 
00208         purge_sys->n_pages_handled = 0;
00209 
00210         purge_sys->purge_trx_no = ut_dulint_zero;
00211         purge_sys->purge_undo_no = ut_dulint_zero;
00212         purge_sys->next_stored = FALSE;
00213 
00214         rw_lock_create(&purge_sys->latch, SYNC_PURGE_LATCH);
00215 
00216         mutex_create(&purge_sys->mutex, SYNC_PURGE_SYS);
00217 
00218         purge_sys->heap = mem_heap_create(256);
00219 
00220         purge_sys->arr = trx_undo_arr_create();
00221 
00222         purge_sys->sess = sess_open();
00223 
00224         purge_sys->trx = purge_sys->sess->trx;
00225 
00226         purge_sys->trx->type = TRX_PURGE;
00227 
00228         ut_a(trx_start_low(purge_sys->trx, ULINT_UNDEFINED));
00229 
00230         purge_sys->query = trx_purge_graph_build();
00231 
00232         purge_sys->view = read_view_oldest_copy_or_open_new(
00233                                 ut_dulint_create(0,0), purge_sys->heap);
00234 }

Here is the call graph for this function:

void trx_purge_sys_print ( void )

Definition at line 1144 of file trx0purge.c.

References trx_purge_struct::hdr_offset, trx_purge_struct::hdr_page_no, trx_purge_struct::next_stored, trx_purge_struct::offset, trx_purge_struct::page_no, purge_sys, trx_purge_struct::purge_trx_no, trx_purge_struct::purge_undo_no, read_view_print(), ut_dulint_get_high(), ut_dulint_get_low(), and trx_purge_struct::view.

Referenced by trx_undo_prev_version_build().

01146 {
01147         fprintf(stderr, "InnoDB: Purge system view:\n");
01148         read_view_print(purge_sys->view);
01149 
01150         fprintf(stderr, "InnoDB: Purge trx n:o %lu %lu, undo n_o %lu %lu\n",
01151                         (ulong) ut_dulint_get_high(purge_sys->purge_trx_no),
01152                         (ulong) ut_dulint_get_low(purge_sys->purge_trx_no),
01153                         (ulong) ut_dulint_get_high(purge_sys->purge_undo_no),
01154                         (ulong) ut_dulint_get_low(purge_sys->purge_undo_no));
01155         fprintf(stderr,
01156         "InnoDB: Purge next stored %lu, page_no %lu, offset %lu,\n"
01157         "InnoDB: Purge hdr_page_no %lu, hdr_offset %lu\n",
01158                 (ulong) purge_sys->next_stored,
01159                 (ulong) purge_sys->page_no,
01160                 (ulong) purge_sys->offset,
01161                 (ulong) purge_sys->hdr_page_no,
01162                 (ulong) purge_sys->hdr_offset);
01163 }

Here is the call graph for this function:

Here is the caller graph for this function:

ibool trx_purge_update_undo_must_exist ( dulint trx_id )

Definition at line 41 of file trx0purge.c.

References FALSE, trx_purge_struct::latch, purge_sys, read_view_sees_trx_id(), RW_LOCK_SHARED, TRUE, ut_ad, and trx_purge_struct::view.

Referenced by row_vers_must_preserve_del_marked(), and trx_undo_get_undo_rec().

00043                               : TRUE if is sure that it is preserved, also
00044                         if the function returns FALSE, it is possible that
00045                         the undo log still exists in the system */
00046         dulint  trx_id) /* in: transaction id */
00047 {
00048 #ifdef UNIV_SYNC_DEBUG
00049         ut_ad(rw_lock_own(&(purge_sys->latch), RW_LOCK_SHARED));
00050 #endif /* UNIV_SYNC_DEBUG */
00051 
00052         if (!read_view_sees_trx_id(purge_sys->view, trx_id)) {
00053 
00054                 return(TRUE);
00055         }
00056 
00057         return(FALSE);
00058 }