← Back to branch summary

~vadim-tk/percona-server/percona-galera-5.1.57-0.8.1

« back to all changes in this revision

Viewing changes to storage/innodb_plugin/include/trx0purge.h

  • Committer: root
  • Date: 2011-07-28 00:14:23 UTC
  • Revision ID: root@r815.office.percona.com-20110728001423-6pw0v4b7r0dkbsr4
Ported to Galera 0.8.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/innodb_plugin/include/trx0purge.h
 
1
/*****************************************************************************
 
2
 
 
3
Copyright (c) 1996, 2009, Innobase Oy. All Rights Reserved.
 
4
 
 
5
This program is free software; you can redistribute it and/or modify it under
 
6
the terms of the GNU General Public License as published by the Free Software
 
7
Foundation; version 2 of the License.
 
8
 
 
9
This program is distributed in the hope that it will be useful, but WITHOUT
 
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 
11
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 
12
 
 
13
You should have received a copy of the GNU General Public License along with
 
14
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 
15
Place, Suite 330, Boston, MA 02111-1307 USA
 
16
 
 
17
*****************************************************************************/
 
18
 
 
19
/**************************************************//**
 
20
@file include/trx0purge.h
 
21
Purge old versions
 
22
 
 
23
Created 3/26/1996 Heikki Tuuri
 
24
*******************************************************/
 
25
 
 
26
#ifndef trx0purge_h
 
27
#define trx0purge_h
 
28
 
 
29
#include "univ.i"
 
30
#include "trx0types.h"
 
31
#include "mtr0mtr.h"
 
32
#include "trx0sys.h"
 
33
#include "que0types.h"
 
34
#include "page0page.h"
 
35
#include "usr0sess.h"
 
36
#include "fil0fil.h"
 
37
 
 
38
/** The global data structure coordinating a purge */
 
39
extern trx_purge_t*     purge_sys;
 
40
 
 
41
/** A dummy undo record used as a return value when we have a whole undo log
 
42
which needs no purge */
 
43
extern trx_undo_rec_t   trx_purge_dummy_rec;
 
44
 
 
45
/********************************************************************//**
 
46
Calculates the file address of an undo log header when we have the file
 
47
address of its history list node.
 
48
@return file address of the log */
 
49
UNIV_INLINE
 
50
fil_addr_t
 
51
trx_purge_get_log_from_hist(
 
52
/*========================*/
 
53
        fil_addr_t      node_addr);     /*!< in: file address of the history
 
54
                                        list node of the log */
 
55
/*****************************************************************//**
 
56
Checks if trx_id is >= purge_view: then it is guaranteed that its update
 
57
undo log still exists in the system.
 
58
@return TRUE if is sure that it is preserved, also if the function
 
59
returns FALSE, it is possible that the undo log still exists in the
 
60
system */
 
61
UNIV_INTERN
 
62
ibool
 
63
trx_purge_update_undo_must_exist(
 
64
/*=============================*/
 
65
        trx_id_t        trx_id);/*!< in: transaction id */
 
66
/********************************************************************//**
 
67
Creates the global purge system control structure and inits the history
 
68
mutex. */
 
69
UNIV_INTERN
 
70
void
 
71
trx_purge_sys_create(void);
 
72
/*======================*/
 
73
/********************************************************************//**
 
74
Frees the global purge system control structure. */
 
75
UNIV_INTERN
 
76
void
 
77
trx_purge_sys_close(void);
 
78
/*======================*/
 
79
/************************************************************************
 
80
Adds the update undo log as the first log in the history list. Removes the
 
81
update undo log segment from the rseg slot if it is too big for reuse. */
 
82
UNIV_INTERN
 
83
void
 
84
trx_purge_add_update_undo_to_history(
 
85
/*=================================*/
 
86
        trx_t*  trx,            /*!< in: transaction */
 
87
        page_t* undo_page,      /*!< in: update undo log header page,
 
88
                                x-latched */
 
89
        mtr_t*  mtr);           /*!< in: mtr */
 
90
/********************************************************************//**
 
91
Fetches the next undo log record from the history list to purge. It must be
 
92
released with the corresponding release function.
 
93
@return copy of an undo log record or pointer to trx_purge_dummy_rec,
 
94
if the whole undo log can skipped in purge; NULL if none left */
 
95
UNIV_INTERN
 
96
trx_undo_rec_t*
 
97
trx_purge_fetch_next_rec(
 
98
/*=====================*/
 
99
        roll_ptr_t*     roll_ptr,/*!< out: roll pointer to undo record */
 
100
        trx_undo_inf_t** cell,  /*!< out: storage cell for the record in the
 
101
                                purge array */
 
102
        mem_heap_t*     heap);  /*!< in: memory heap where copied */
 
103
/*******************************************************************//**
 
104
Releases a reserved purge undo record. */
 
105
UNIV_INTERN
 
106
void
 
