← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/mf_iocache.c

  • Committer: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/mf_iocache.c
47
47
  write buffer to the read buffer before we start to reuse it.
48
48
*/
49
49
 
 
50
#define MAP_TO_USE_RAID
50
51
#include "mysys_priv.h"
51
52
#include <mystrings/m_string.h>
52
53
#ifdef HAVE_AIOWAIT
53
54
#include "mysys_err.h"
54
 
#include <mysys/aio_result.h>
55
55
static void my_aiowait(my_aio_result *result);
56
56
#endif
57
 
#include <mysys/iocache.h>
58
57
#include <errno.h>
59
 
#include <drizzled/util/test.h>
 
58
 
60
59
#define lock_append_buffer(info) \
61
60
 pthread_mutex_lock(&(info)->append_buffer_lock)
62
61
#define unlock_append_buffer(info) \
222
221
      if (type == SEQ_READ_APPEND)
223
222
        buffer_block *= 2;
224
223
      if ((info->buffer=
225
 
           (unsigned char*) my_malloc(buffer_block,
 
224
           (uchar*) my_malloc(buffer_block,
226
225
                             MYF((cache_myflags & ~ MY_WME) |
227
226
                                 (cachesize == min_cache ? MY_WME : 0)))) != 0)
228
227
      {
328
327
      seek_offset <= my_b_tell(info))
329
328
  {
330
329
    /* Reuse current buffer without flushing it to disk */
331
 
    unsigned char *pos;
 
330
    uchar *pos;
332
331
    if (info->type == WRITE_CACHE && type == READ_CACHE)
333
332
    {
334
333
      info->read_end=info->write_pos;
430
429
    1      Error: can't read requested characters
431
430
*/
432
431
 
433
 
int _my_b_read(register IO_CACHE *info, unsigned char *Buffer, size_t Count)
 
432
int _my_b_read(register IO_CACHE *info, uchar *Buffer, size_t Count)
434
433
{
435
434
  size_t length,diff_length,left_length, max_length;
436
435
  my_off_t pos_in_file;
598
597
*/
599
598
 
600
599
void init_io_cache_share(IO_CACHE *read_cache, IO_CACHE_SHARE *cshare,
601
 
                         IO_CACHE *write_cache, uint32_t num_threads)
 
600
                         IO_CACHE *write_cache, uint num_threads)
602
601
{
603
602
  assert(num_threads > 1);
604
603
  assert(read_cache->type == READ_CACHE);
650
649
void remove_io_thread(IO_CACHE *cache)
651
650
{
652
651
  IO_CACHE_SHARE *cshare= cache->share;
653
 
  uint32_t total;
 
652
  uint total;
654
653
 
655
654
  /* If the writer goes, it needs to flush the write cache. */
656
655
  if (cache == cshare->source_cache)
891
890
    1      Error: can't read requested characters
892
891
*/
893
892
 
894
 
int _my_b_read_r(register IO_CACHE *cache, unsigned char *Buffer, size_t Count)
 
893
int _my_b_read_r(register IO_CACHE *cache, uchar *Buffer, size_t Count)
895
894
{
896
895
  my_off_t pos_in_file;
897
896
  size_t length, diff_length, left_length;
1014
1013
*/
1015
1014
 
1016
1015
static void copy_to_read_buffer(IO_CACHE *write_cache,
1017
 
                                const unsigned char *write_buffer, size_t write_length)
 
1016
                                const uchar *write_buffer, size_t write_length)
1018
1017
{
1019
1018
  IO_CACHE_SHARE *cshare= write_cache->share;
1020
1019
 
1025
1024
  */
1026
1025
  while (write_length)
1027
1026
  {
1028
 
    size_t copy_length= cmin(write_length, write_cache->buffer_length);
 
1027
    size_t copy_length= min(write_length, write_cache->buffer_length);
1029
1028
    int  __attribute__((unused)) rc;
1030
1029
 
1031
1030
    rc= lock_io_cache(write_cache, write_cache->pos_in_file);
1060
1059
    1  Failed to read
1061
1060
*/
1062
1061
 
1063
 
int _my_b_seq_read(register IO_CACHE *info, unsigned char *Buffer, size_t Count)
 
1062
int _my_b_seq_read(register IO_CACHE *info, uchar *Buffer, size_t Count)
1064
1063
{
1065
1064
  size_t length, diff_length, left_length, save_count, max_length;
1066
1065
  my_off_t pos_in_file;
1183
1182
      TODO: figure out if the assert below is needed or correct.
1184
1183
    */
1185
1184
    assert(pos_in_file == info->end_of_file);
1186
 
    copy_len=cmin(Count, len_in_buff);
 
1185
    copy_len=min(Count, len_in_buff);
1187
1186
    memcpy(Buffer, info->append_read_pos, copy_len);
1188
1187
    info->append_read_pos += copy_len;
1189
1188
    Count -= copy_len;
1222
1221
     1          An error has occurred; IO_CACHE to error state.
1223
1222
*/
1224
1223
 
1225
 
int _my_b_async_read(register IO_CACHE *info, unsigned char *Buffer, size_t Count)
 
1224
int _my_b_async_read(register IO_CACHE *info, uchar *Buffer, size_t Count)
1226
1225
{
1227
1226
  size_t length,read_length,diff_length,left_length,use_length,org_Count;
1228
1227
  size_t max_length;
1229
1228
  my_off_t next_pos_in_file;
1230
 
  unsigned char *read_buffer;
 
1229
  uchar *read_buffer;
1231
1230
 
1232
1231
  memcpy(Buffer,info->read_pos,
1233
1232
         (left_length= (size_t) (info->read_end-info->read_pos)));
1285
1284
      }
1286
1285
    }
1287
1286
        /* Copy found bytes to buffer */
1288
 
    length=cmin(Count,read_length);
 
1287
    length=min(Count,read_length);
1289
1288
    memcpy(Buffer,info->read_pos,(size_t) length);
1290
1289
    Buffer+=length;
1291
1290
    Count-=length;
1319
1318
      if ((read_length=my_read(info->file,info->request_pos,
1320
1319
                               read_length, info->myflags)) == (size_t) -1)
1321
1320
        return info->error= -1;
1322
 
      use_length=cmin(Count,read_length);
 
1321
      use_length=min(Count,read_length);
1323
1322
      memcpy(Buffer,info->request_pos,(size_t) use_length);
1324
1323
      info->read_pos=info->request_pos+Count;
1325
1324
      info->read_end=info->request_pos+read_length;
1390
1389
 
1391
1390
int _my_b_get(IO_CACHE *info)
1392
1391
{
1393
 
  unsigned char buff;
 
1392
  uchar buff;
1394
1393
  IO_CACHE_CALLBACK pre_read,post_read;
1395
1394
  if ((pre_read = info->pre_read))
1396
1395
    (*pre_read)(info);
1398
1397
    return my_b_EOF;
1399
1398
  if ((post_read = info->post_read))
1400
1399
    (*post_read)(info);
1401
 
  return (int) (unsigned char) buff;
 
1400
  return (int) (uchar) buff;
1402
1401
}
1403
1402
 
1404
1403
/* 
1411
1410
   -1 On error; my_errno contains error code.
1412
1411
*/
1413
1412
 
1414
 
int _my_b_write(register IO_CACHE *info, const unsigned char *Buffer, size_t Count)
 
1413
int _my_b_write(register IO_CACHE *info, const uchar *Buffer, size_t Count)
1415
1414
{
1416
1415
  size_t rest_length,length;
1417
1416
 
1480
1479
  the write buffer before we are ready with it.
1481
1480
*/
1482
1481
 
1483
 
int my_b_append(register IO_CACHE *info, const unsigned char *Buffer, size_t Count)
 
1482
int my_b_append(register IO_CACHE *info, const uchar *Buffer, size_t Count)
1484
1483
{
1485
1484
  size_t rest_length,length;
1486
1485
 
1524
1523
}
1525
1524
 
1526
1525
 
1527
 
int my_b_safe_write(IO_CACHE *info, const unsigned char *Buffer, size_t Count)
 
1526
int my_b_safe_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
1528
1527
{
1529
1528
  /*
1530
1529
    Sasha: We are not writing this with the ? operator to avoid hitting
1544
1543
  we will never get a seek over the end of the buffer
1545
1544
*/
1546
1545
 
1547
 
int my_block_write(register IO_CACHE *info, const unsigned char *Buffer, size_t Count,
 
1546
int my_block_write(register IO_CACHE *info, const uchar *Buffer, size_t Count,
1548
1547
                   my_off_t pos)
1549
1548
{
1550
1549
  size_t length;
1724
1723
    info->alloced_buffer=0;
1725
1724
    if (info->file != -1)                       /* File doesn't exist */
1726
1725
      error= my_b_flush_io_cache(info,1);
1727
 
    free((unsigned char*) info->buffer);
1728
 
    info->buffer=info->read_pos=(unsigned char*) 0;
 
1726
    my_free((uchar*) info->buffer,MYF(MY_WME));
 
1727
    info->buffer=info->read_pos=(uchar*) 0;
1729
1728
  }
1730
1729
  if (info->type == SEQ_READ_APPEND)
1731
1730
  {
1808
1807
    total_bytes += 4+block_size;
1809
1808
  }
1810
1809
  close_file(&sra_cache);
1811
 
  free(block);
 
1810
  my_free(block,MYF(MY_WME));
1812
1811
  if (!my_stat(fname,&status,MYF(MY_WME)))
1813
1812
    die("%s failed to stat, but I had just closed it,\
1814
1813
 wonder how that happened");