← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/iocache.h

  • Committer: Monty Taylor
  • Date: 2008-10-04 22:26:22 UTC
  • Revision ID: monty@inaugust.com-20081004222622-89vkm3px5b1jujc2
Made sql_state and stacktrace compile as C++. drizzled/ is pure c++ now.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/iocache.h
1
 
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2008 MySQL
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; either version 2 of the License, or
9
 
 *  (at your option) any later version.
10
 
 *
11
 
 *  This program is distributed in the hope that it will be useful,
12
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 *  GNU General Public License for more details.
15
 
 *
16
 
 *  You should have received a copy of the GNU General Public License
17
 
 *  along with this program; if not, write to the Free Software
18
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
 
 */
20
 
 
21
 
#ifndef mysys_iocache_h
22
 
#define mysys_iocache_h
23
 
 
24
 
#include <mysys/my_sys.h>
25
 
 
26
 
#if defined(__cplusplus)
27
 
extern "C" {
28
 
#endif
29
 
 
30
 
struct st_io_cache;
31
 
typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);
32
 
 
33
 
typedef struct st_io_cache_share
34
 
{
35
 
  pthread_mutex_t       mutex;           /* To sync on reads into buffer. */
36
 
  pthread_cond_t        cond;            /* To wait for signals. */
37
 
  pthread_cond_t        cond_writer;     /* For a synchronized writer. */
38
 
  /* Offset in file corresponding to the first byte of buffer. */
39
 
  my_off_t              pos_in_file;
40
 
  /* If a synchronized write cache is the source of the data. */
41
 
  struct st_io_cache    *source_cache;
42
 
  unsigned char                 *buffer;         /* The read buffer. */
43
 
  unsigned char                 *read_end;       /* Behind last valid byte of buffer. */
44
 
  int                   running_threads; /* threads not in lock. */
45
 
  int                   total_threads;   /* threads sharing the cache. */
46
 
  int                   error;           /* Last error. */
47
 
#ifdef NOT_YET_IMPLEMENTED
48
 
  /* whether the structure should be free'd */
49
 
  bool alloced;
50
 
#endif
51
 
} IO_CACHE_SHARE;
52
 
 
53
 
typedef struct st_io_cache    /* Used when cacheing files */
54
 
{
55
 
  /* Offset in file corresponding to the first byte of unsigned char* buffer. */
56
 
  my_off_t pos_in_file;
57
 
  /*
58
 
    The offset of end of file for READ_CACHE and WRITE_CACHE.
59
 
    For SEQ_READ_APPEND it the maximum of the actual end of file and
60
 
    the position represented by read_end.
61
 
  */
62
 
  my_off_t end_of_file;
63
 
  /* Points to current read position in the buffer */
64
 
  unsigned char  *read_pos;
65
 
  /* the non-inclusive boundary in the buffer for the currently valid read */
66
 
  unsigned char  *read_end;
67
 
  unsigned char  *buffer;        /* The read buffer */
68
 
  /* Used in ASYNC_IO */
69
 
  unsigned char  *request_pos;
70
 
 
71
 
  /* Only used in WRITE caches and in SEQ_READ_APPEND to buffer writes */
72
 
  unsigned char  *write_buffer;
73
 
  /*
74
 
    Only used in SEQ_READ_APPEND, and points to the current read position
75
 
    in the write buffer. Note that reads in SEQ_READ_APPEND caches can
76
 
    happen from both read buffer (unsigned char* buffer) and write buffer
77
 
    (unsigned char* write_buffer).
78
 
  */
79
 
  unsigned char *append_read_pos;
80
 
  /* Points to current write position in the write buffer */
81
 
  unsigned char *write_pos;
82
 
  /* The non-inclusive boundary of the valid write area */
83
 
  unsigned char *write_end;
84
 
 
85
 
  /*
86
 
    Current_pos and current_end are convenience variables used by
87
 
    my_b_tell() and other routines that need to know the current offset
88
 
    current_pos points to &write_pos, and current_end to &write_end in a
89
 
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise
90
 
  */
91
 
  unsigned char  **current_pos, **current_end;
92
 
  /*
93
 
    The lock is for append buffer used in SEQ_READ_APPEND cache
94
 
    need mutex copying from append buffer to read buffer.
95
 
  */
96
 
  pthread_mutex_t append_buffer_lock;
97
 
  /*
98
 
    The following is used when several threads are reading the
99
 
    same file in parallel. They are synchronized on disk
100
 
    accesses reading the cached part of the file asynchronously.
101
 
    It should be set to NULL to disable the feature.  Only
102
 
    READ_CACHE mode is supported.
103
 
  */
104
 
  IO_CACHE_SHARE *share;
105
 
  /*
106
 
    A caller will use my_b_read() macro to read from the cache
107
 
    if the data is already in cache, it will be simply copied with
108
 
    memcpy() and internal variables will be accordinging updated with
109
 
    no functions invoked. However, if the data is not fully in the cache,
110
 
    my_b_read() will call read_function to fetch the data. read_function
111
 
    must never be invoked directly.
112
 
  */
113
 
  int (*read_function)(struct st_io_cache *,unsigned char *,size_t);
114
 
  /*
115
 
    Same idea as in the case of read_function, except my_b_write() needs to
116
 
    be replaced with my_b_append() for a SEQ_READ_APPEND cache
117
 
  */
118
 
  int (*write_function)(struct st_io_cache *,const unsigned char *,size_t);
119
 
  /*
120
 
    Specifies the type of the cache. Depending on the type of the cache
121
 
    certain operations might not be available and yield unpredicatable
122
 
    results. Details to be documented later
123
 
  */
124
 
  enum cache_type type;
125
 
  /*
126
 
    Callbacks when the actual read I/O happens. These were added and
127
 
    are currently used for binary logging of LOAD DATA INFILE - when a
128
 
    block is read from the file, we create a block create/append event, and
129
 
    when IO_CACHE is closed, we create an end event. These functions could,
130
 
    of course be used for other things
131
 
  */
132
 
  IO_CACHE_CALLBACK pre_read;
133
 
  IO_CACHE_CALLBACK post_read;
134
 
  IO_CACHE_CALLBACK pre_close;
135
 
  /*
136
 
    Counts the number of times, when we were forced to use disk. We use it to
137
 
    increase the binlog_cache_disk_use status variable.
138
 
  */
139
 
  uint32_t disk_writes;
140
 
  void* arg;        /* for use by pre/post_read */
141
 
  char *file_name;      /* if used with 'open_cached_file' */
142
 
  char *dir,*prefix;
143
 
  File file; /* file descriptor */
144
 
  /*
145
 
    seek_not_done is set by my_b_seek() to inform the upcoming read/write
146
 
    operation that a seek needs to be preformed prior to the actual I/O
147
 
    error is 0 if the cache operation was successful, -1 if there was a
148
 
    "hard" error, and the actual number of I/O-ed bytes if the read/write was
149
 
    partial.
150
 
  */
151
 
  int  seek_not_done,error;
152
 
  /* buffer_length is memory size allocated for buffer or write_buffer */
153
 
  size_t  buffer_length;
154
 
  /* read_length is the same as buffer_length except when we use async io */
155
 
  size_t  read_length;
156
 
  myf  myflags;      /* Flags used to my_read/my_write */
157
 
  /*
158
 
    alloced_buffer is 1 if the buffer was allocated by init_io_cache() and
159
 
    0 if it was supplied by the user.
160
 
    Currently READ_NET is the only one that will use a buffer allocated
161
 
    somewhere else
162
 
  */
163
 
  bool alloced_buffer;
164
 
#ifdef HAVE_AIOWAIT
165
 
  /*
166
 
    As inidicated by ifdef, this is for async I/O, which is not currently
167
 
    used (because it's not reliable on all systems)
168
 
  */
169
 
  uint32_t inited;
170
 
  my_off_t aio_read_pos;
171
 
  my_aio_result aio_result;
172
 
#endif
173
 
} IO_CACHE;
174
 
 
175
 
