Merge polly.(none):/home/kaa/src/maint/bug5731/my50-bug5731
into polly.(none):/home/kaa/src/maint/mysql-5.0-maint sql/mysqld.cc: Auto merged
This commit is contained in:
commit
bc8d42f96d
@ -46,7 +46,7 @@ typedef struct st_key_cache
|
||||
my_bool key_cache_inited;
|
||||
my_bool resize_in_flush; /* true during flush of resize operation */
|
||||
my_bool can_be_used; /* usage of cache for read/write is allowed */
|
||||
ulong key_cache_mem_size; /* specified size of the cache memory */
|
||||
size_t key_cache_mem_size; /* specified size of the cache memory */
|
||||
uint key_cache_block_size; /* size of the page buffer of a cache block */
|
||||
ulong min_warm_blocks; /* min number of warm blocks; */
|
||||
ulong age_threshold; /* age threshold for hot blocks */
|
||||
@ -101,11 +101,11 @@ typedef struct st_key_cache
|
||||
extern KEY_CACHE dflt_key_cache_var, *dflt_key_cache;
|
||||
|
||||
extern int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
|
||||
ulong use_mem, uint division_limit,
|
||||
uint age_threshold);
|
||||
size_t use_mem, uint division_limit,
|
||||
uint age_threshold);
|
||||
extern int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
|
||||
ulong use_mem, uint division_limit,
|
||||
uint age_threshold);
|
||||
size_t use_mem, uint division_limit,
|
||||
uint age_threshold);
|
||||
extern void change_key_cache_param(KEY_CACHE *keycache, uint division_limit,
|
||||
uint age_threshold);
|
||||
extern byte *key_cache_read(KEY_CACHE *keycache,
|
||||
|
@ -780,9 +780,6 @@ typedef SOCKET_SIZE_TYPE size_socket;
|
||||
#define DBL_MAX 1.79769313486231470e+308
|
||||
#define FLT_MAX ((float)3.40282346638528860e+38)
|
||||
#endif
|
||||
#ifndef SSIZE_MAX
|
||||
#define SSIZE_MAX ((~((size_t) 0)) / 2)
|
||||
#endif
|
||||
|
||||
#ifndef HAVE_FINITE
|
||||
#define finite(x) (1.0 / fabs(x) > 0.0)
|
||||
|
@ -147,14 +147,14 @@ extern ulonglong sf_malloc_mem_limit;
|
||||
#define TERMINATE(A) {}
|
||||
#define QUICK_SAFEMALLOC
|
||||
#define NORMAL_SAFEMALLOC
|
||||
extern gptr my_malloc(uint Size,myf MyFlags);
|
||||
extern gptr my_malloc(size_t Size, myf MyFlags);
|
||||
#define my_malloc_ci(SZ,FLAG) my_malloc( SZ, FLAG )
|
||||
extern gptr my_realloc(gptr oldpoint,uint Size,myf MyFlags);
|
||||
extern void my_no_flags_free(gptr ptr);
|
||||
extern gptr my_memdup(const byte *from,uint length,myf MyFlags);
|
||||
extern gptr my_memdup(const byte *from, size_t length, myf MyFlags);
|
||||
extern char *my_strdup(const char *from,myf MyFlags);
|
||||
extern char *my_strdup_with_length(const char *from, uint length,
|
||||
myf MyFlags);
|
||||
extern char *my_strdup_with_length(const char *from, size_t length,
|
||||
myf MyFlags);
|
||||
/* we do use FG (as a no-op) in below so that a typo on FG is caught */
|
||||
#define my_free(PTR,FG) ((void)FG,my_no_flags_free(PTR))
|
||||
#define CALLER_INFO_PROTO /* nothing */
|
||||
@ -165,7 +165,7 @@ extern char *my_strdup_with_length(const char *from, uint length,
|
||||
|
||||
#ifdef HAVE_LARGE_PAGES
|
||||
extern uint my_get_large_page_size(void);
|
||||
extern gptr my_large_malloc(uint size, myf my_flags);
|
||||
extern gptr my_large_malloc(size_t size, myf my_flags);
|
||||
extern void my_large_free(gptr ptr, myf my_flags);
|
||||
#else
|
||||
#define my_get_large_page_size() (0)
|
||||
@ -590,18 +590,18 @@ extern uint my_fwrite(FILE *stream,const byte *Buffer,uint Count,
|
||||
myf MyFlags);
|
||||
extern my_off_t my_fseek(FILE *stream,my_off_t pos,int whence,myf MyFlags);
|
||||
extern my_off_t my_ftell(FILE *stream,myf MyFlags);
|
||||
extern gptr _mymalloc(uint uSize,const char *sFile,
|
||||
uint uLine, myf MyFlag);
|
||||
extern gptr _myrealloc(gptr pPtr,uint uSize,const char *sFile,
|
||||
uint uLine, myf MyFlag);
|
||||
extern gptr _mymalloc(size_t uSize, const char *sFile,
|
||||
uint uLine, myf MyFlag);
|
||||
extern gptr _myrealloc(gptr pPtr, size_t uSize, const char *sFile,
|
||||
uint uLine, myf MyFlag);
|
||||
extern gptr my_multi_malloc _VARARGS((myf MyFlags, ...));
|
||||
extern void _myfree(gptr pPtr,const char *sFile,uint uLine, myf MyFlag);
|
||||
extern void _myfree(gptr pPtr, const char *sFile, uint uLine, myf MyFlag);
|
||||
extern int _sanity(const char *sFile,unsigned int uLine);
|
||||
extern gptr _my_memdup(const byte *from,uint length,
|
||||
const char *sFile, uint uLine,myf MyFlag);
|
||||
extern gptr _my_memdup(const byte *from, size_t length,
|
||||
const char *sFile, uint uLine, myf MyFlag);
|
||||
extern my_string _my_strdup(const char *from, const char *sFile, uint uLine,
|
||||
myf MyFlag);
|
||||
extern char *_my_strdup_with_length(const char *from, uint length,
|
||||
extern char *_my_strdup_with_length(const char *from, size_t length,
|
||||
const char *sFile, uint uLine,
|
||||
myf MyFlag);
|
||||
|
||||
|
@ -301,10 +301,11 @@ static uint next_power(uint value)
|
||||
*/
|
||||
|
||||
int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
|
||||
ulong use_mem, uint division_limit,
|
||||
uint age_threshold)
|
||||
size_t use_mem, uint division_limit,
|
||||
uint age_threshold)
|
||||
{
|
||||
uint blocks, hash_links, length;
|
||||
ulong blocks, hash_links;
|
||||
size_t length;
|
||||
int error;
|
||||
DBUG_ENTER("init_key_cache");
|
||||
DBUG_ASSERT(key_cache_block_size >= 512);
|
||||
@ -332,8 +333,8 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
|
||||
DBUG_PRINT("info", ("key_cache_block_size: %u",
|
||||
key_cache_block_size));
|
||||
|
||||
blocks= (uint) (use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) +
|
||||
sizeof(HASH_LINK*) * 5/4 + key_cache_block_size));
|
||||
blocks= (ulong) (use_mem / (sizeof(BLOCK_LINK) + 2 * sizeof(HASH_LINK) +
|
||||
sizeof(HASH_LINK*) * 5/4 + key_cache_block_size));
|
||||
/* It doesn't make sense to have too few blocks (less than 8) */
|
||||
if (blocks >= 8 && keycache->disk_blocks < 0)
|
||||
{
|
||||
@ -351,18 +352,18 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
|
||||
ALIGN_SIZE(hash_links * sizeof(HASH_LINK)) +
|
||||
ALIGN_SIZE(sizeof(HASH_LINK*) *
|
||||
keycache->hash_entries))) +
|
||||
((ulong) blocks * keycache->key_cache_block_size) > use_mem)
|
||||
((size_t) blocks * keycache->key_cache_block_size) > use_mem)
|
||||
blocks--;
|
||||
/* Allocate memory for cache page buffers */
|
||||
if ((keycache->block_mem=
|
||||
my_large_malloc((ulong) blocks * keycache->key_cache_block_size,
|
||||
MYF(MY_WME))))
|
||||
my_large_malloc((size_t) blocks * keycache->key_cache_block_size,
|
||||
MYF(MY_WME))))
|
||||
{
|
||||
/*
|
||||
Allocate memory for blocks, hash_links and hash entries;
|
||||
For each block 2 hash links are allocated
|
||||
*/
|
||||
if ((keycache->block_root= (BLOCK_LINK*) my_malloc((uint) length,
|
||||
if ((keycache->block_root= (BLOCK_LINK*) my_malloc(length,
|
||||
MYF(0))))
|
||||
break;
|
||||
my_large_free(keycache->block_mem, MYF(0));
|
||||
@ -375,7 +376,7 @@ int init_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
|
||||
}
|
||||
blocks= blocks / 4*3;
|
||||
}
|
||||
keycache->blocks_unused= (ulong) blocks;
|
||||
keycache->blocks_unused= blocks;
|
||||
keycache->disk_blocks= (int) blocks;
|
||||
keycache->hash_links= hash_links;
|
||||
keycache->hash_root= (HASH_LINK**) ((char*) keycache->block_root +
|
||||
@ -480,8 +481,8 @@ err:
|
||||
*/
|
||||
|
||||
int resize_key_cache(KEY_CACHE *keycache, uint key_cache_block_size,
|
||||
ulong use_mem, uint division_limit,
|
||||
uint age_threshold)
|
||||
size_t use_mem, uint division_limit,
|
||||
uint age_threshold)
|
||||
{
|
||||
int blocks;
|
||||
struct st_my_thread_var *thread;
|
||||
|
@ -26,7 +26,7 @@
|
||||
#endif
|
||||
|
||||
static uint my_get_large_page_size_int(void);
|
||||
static gptr my_large_malloc_int(uint size, myf my_flags);
|
||||
static gptr my_large_malloc_int(size_t size, myf my_flags);
|
||||
static my_bool my_large_free_int(gptr ptr, myf my_flags);
|
||||
|
||||
/* Gets the size of large pages from the OS */
|
||||
@ -48,7 +48,7 @@ uint my_get_large_page_size(void)
|
||||
my_malloc_lock() in case of failure
|
||||
*/
|
||||
|
||||
gptr my_large_malloc(uint size, myf my_flags)
|
||||
gptr my_large_malloc(size_t size, myf my_flags)
|
||||
{
|
||||
gptr ptr;
|
||||
DBUG_ENTER("my_large_malloc");
|
||||
@ -113,7 +113,7 @@ finish:
|
||||
#if HAVE_DECL_SHM_HUGETLB
|
||||
/* Linux-specific large pages allocator */
|
||||
|
||||
gptr my_large_malloc_int(uint size, myf my_flags)
|
||||
gptr my_large_malloc_int(size_t size, myf my_flags)
|
||||
{
|
||||
int shmid;
|
||||
gptr ptr;
|
||||
@ -123,13 +123,13 @@ gptr my_large_malloc_int(uint size, myf my_flags)
|
||||
/* Align block size to my_large_page_size */
|
||||
size = ((size - 1) & ~(my_large_page_size - 1)) + my_large_page_size;
|
||||
|
||||
shmid = shmget(IPC_PRIVATE, (size_t)size, SHM_HUGETLB | SHM_R | SHM_W);
|
||||
shmid = shmget(IPC_PRIVATE, size, SHM_HUGETLB | SHM_R | SHM_W);
|
||||
if (shmid < 0)
|
||||
{
|
||||
if (my_flags & MY_WME)
|
||||
fprintf(stderr,
|
||||
"Warning: Failed to allocate %d bytes from HugeTLB memory."
|
||||
" errno %d\n", size, errno);
|
||||
"Warning: Failed to allocate %lu bytesx from HugeTLB memory."
|
||||
" errno %d\n", (ulong) size, errno);
|
||||
|
||||
DBUG_RETURN(NULL);
|
||||
}
|
||||
|
@ -23,11 +23,11 @@
|
||||
|
||||
/* My memory allocator */
|
||||
|
||||
gptr my_malloc(unsigned int size, myf my_flags)
|
||||
gptr my_malloc(size_t size, myf my_flags)
|
||||
{
|
||||
gptr point;
|
||||
DBUG_ENTER("my_malloc");
|
||||
DBUG_PRINT("my",("size: %u my_flags: %d",size, my_flags));
|
||||
DBUG_PRINT("my",("size: %lu my_flags: %d", (ulong) size, my_flags));
|
||||
|
||||
if (!size)
|
||||
size=1; /* Safety */
|
||||
@ -63,11 +63,11 @@ void my_no_flags_free(gptr ptr)
|
||||
|
||||
/* malloc and copy */
|
||||
|
||||
gptr my_memdup(const byte *from, uint length, myf my_flags)
|
||||
gptr my_memdup(const byte *from, size_t length, myf my_flags)
|
||||
{
|
||||
gptr ptr;
|
||||
if ((ptr=my_malloc(length,my_flags)) != 0)
|
||||
memcpy((byte*) ptr, (byte*) from,(size_t) length);
|
||||
memcpy((byte*) ptr, (byte*)from, length);
|
||||
return(ptr);
|
||||
}
|
||||
|
||||
@ -75,19 +75,19 @@ gptr my_memdup(const byte *from, uint length, myf my_flags)
|
||||
char *my_strdup(const char *from, myf my_flags)
|
||||
{
|
||||
gptr ptr;
|
||||
uint length=(uint) strlen(from)+1;
|
||||
size_t length= strlen(from)+1;
|
||||
if ((ptr=my_malloc(length,my_flags)) != 0)
|
||||
memcpy((byte*) ptr, (byte*) from,(size_t) length);
|
||||
memcpy((byte*) ptr, (byte*) from, length);
|
||||
return((my_string) ptr);
|
||||
}
|
||||
|
||||
|
||||
char *my_strdup_with_length(const char *from, uint length, myf my_flags)
|
||||
char *my_strdup_with_length(const char *from, size_t length, myf my_flags)
|
||||
{
|
||||
gptr ptr;
|
||||
if ((ptr=my_malloc(length+1,my_flags)) != 0)
|
||||
{
|
||||
memcpy((byte*) ptr, (byte*) from,(size_t) length);
|
||||
memcpy((byte*) ptr, (byte*) from, length);
|
||||
((char*) ptr)[length]=0;
|
||||
}
|
||||
return((char*) ptr);
|
||||
|
@ -119,12 +119,12 @@ static int _checkchunk(struct st_irem *pRec, const char *sFile, uint uLine);
|
||||
|
||||
/* Allocate some memory. */
|
||||
|
||||
gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
|
||||
gptr _mymalloc(size_t size, const char *filename, uint lineno, myf MyFlags)
|
||||
{
|
||||
struct st_irem *irem;
|
||||
char *data;
|
||||
DBUG_ENTER("_mymalloc");
|
||||
DBUG_PRINT("enter",("Size: %u",size));
|
||||
DBUG_PRINT("enter",("Size: %lu", (ulong) size));
|
||||
|
||||
if (!sf_malloc_quick)
|
||||
(void) _sanity (filename, lineno);
|
||||
@ -151,8 +151,8 @@ gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
|
||||
my_errno=errno;
|
||||
sprintf(buff,"Out of memory at line %d, '%s'", lineno, filename);
|
||||
my_message(EE_OUTOFMEMORY, buff, MYF(ME_BELL+ME_WAITTANG+ME_NOREFRESH));
|
||||
sprintf(buff,"needed %d byte (%ldk), memory in use: %ld bytes (%ldk)",
|
||||
size, (size + 1023L) / 1024L,
|
||||
sprintf(buff,"needed %u byte (%ldk), memory in use: %ld bytes (%ldk)",
|
||||
(uint) size, (uint) (size + 1023L) / 1024L,
|
||||
sf_malloc_max_memory, (sf_malloc_max_memory + 1023L) / 1024L);
|
||||
my_message(EE_OUTOFMEMORY, buff, MYF(ME_BELL+ME_WAITTANG+ME_NOREFRESH));
|
||||
}
|
||||
@ -207,8 +207,8 @@ gptr _mymalloc(uint size, const char *filename, uint lineno, myf MyFlags)
|
||||
Free then old memoryblock
|
||||
*/
|
||||
|
||||
gptr _myrealloc(register gptr ptr, register uint size,
|
||||
const char *filename, uint lineno, myf MyFlags)
|
||||
gptr _myrealloc(register gptr ptr, register size_t size,
|
||||
const char *filename, uint lineno, myf MyFlags)
|
||||
{
|
||||
struct st_irem *irem;
|
||||
char *data;
|
||||
@ -373,8 +373,7 @@ void TERMINATE(FILE *file)
|
||||
{
|
||||
if (file)
|
||||
{
|
||||
fprintf(file, "Warning: Not freed memory segments: %u\n",
|
||||
sf_malloc_count);
|
||||
fprintf(file, "Warning: Not freed memory segments: %u\n", sf_malloc_count);
|
||||
(void) fflush(file);
|
||||
}
|
||||
DBUG_PRINT("safe",("sf_malloc_count: %u", sf_malloc_count));
|
||||
@ -503,8 +502,8 @@ int _sanity(const char *filename, uint lineno)
|
||||
|
||||
/* malloc and copy */
|
||||
|
||||
gptr _my_memdup(const byte *from, uint length, const char *filename,
|
||||
uint lineno, myf MyFlags)
|
||||
gptr _my_memdup(const byte *from, size_t length, const char *filename,
|
||||
uint lineno, myf MyFlags)
|
||||
{
|
||||
gptr ptr;
|
||||
if ((ptr=_mymalloc(length,filename,lineno,MyFlags)) != 0)
|
||||
@ -517,16 +516,16 @@ char *_my_strdup(const char *from, const char *filename, uint lineno,
|
||||
myf MyFlags)
|
||||
{
|
||||
gptr ptr;
|
||||
uint length=(uint) strlen(from)+1;
|
||||
size_t length= strlen(from)+1;
|
||||
if ((ptr=_mymalloc(length,filename,lineno,MyFlags)) != 0)
|
||||
memcpy((byte*) ptr, (byte*) from,(size_t) length);
|
||||
return((char*) ptr);
|
||||
} /* _my_strdup */
|
||||
|
||||
|
||||
char *_my_strdup_with_length(const char *from, uint length,
|
||||
const char *filename, uint lineno,
|
||||
myf MyFlags)
|
||||
char *_my_strdup_with_length(const char *from, size_t length,
|
||||
const char *filename, uint lineno,
|
||||
myf MyFlags)
|
||||
{
|
||||
gptr ptr;
|
||||
if ((ptr=_mymalloc(length+1,filename,lineno,MyFlags)) != 0)
|
||||
|
@ -5848,7 +5848,7 @@ log and this option does nothing anymore.",
|
||||
"The size of the buffer that is used for full joins.",
|
||||
(gptr*) &global_system_variables.join_buff_size,
|
||||
(gptr*) &max_system_variables.join_buff_size, 0, GET_ULONG,
|
||||
REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, ~0L, MALLOC_OVERHEAD,
|
||||
REQUIRED_ARG, 128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, UINT_MAX32, MALLOC_OVERHEAD,
|
||||
IO_SIZE, 0},
|
||||
{"keep_files_on_create", OPT_KEEP_FILES_ON_CREATE,
|
||||
"Don't overwrite stale .MYD and .MYI even if no directory is specified.",
|
||||
@ -6017,7 +6017,7 @@ The minimum value for this variable is 4096.",
|
||||
"The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE.",
|
||||
(gptr*) &global_system_variables.myisam_sort_buff_size,
|
||||
(gptr*) &max_system_variables.myisam_sort_buff_size, 0,
|
||||
GET_ULONG, REQUIRED_ARG, 8192*1024, 4, ~0L, 0, 1, 0},
|
||||
GET_ULONG, REQUIRED_ARG, 8192*1024, 4, UINT_MAX32, 0, 1, 0},
|
||||
{"myisam_stats_method", OPT_MYISAM_STATS_METHOD,
|
||||
"Specifies how MyISAM index statistics collection code should threat NULLs. "
|
||||
"Possible values of name are \"nulls_unequal\" (default behavior for 4.1/5.0), "
|
||||
@ -6110,7 +6110,7 @@ The minimum value for this variable is 4096.",
|
||||
"Each thread that does a sequential scan allocates a buffer of this size for each table it scans. If you do many sequential scans, you may want to increase this value.",
|
||||
(gptr*) &global_system_variables.read_buff_size,
|
||||
(gptr*) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
|
||||
128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, SSIZE_MAX, MALLOC_OVERHEAD, IO_SIZE,
|
||||
128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE,
|
||||
0},
|
||||
{"read_only", OPT_READONLY,
|
||||
"Make all non-temporary tables read-only, with the exception for replication (slave) threads and users with the SUPER privilege",
|
||||
@ -6122,12 +6122,12 @@ The minimum value for this variable is 4096.",
|
||||
(gptr*) &global_system_variables.read_rnd_buff_size,
|
||||
(gptr*) &max_system_variables.read_rnd_buff_size, 0,
|
||||
GET_ULONG, REQUIRED_ARG, 256*1024L, IO_SIZE*2+MALLOC_OVERHEAD,
|
||||
SSIZE_MAX, MALLOC_OVERHEAD, IO_SIZE, 0},
|
||||
INT_MAX32, MALLOC_OVERHEAD, IO_SIZE, 0},
|
||||
{"record_buffer", OPT_RECORD_BUFFER,
|
||||
"Alias for read_buffer_size",
|
||||
(gptr*) &global_system_variables.read_buff_size,
|
||||
(gptr*) &max_system_variables.read_buff_size,0, GET_ULONG, REQUIRED_ARG,
|
||||
128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, SSIZE_MAX, MALLOC_OVERHEAD, IO_SIZE, 0},
|
||||
128*1024L, IO_SIZE*2+MALLOC_OVERHEAD, INT_MAX32, MALLOC_OVERHEAD, IO_SIZE, 0},
|
||||
#ifdef HAVE_REPLICATION
|
||||
{"relay_log_purge", OPT_RELAY_LOG_PURGE,
|
||||
"0 = do not purge relay logs. 1 = purge them as soon as they are no more needed.",
|
||||
@ -6163,7 +6163,7 @@ The minimum value for this variable is 4096.",
|
||||
"Each thread that needs to do a sort allocates a buffer of this size.",
|
||||
(gptr*) &global_system_variables.sortbuff_size,
|
||||
(gptr*) &max_system_variables.sortbuff_size, 0, GET_ULONG, REQUIRED_ARG,
|
||||
MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, ~0L, MALLOC_OVERHEAD,
|
||||
MAX_SORT_MEMORY, MIN_SORT_MEMORY+MALLOC_OVERHEAD*2, UINT_MAX32, MALLOC_OVERHEAD,
|
||||
1, 0},
|
||||
#ifdef HAVE_BERKELEY_DB
|
||||
{"sync-bdb-logs", OPT_BDB_SYNC,
|
||||
|
Loading…
x
Reference in New Issue
Block a user