← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-10-02 14:17:48 UTC
  • mfrom: (1.1.1 upstream)
  • mto: (2.1.17 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20101002141748-m6vbfbfjhrw1153e
Tags: 2010.09.1802-1
* New upstream release.
* Removed pid-file argument hack.
* Updated GPL-2 address to be new address.
* Directly copy in drizzledump.1 since debian doesn't have sphinx 1.0 yet.
* Link to jquery from libjs-jquery. Add it as a depend.
* Add drizzled.8 symlink to the install files.

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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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