← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbxt/src/datalog_xt.h

  • Committer: Padraig O'Sullivan
  • Date: 2009-12-17 04:48:59 UTC
  • mto: This revision was merged to the branch mainline in revision 1246.
  • Revision ID: osullivan.padraig@gmail.com-20091217044859-qorpkp4911zypfv3
Added some dtrace probes for tracing the optimizer.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbxt/src/datalog_xt.h
1
 
/* Copyright (C) 2005 PrimeBase Technologies GmbH
2
 
 *
3
 
 * PrimeBase XT
4
 
 *
5
 
 * This program is free software; you can redistribute it and/or modify
6
 
 * it under the terms of the GNU General Public License as published by
7
 
 * the Free Software Foundation; either version 2 of the License, or
8
 
 * (at your option) any later version.
9
 
 *
10
 
 * This program is distributed in the hope that it will be useful,
11
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 * GNU General Public License for more details.
14
 
 *
15
 
 * You should have received a copy of the GNU General Public License
16
 
 * along with this program; if not, write to the Free Software
17
 
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
 
 *
19
 
 * 2005-01-24   Paul McCullagh
20
 
 *
21
 
 * H&G2JCtL
22
 
 */
23
 
#ifndef __xt_datalog_h__
24
 
#define __xt_datalog_h__
25
 
 
26
 
#include "pthread_xt.h"
27
 
#include "filesys_xt.h"
28
 
#include "sortedlist_xt.h"
29
 
#include "xactlog_xt.h"
30
 
#include "util_xt.h"
31
 
 
32
 
struct XTThread;
33
 
struct XTDatabase;
34
 
struct xXTDataLog;
35
 
struct XTTable;
36
 
struct XTOpenTable;
37
 
 
38
 
#define XT_SET_LOG_REF(d, l, o)                 do { XT_SET_DISK_2((d)->re_log_id_2, l); \
39
 
                                                                                         XT_SET_DISK_6((d)->re_log_offs_6, o); \
40
 
                                                                                } while (0)
41
 
#define XT_GET_LOG_REF(l, o, s)                 do { l = XT_GET_DISK_2((s)->re_log_id_2); \
42
 
                                                                                         o = XT_GET_DISK_6((s)->re_log_offs_6); \
43
 
                                                                                } while (0)
44
 
 
45
 
#ifdef DEBUG
46
 
//#define USE_DEBUG_SIZES
47
 
#endif
48
 
 
49
 
#ifdef USE_DEBUG_SIZES
50
 
#define XT_DL_MAX_LOG_ID                                500
51
 
#define XT_DL_LOG_POOL_SIZE                             10
52
 
#define XT_DL_HASH_TABLE_SIZE                   5
53
 
#define XT_DL_SEGMENT_SHIFTS                    1
54
 
#else
55
 
#define XT_DL_MAX_LOG_ID                                0x7FFF
56
 
#define XT_DL_LOG_POOL_SIZE                             1000
57
 
#define XT_DL_HASH_TABLE_SIZE                   10000
58
 
#define XT_DL_SEGMENT_SHIFTS                    3
59
 
#endif
60
 
 
61
 
#define XT_DL_SEG_HASH_TABLE_SIZE               (XT_DL_HASH_TABLE_SIZE / XT_DL_NO_OF_SEGMENTS)
62
 
#define XT_DL_NO_OF_SEGMENTS                    (1 << XT_DL_SEGMENT_SHIFTS)
63
 
#define XT_DL_SEGMENT_MASK                              (XT_DL_NO_OF_SEGMENTS - 1)
64
 
 
65
 
typedef struct XTOpenLogFile {
66
 
        xtLogID                                 olf_log_id;
67
 
        XTOpenFilePtr                   odl_log_file;                                   /* The open file handle. */
68
 
        struct XTDataLogFile    *odl_data_log;
69
 
 
70
 
        xtBool                                  odl_in_use;
71
 
        struct XTOpenLogFile    *odl_next_free;                                 /* Pointer to the next on the free list. */
72
 
        struct XTOpenLogFile    *odl_prev_free;                                 /* Pointer to the previous on the free list. */
73
 
 
74
 
        xtWord4                                 odl_ru_time;                                    /* If this is in the top 1/4 don't change position in MRU list. */
75
 
        struct XTOpenLogFile    *odl_mr_used;                                   /* More recently used pages. */
76
 
        struct XTOpenLogFile    *odl_lr_used;                                   /* Less recently used pages. */
77
 
} XTOpenLogFileRec, *XTOpenLogFilePtr;
78
 
 
79
 
