Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

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
pull/374/head
unknown 18 years ago
parent
ba0cd51eb1 2b8748ca6e
commit
bc8d42f96d
8 changed files with 64 additions and 67 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      include/keycache.h
  2. 3
      include/my_global.h
  3. 26
      include/my_sys.h
  4. 25
      mysys/mf_keycache.c
  5. 12
      mysys/my_largepage.c
  6. 16
      mysys/my_malloc.c
  7. 27
      mysys/safemalloc.c
  8. 12
      sql/mysqld.cc

10
include/keycache.h
View File

@ -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,

3
include/my_global.h
View File

@ -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)

26
include/my_sys.h
View File

@ -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);

25
mysys/mf_keycache.c
View File

@ -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;

12
mysys/my_largepage.c
View File

@ -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);
}

16
mysys/my_malloc.c
View File

@ -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);

27
mysys/safemalloc.c
View File

@ -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)

12
sql/mysqld.cc
View File

@ -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,

Write Preview
Loading…
Cancel
Save