107
trx_purge_rec_release(
 
108
/*==================*/
 
109
        trx_undo_inf_t* cell);  /*!< in: storage cell */
 
110
/*******************************************************************//**
 
111
This function runs a purge batch.
 
112
@return number of undo log pages handled in the batch */
 
113
UNIV_INTERN
 
114
ulint
 
115
trx_purge(void);
 
116
/*===========*/
 
117
/**********************************************************************
 
118
This function runs a purge worker batch */
 
119
UNIV_INTERN
 
120
void
 
121
trx_purge_worker(
 
122
/*=============*/
 
123
        ulint   worker_id);
 
124
/**********************************************************************
 
125
This function waits the event for worker batch */
 
126
UNIV_INTERN
 
127
void
 
128
trx_purge_worker_wait(void);
 
129
/*========================*/
 
130
/**********************************************************************
 
131
This function wakes the waiting worker batch */
 
132
UNIV_INTERN
 
133
void
 
134
trx_purge_worker_wake(void);
 
135
/*========================*/
 
136
/******************************************************************//**
 
137
Prints information of the purge system to stderr. */
 
138
UNIV_INTERN
 
139
void
 
140
trx_purge_sys_print(void);
 
141
/*======================*/
 
142
 
 
143
/** The control structure used in the purge operation */
 
144
struct trx_purge_struct{
 
145
        ulint           state;          /*!< Purge system state */
 
146
        sess_t*         sess;           /*!< System session running the purge
 
147
                                        query */
 
148
        trx_t*          trx;            /*!< System transaction running the purge
 
149
                                        query: this trx is not in the trx list
 
150
                                        of the trx system and it never ends */
 
151
        que_t*          query;          /*!< The query graph which will do the
 
152
                                        parallelized purge operation */
 
153
        ulint           n_worker;
 
154
        os_event_t      worker_event;
 
155
        sess_t**        sess_arr;
 
156
        trx_t**         trx_arr;
 
157
        que_t**         query_arr;
 
158
        rw_lock_t       latch;          /*!< The latch protecting the purge view.
 
159
                                        A purge operation must acquire an
 
160
                                        x-latch here for the instant at which
 
161
                                        it changes the purge view: an undo
 
162
                                        log operation can prevent this by
 
163
                                        obtaining an s-latch here. */
 
164
        read_view_t*    view;           /*!< The purge will not remove undo logs
 
165
                                        which are >= this view (purge view) */
 
166
        mutex_t         mutex;          /*!< Mutex protecting the fields below */
 
167
        ulint           n_pages_handled;/*!< Approximate number of undo log
 
168
                                        pages processed in purge */
 
169
        ulint           handle_limit;   /*!< Target of how many pages to get
 
170
                                        processed in the current purge */
 
171
        /*------------------------------*/
 
172
        /* The following two fields form the 'purge pointer' which advances
 
173
        during a purge, and which is used in history list truncation */
 
174
 
 
175
        trx_id_t        purge_trx_no;   /*!< Purge has advanced past all
 
176
                                        transactions whose number is less
 
177
                                        than this */
 
178
        undo_no_t       purge_undo_no;  /*!< Purge has advanced past all records
 
179
                                        whose undo number is less than this */
 
180
        /*-----------------------------*/
 
181
        ibool           next_stored;    /*!< TRUE if the info of the next record
 
182
                                        to purge is stored below: if yes, then
 
183
                                        the transaction number and the undo
 
184
                                        number of the record are stored in
 
185
                                        purge_trx_no and purge_undo_no above */
 
186
        trx_rseg_t*     rseg;           /*!< Rollback segment for the next undo
 
187
                                        record to purge */
 
188
        ulint           page_no;        /*!< Page number for the next undo
 
189
                                        record to purge, page number of the
 
190
                                        log header, if dummy record */
 
191
        ulint           offset;         /*!< Page offset for the next undo
 
192
                                        record to purge, 0 if the dummy
 
193
                                        record */
 
194
        ulint           hdr_page_no;    /*!< Header page of the undo log where
 
195
                                        the next record to purge belongs */
 
196
        ulint           hdr_offset;     /*!< Header byte offset on the page */
 
197
        /*-----------------------------*/
 
198
        trx_undo_arr_t* arr;            /*!< Array of transaction numbers and
 
199
                                        undo numbers of the undo records
 
200
                                        currently under processing in purge */
 
201
        mem_heap_t*     heap;           /*!< Temporary storage used during a
 
202
                                        purge: can be emptied after purge
 
203
                                        completes */
 
204
};
 
205
 
 
206
#define TRX_PURGE_ON            1       /* purge operation is running */
 
207
#define TRX_STOP_PURGE          2       /* purge operation is stopped, or
 
208
                                        it should be stopped */
 
209
#ifndef UNIV_NONINL
 
210
#include "trx0purge.ic"
 
211
#endif
 
212
 
 
213
#endif