/* tell write offset in the SEQ_APPEND cache */
176
 
int      my_b_copy_to_file(IO_CACHE *cache, FILE *file);
177
 
my_off_t my_b_append_tell(IO_CACHE* info);
178
 
my_off_t my_b_safe_tell(IO_CACHE* info); /* picks the correct tell() */
179
 
 
180
 
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,
181
 
                         enum cache_type type,my_off_t seek_offset,
182
 
                         bool use_async_io, myf cache_myflags);
183
 
extern bool reinit_io_cache(IO_CACHE *info,enum cache_type type,
184
 
                            my_off_t seek_offset,bool use_async_io,
185
 
                            bool clear_cache);
186
 
extern void setup_io_cache(IO_CACHE* info);
187
 
extern int _my_b_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
188
 
extern int _my_b_read_r(IO_CACHE *info,unsigned char *Buffer,size_t Count);
189
 
extern void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
190
 
                                IO_CACHE *write_cache, uint32_t num_threads);
191
 
extern void remove_io_thread(IO_CACHE *info);
192
 
extern int _my_b_seq_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
193
 
extern int _my_b_get(IO_CACHE *info);
194
 
extern int _my_b_async_read(IO_CACHE *info,unsigned char *Buffer,size_t Count);
195
 
extern int _my_b_write(IO_CACHE *info,const unsigned char *Buffer,
196
 
                       size_t Count);
197
 
extern int my_b_append(IO_CACHE *info,const unsigned char *Buffer,
198
 
                       size_t Count);
199
 
extern int my_b_safe_write(IO_CACHE *info,const unsigned char *Buffer,
200
 
                           size_t Count);
201
 
 
202
 
extern int my_block_write(IO_CACHE *info, const unsigned char *Buffer,
203
 
                          size_t Count, my_off_t pos);
204
 
extern int my_b_flush_io_cache(IO_CACHE *info, int need_append_buffer_lock);
205
 
 
206
 
#define flush_io_cache(info) my_b_flush_io_cache((info),1)
207
 
 
208
 
extern int end_io_cache(IO_CACHE *info);
209
 
extern size_t my_b_fill(IO_CACHE *info);
210
 
extern void my_b_seek(IO_CACHE *info,my_off_t pos);
211
 
extern size_t my_b_gets(IO_CACHE *info, char *to, size_t max_length);
212
 
extern my_off_t my_b_filelength(IO_CACHE *info);
213
 
extern size_t my_b_printf(IO_CACHE *info, const char* fmt, ...);
214
 
extern size_t my_b_vprintf(IO_CACHE *info, const char* fmt, va_list ap);
215
 
extern bool open_cached_file(IO_CACHE *cache,const char *dir,
216
 
                             const char *prefix, size_t cache_size,
217
 
                             myf cache_myflags);
218
 
extern bool real_open_cached_file(IO_CACHE *cache);
219
 
extern void close_cached_file(IO_CACHE *cache);
220
 
 
221
 
#if defined(__cplusplus)
222
 
}
223
 
#endif
224
 
 
225
 
#endif