#define XT_DL_MAY_COMPACT       -1                                                              /* This is an indication to set the state to XT_DL_TO_COMPACT. */
80
 
#define XT_DL_UNKNOWN           0
81
 
#define XT_DL_HAS_SPACE         1                                                               /* The log is not yet full, and can be used for writing. */
82
 
#define XT_DL_READ_ONLY         2                                                               /* The log is full, and can only be read now. */
83
 
#define XT_DL_TO_COMPACT        3                                                               /* The log has too much garbage, and must be compacted. */
84
 
#define XT_DL_COMPACTED         4                                                               /* The state after compaction. */
85
 
#define XT_DL_TO_DELETE         5                                                               /* All references to this log have been removed, and it is to be deleted. */
86
 
#define XT_DL_DELETED           6                                                               /* After deletion, logs are locked until the next checkpoint. */
87
 
#define XT_DL_EXCLUSIVE         7                                                               /* The log is locked and being written by a thread. */
88
 
 
89
 
typedef struct XTDataLogFile {
90
 
        xtLogID                                 dlf_log_id;                                             /* The ID of the data log. */
91
 
        int                                             dlf_state;
92
 
        struct XTDataLogFile    *dlf_next_hash;                                 /* Pointer to the next on the hash list. */
93
 
        u_int                                   dlf_open_count;                                 /* Number of open log files. */
94
 
        XTOpenLogFilePtr                dlf_free_list;                                  /* The open file free list. */
95
 
        off_t                                   dlf_log_eof;
96
 
        off_t                                   dlf_start_offset;                               /* Start offset for garbage collection. */
97
 
        off_t                                   dlf_garbage_count;                              /* The amount of garbage in the log file. */
98
 
        XTOpenFilePtr                   dlf_log_file;                                   /* The open file handle (if the log is in exclusive use!!). */
99
 
 
100
 
        off_t                                   dlf_space_avaliable();
101
 
        xtBool                                  dlf_to_much_garbage();
102
 
} XTDataLogFileRec, *XTDataLogFilePtr;
103
 
 
104
 
typedef struct XTDataLogSeg {
105
 
        xt_mutex_type                   dls_lock;                                               /* The cache segment lock. */
106
 
        xt_cond_type                    dls_cond;
107
 
        XTDataLogFilePtr                dls_hash_table[XT_DL_SEG_HASH_TABLE_SIZE];
108
 
} XTDataLogSegRec, *XTDataLogSegPtr;
109
 
 
110
 
typedef struct XTDataLogCache {
111
 
        struct XTDatabase               *dlc_db;
112
 
 
113
 
        xt_mutex_type                   dlc_lock;                                               /* The public cache lock. */
114
 
        xt_cond_type                    dlc_cond;                                               /* The public cache wait condition. */
115
 
        XTSortedListPtr                 dlc_has_space;                                  /* List of logs with space for more data. */
116
 
        XTSortedListPtr                 dlc_to_compact;                                 /* List of logs to be compacted. */
117
 
        XTSortedListPtr                 dlc_to_delete;                                  /* List of logs to be deleted at next checkpoint. */
118
 
        XTSortedListPtr                 dlc_deleted;                                    /* List of logs deleted at the previous checkpoint. */
119
 
        XTDataLogSegRec                 dlc_segment[XT_DL_NO_OF_SEGMENTS];
120
 
        xtLogID                                 dlc_next_log_id;                                /* The next log ID to be used to create a new log. */
121
 
 
122
 
        xt_mutex_type                   dlc_mru_lock;                                   /* The lock for the LRU list. */
123
 
        xtWord4                                 dlc_ru_now;
124
 
        XTOpenLogFilePtr                dlc_lru_open_log;
125
 
        XTOpenLogFilePtr                dlc_mru_open_log;
126
 
        u_int                                   dlc_open_count;                                 /* The total open file count. */
127
 
 
128
 
        xt_mutex_type                   dlc_head_lock;                                  /* The lock for changing the header of shared logs. */
129
 
 
130
 
        void                                    dls_remove_log(XTDataLogFilePtr data_log);
131
 
        int                                             dls_get_log_state(XTDataLogFilePtr data_log);
132
 
        xtBool                                  dls_set_log_state(XTDataLogFilePtr data_log, int state);
133
 
        void                                    dlc_init(struct XTThread *self, struct XTDatabase *db);
134
 
        void                                    dlc_exit(struct XTThread *self);
135
 
        void                                    dlc_name(size_t size, char *path, xtLogID log_id);
136
 
        xtBool                                  dlc_open_log(XTOpenFilePtr *fh, xtLogID log_id, int mode);
137
 
        xtBool                                  dlc_unlock_log(XTDataLogFilePtr data_log);
138
 
        XTDataLogFilePtr                dlc_get_log_for_writing(off_t space_required, struct XTThread *thread);
139
 
        xtBool                                  dlc_get_data_log(XTDataLogFilePtr *data_log, xtLogID log_id, xtBool create, XTDataLogSegPtr *ret_seg);
140
 
        xtBool                                  dlc_remove_data_log(xtLogID log_id, xtBool just_close);
141
 
        xtBool                                  dlc_get_open_log(XTOpenLogFilePtr *open_log, xtLogID log_id);
142
 
        void                                    dlc_release_open_log(XTOpenLogFilePtr open_log);
143
 
} XTDataLogCacheRec, *XTDataLogCachePtr;
144
 
 
145
 
/* The data log buffer, used by a thread to write a
146
 
 * data log file.
147
 
 */
148
 
typedef struct XTDataLogBuffer {
149
 
        struct XTDatabase               *dlb_db;
150
 
        XTDataLogFilePtr                dlb_data_log;                                           /* The data log file. */
151
 
        
152
 
        xtLogOffset                             dlb_buffer_offset;                                      /* The offset into the log file. */
153
 
        size_t                                  dlb_buffer_size;                                        /* The size of the buffer. */
154
 
        size_t                                  dlb_buffer_len;                                         /* The amount of data in the buffer. */
155
 
        xtWord1                                 *dlb_log_buffer;
156
 
        xtBool                                  dlb_flush_required;
157
 
#ifdef DEBUG
158
 
        off_t                                   dlb_max_write_offset;
159
 
#endif
160
 
 
161
 
        void                                    dlb_init(struct XTDatabase *db, size_t buffer_size);
162
 
        void                                    dlb_exit(struct XTThread *self);
163
 
        xtBool                                  dlb_close_log(struct XTThread *thread);
164
 
        xtBool                                  dlb_get_log_offset(xtLogID *log_id, xtLogOffset *out_offset, size_t req_size, struct XTThread *thread);
165
 
        xtBool                                  dlb_flush_log(xtBool commit, struct XTThread *thread);
166
 
        xtBool                                  dlb_write_thru_log(xtLogID log_id, xtLogOffset log_offset, size_t size, xtWord1 *data, struct XTThread *thread);
167
 
        xtBool                                  dlb_append_log(xtLogID log_id, off_t out_offset, size_t size, xtWord1 *data, struct XTThread *thread);
168
 
        xtBool                                  dlb_read_log(xtLogID log_id, off_t offset, size_t size, xtWord1 *data, struct XTThread *thread);
169
 
        xtBool                                  dlb_delete_log(xtLogID log_id, off_t offset, size_t size, xtTableID tab_id, xtRecordID tab_offset, struct XTThread *thread);
170
 
} XTDataLogBufferRec, *XTDataLogBufferPtr;
171
 
 
172
 
typedef struct XTSeqLogRead {
173
 
        struct XTDatabase               *sl_db;
174
 
 
175
 
        virtual                                 ~XTSeqLogRead() { }
176
 
        virtual xtBool                  sl_seq_init(struct XTDatabase *db, size_t buffer_size) { (void) buffer_size; sl_db = db; return OK; }
177
 
        virtual void                    sl_seq_exit() { }
178
 
        virtual XTOpenFilePtr   sl_seq_open_file() { return NULL; }
179
 
        virtual void                    sl_seq_pos(xtLogID *log_id, xtLogOffset *log_offset) { (void) log_id; (void) log_offset; }
180
 
        virtual xtBool                  sl_seq_start(xtLogID log_id, xtLogOffset log_offset, xtBool missing_ok) {
181
 
                (void) log_id; (void) log_offset; (void) missing_ok; return OK; 
182
 
        }
183
 
        virtual xtBool                  sl_rnd_read(xtLogOffset log_offset, size_t size, xtWord1 *data, size_t *read, struct XTThread *thread) {
184
 
                (void) log_offset; (void) size; (void) data; (void) read; (void) thread; return OK;
185
 
        }
186
 
        virtual xtBool                  sl_seq_next(XTXactLogBufferDPtr *entry, struct XTThread *thread) {
187
 
                (void) entry; (void) thread; return OK;
188
 
        }
189
 
        virtual void                    sl_seq_skip(size_t size) { (void) size; }
190
 
} XTSeqLogReadRec, *XTSeqLogReadPtr;
191
 
 
192
 
typedef struct XTDataSeqRead : public XTSeqLogRead {
193
 
        XTOpenFilePtr                   sl_log_file;
194
 
        xtLogID                                 sl_rec_log_id;          /* The current record log ID. */
195
 
        xtLogOffset                             sl_rec_log_offset;      /* The current log read position. */
196
 
        size_t                                  sl_record_len;          /* The length of the current record. */
197
 
        xtLogOffset                             sl_log_eof;
198
 
        xtLogOffset                             sl_extra_garbage;       /* Garbage found during a scan. */
199
 
 
200
 
        size_t                                  sl_buffer_size;         /* Size of the buffer. */
201
 
        xtLogOffset                             sl_buf_log_offset;      /* File offset of the buffer. */
202
 
        size_t                                  sl_buffer_len;          /* Amount of data in the buffer. */
203
 
        xtWord1                                 *sl_buffer;
204
 
 
205
 
        virtual                                 ~XTDataSeqRead() { }
206
 
        virtual xtBool                  sl_seq_init(struct XTDatabase *db, size_t buffer_size);
207
 
        virtual void                    sl_seq_exit();
208
 
        virtual XTOpenFilePtr   sl_seq_open_file();
209
 
        virtual void                    sl_seq_pos(xtLogID *log_id, xtLogOffset *log_offset);
210
 
        virtual xtBool                  sl_seq_start(xtLogID log_id, xtLogOffset log_offset, xtBool missing_ok);
211
 
        virtual xtBool                  sl_rnd_read(xtLogOffset log_offset, size_t size, xtWord1 *data, size_t *read, struct XTThread *thread);
212
 
        virtual xtBool                  sl_seq_next(XTXactLogBufferDPtr *entry, struct XTThread *thread);
213
 
        virtual void                    sl_seq_skip(size_t size);
214
 
        virtual void                    sl_seq_skip_to(off_t offset);
215
 
} XTDataSeqReadRec, *XTDataSeqReadPtr;
216
 
 
217
 
void    xt_dl_delete_ext_data(struct XTThread *self, struct XTTable *tab, xtBool missing_ok, xtBool have_table_lock);
218
 
 
219
 
void    xt_start_compactor(struct XTThread *self, struct XTDatabase *db);
220
 
void    xt_stop_compactor(struct XTThread *self, struct XTDatabase *db);
221
 
 
222
 
void    xt_dl_init_db(struct XTThread *self, struct XTDatabase *db);
223
 
void    xt_dl_exit_db(struct XTThread *self, struct XTDatabase *db);
224
 
void    xt_dl_set_to_delete(struct XTThread *self, struct XTDatabase *db, xtLogID log_id);
225
 
void    xt_dl_log_status(struct XTThread *self, struct XTDatabase *db, XTStringBufferPtr strbuf);
226
 
void    xt_dl_delete_logs(struct XTThread *self, struct XTDatabase *db);
227
 
 
228
 
#endif
229