Skip to content

M
MariaDB
Commit b72903fe authored by unknown's avatar unknown
Browse files
Options

Maria: 

* merging changes done to the key cache since May 2006 into Maria
* enabling two small enough page cache's unit tests by default
* fix to have non-buffered output in unit tests (to not have a false
timeout killing in pushbuild) (patch given by Serg)
* removing some warnings of gcc -ansi


include/lf.h:
  getting rid of "warning: ISO C does not allow extra `;' outside of a function"
  (gcc -ansi)
mysys/lf_hash.c:
  getting rid of "warning: ISO C does not allow extra `;' outside of a function"
  (gcc -ansi)
mysys/mf_pagecache.c:
  Cosmetic changes to minimize the diff with the key cache.
  #define PAGECACHE_DEBUG_LOG is not needed (just define PAGECACHE_DEBUG
  if you want) (this change removes "warning: 'pagecache_debug_print'
  declared `static' but never defined").
  Importing changes made to mf_keycache.c since May 2006, into the page cache.
  Disabling online resizing in the page cache.
  Fix for "warning: ISO C90 forbids mixed declarations and code".
unittest/mysys/Makefile.am:
  Of the page cache's unit tests, two are small enough to run on pushbuild,
  renaming them to a -t suffix.
unittest/mytap/tap.c:
  pushbuild kills a test after seeing no output from it for 10 minutes;
  so we set the mytap framework to not buffer output (patch given by
  Serg) so that output is seen more frequently and not "all at the end
  of the test".
parent 8993dab5
Show whitespace changes
Inline Side-by-side
Showing with 55 additions and 44 deletions
include/lf.h
View file @ b72903fe
......@@ -80,14 +80,14 @@ void lf_dynarray_destroy(LF_DYNARRAY *array);
nolock_wrap(lf_dynarray_value, void *,
(LF_DYNARRAY *array, uint idx),
(array, idx));
(array, idx))
lock_wrap(lf_dynarray_lvalue, void *,
(LF_DYNARRAY *array, uint idx),
(array, idx),
&array->lock);
&array->lock)
nolock_wrap(lf_dynarray_iterate, int,
(LF_DYNARRAY *array, lf_dynarray_func func, void *arg),
(array, func, arg));
(array, func, arg))
/*
pin manager for memory allocator, lf_alloc-pin.c
......@@ -165,15 +165,15 @@ void lf_pinbox_destroy(LF_PINBOX *pinbox);
lock_wrap(lf_pinbox_get_pins, LF_PINS *,
(LF_PINBOX *pinbox),
(pinbox),
&pinbox->pinstack.lock);
&pinbox->pinstack.lock)
lock_wrap_void(lf_pinbox_put_pins,
(LF_PINS *pins),
(pins),
&pins->pinbox->pinstack.lock);
&pins->pinbox->pinstack.lock)
lock_wrap_void(lf_pinbox_free,
(LF_PINS *pins, void *addr),
(pins, addr),
&pins->pinbox->pinstack.lock);
&pins->pinbox->pinstack.lock)
/*
memory allocator, lf_alloc-pin.c
......@@ -208,7 +208,7 @@ uint lf_alloc_in_pool(LF_ALLOCATOR *allocator);
lock_wrap(lf_alloc_new, void *,
(LF_PINS *pins),
(pins),
&pins->pinbox->pinstack.lock);
&pins->pinbox->pinstack.lock)
/*
extendible hash, lf_hash.c
......
mysys/lf_hash.c
View file @ b72903fe
......@@ -28,7 +28,7 @@
#include <my_bit.h>
#include <lf.h>
LF_REQUIRE_PINS(3);
LF_REQUIRE_PINS(3)
/* An element of the list */
typedef struct {
......
mysys/mf_pagecache.c
View file @ b72903fe
......@@ -43,9 +43,9 @@
#include <pagecache.h>
#include "my_static.h"
#include <m_string.h>
#include <my_bit.h>
#include <errno.h>
#include <stdarg.h>
#include <my_bit.h>
/*
......@@ -86,8 +86,6 @@
#define PAGECACHE_DEBUG_LOG "my_pagecache_debug.log"
*/
#define PAGECACHE_DEBUG_LOG "my_pagecache_debug.log"
/*
In key cache we have external raw locking here we use
SERIALIZED_READ_FROM_CACHE to avoid problem of reading
......@@ -115,14 +113,6 @@
/* TODO: put it to my_static.c */
my_bool my_disable_flush_pagecache_blocks= 0;
#if defined(MSDOS) && !defined(M_IC80386)
/* we nead much memory */
#undef my_malloc_lock
#undef my_free_lock
#define my_malloc_lock(A,B) halloc((long) (A/IO_SIZE),IO_SIZE)
#define my_free_lock(A,B) hfree(A)
#endif /* defined(MSDOS) && !defined(M_IC80386) */
#define STRUCT_PTR(TYPE, MEMBER, a) \
(TYPE *) ((char *) (a) - offsetof(TYPE, MEMBER))
......@@ -314,8 +304,8 @@ my_bool info_check_pin(PAGECACHE_BLOCK_LINK *block,
enum pagecache_page_pin mode)
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ENTER("info_check_pin");
PAGECACHE_PIN_INFO *info= info_find(block->pin_list, thread);
DBUG_ENTER("info_check_pin");
if (info)
{
if (mode == PAGECACHE_PIN_LEFT_UNPINNED)
......@@ -372,10 +362,10 @@ my_bool info_check_lock(PAGECACHE_BLOCK_LINK *block,
enum pagecache_page_pin pin)
{
struct st_my_thread_var *thread= my_thread_var;
DBUG_ENTER("info_check_lock");
PAGECACHE_LOCK_INFO *info=
(PAGECACHE_LOCK_INFO *) info_find((PAGECACHE_PIN_INFO *) block->lock_list,
thread);
DBUG_ENTER("info_check_lock");
switch(lock)
{
case PAGECACHE_LOCK_LEFT_UNLOCKED:
......@@ -605,15 +595,9 @@ uint pagecache_fwrite(PAGECACHE *pagecache,
next_power(value) is 2 at the power of (1+floor(log2(value)));
e.g. next_power(2)=4, next_power(3)=4.
*/
static uint next_power(uint value)
static inline uint next_power(uint value)
{
uint old_value= 1;
while (value)
{
old_value= value;
value&= value-1;
}
return (old_value << 1);
return (uint) my_round_up_to_next_power((uint32) value) << 1;
}
......@@ -834,15 +818,24 @@ int init_pagecache(PAGECACHE *pagecache, my_size_t use_mem,
The function starts the operation only when all other threads
performing operations with the key cache let her to proceed
(when cnt_for_resize=0).
*/
Before being usable, this function needs:
- to receive fixes for BUG#17332 "changing key_buffer_size on a running
server can crash under load" similar to those done to the key cache
- to have us (Sanja) look at the additional constraints placed on
resizing, due to the page locking specific to this page cache.
So we disable it for now.
*/
#if 0 /* keep disabled until code is fixed see above !! */
int resize_pagecache(PAGECACHE *pagecache,
my_size_t use_mem, uint division_limit,
uint age_threshold)
{
int blocks;
#ifdef THREAD
struct st_my_thread_var *thread;
PAGECACHE_WQUEUE *wqueue;
#endif
DBUG_ENTER("resize_pagecache");
if (!pagecache->inited)
......@@ -909,6 +902,7 @@ int resize_pagecache(PAGECACHE *pagecache,
pagecache_pthread_mutex_unlock(&pagecache->cache_lock);
DBUG_RETURN(blocks);
}
#endif /* 0 */
/*
......@@ -1504,8 +1498,12 @@ static inline void remove_reader(PAGECACHE_BLOCK_LINK *block)
{
DBUG_ENTER("remove_reader");
BLOCK_INFO(block);
#ifdef THREAD
if (! --block->hash_link->requests && block->condvar)
pagecache_pthread_cond_signal(block->condvar);
#else
--block->hash_link->requests;
#endif
DBUG_VOID_RETURN;
}
......@@ -1515,7 +1513,8 @@ static inline void remove_reader(PAGECACHE_BLOCK_LINK *block)
signals on its termination
*/
static inline void wait_for_readers(PAGECACHE *pagecache,
static inline void wait_for_readers(PAGECACHE *pagecache
__attribute__((unused)),
PAGECACHE_BLOCK_LINK *block)
{
#ifdef THREAD
......@@ -1684,7 +1683,6 @@ static PAGECACHE_HASH_LINK *get_hash_link(PAGECACHE *pagecache,
{
reg1 PAGECACHE_HASH_LINK *hash_link;
PAGECACHE_HASH_LINK **start;
PAGECACHE_PAGE page;
KEYCACHE_DBUG_PRINT("get_hash_link", ("fd: %u pos: %lu",
(uint) file->file, (ulong) pageno));
......@@ -1710,6 +1708,7 @@ static PAGECACHE_HASH_LINK *get_hash_link(PAGECACHE *pagecache,
#ifdef THREAD
/* Wait for a free hash link */
struct st_my_thread_var *thread= my_thread_var;
PAGECACHE_PAGE page;
KEYCACHE_DBUG_PRINT("get_hash_link", ("waiting"));
page.file= *file;
page.pageno= pageno;
......@@ -2053,8 +2052,10 @@ static PAGECACHE_BLOCK_LINK *find_key_block(PAGECACHE *pagecache,
/* Remove the hash link for this page from the hash table */
unlink_hash(pagecache, block->hash_link);
/* All pending requests for this page must be resubmitted */
#ifdef THREAD
if (block->wqueue[COND_FOR_SAVED].last_thread)
release_queue(&block->wqueue[COND_FOR_SAVED]);
#endif
}
link_to_file_list(pagecache, block, file,
(my_bool)(block->hash_link ? 1 : 0));
......@@ -2209,10 +2210,10 @@ my_bool pagecache_lock_block(PAGECACHE *pagecache,
BLOCK_INFO(block);
while (block->status & BLOCK_WRLOCK)
{
DBUG_PRINT("info", ("fail to lock, waiting..."));
/* Lock failed we will wait */
#ifdef THREAD
struct st_my_thread_var *thread= my_thread_var;
DBUG_PRINT("info", ("fail to lock, waiting..."));
add_to_queue(&block->wqueue[COND_FOR_WRLOCK], thread);
dec_counter_for_resize_op(pagecache);
do
......@@ -2403,8 +2404,10 @@ static void read_block(PAGECACHE *pagecache,
KEYCACHE_DBUG_PRINT("read_block",
("primary request: new page in cache"));
/* Signal that all pending requests for this page now can be processed */
#ifdef THREAD
if (block->wqueue[COND_FOR_REQUESTED].last_thread)
release_queue(&block->wqueue[COND_FOR_REQUESTED]);
#endif
}
else
{
......@@ -3210,9 +3213,11 @@ my_bool pagecache_write(PAGECACHE *pagecache,
block->status= (BLOCK_READ | (block->status & BLOCK_WRLOCK));
KEYCACHE_DBUG_PRINT("key_cache_insert",
("primary request: new page in cache"));
#ifdef THREAD
/* Signal that all pending requests for this now can be processed. */
if (block->wqueue[COND_FOR_REQUESTED].last_thread)
release_queue(&block->wqueue[COND_FOR_REQUESTED]);
#endif
}
}
else
......@@ -3223,11 +3228,9 @@ my_bool pagecache_write(PAGECACHE *pagecache,
if (block->status & BLOCK_CHANGED)
link_to_file_list(pagecache, block, &block->hash_link->file, 1);
}
else
{
if (! (block->status & BLOCK_CHANGED))
else if (! (block->status & BLOCK_CHANGED))
link_to_changed_list(pagecache, block);
}
if (! (block->status & BLOCK_ERROR))
{
bmove512(block->buffer, buff, pagecache->block_size);
......@@ -3342,9 +3345,11 @@ static void free_block(PAGECACHE *pagecache, PAGECACHE_BLOCK_LINK *block)
/* Keep track of the number of currently unused blocks. */
pagecache->blocks_unused++;
#ifdef THREAD
/* All pending requests for this page must be resubmitted. */
if (block->wqueue[COND_FOR_SAVED].last_thread)
release_queue(&block->wqueue[COND_FOR_SAVED]);
#endif
}
......@@ -3438,12 +3443,14 @@ static int flush_cached_blocks(PAGECACHE *pagecache,
if (!last_errno)
last_errno= errno ? errno : -1;
}
#ifdef THREAD
/*
Let to proceed for possible waiting requests to write to the block page.
It might happen only during an operation to resize the key cache.
*/
if (block->wqueue[COND_FOR_SAVED].last_thread)
release_queue(&block->wqueue[COND_FOR_SAVED]);
#endif
/* type will never be FLUSH_IGNORE_CHANGED here */
if (! (type == FLUSH_KEEP || type == FLUSH_FORCE_WRITE))
{
......@@ -3970,7 +3977,6 @@ static void ___pagecache_pthread_mutex_unlock(pthread_mutex_t *mutex)
{
KEYCACHE_THREAD_TRACE_END("");
pthread_mutex_unlock(mutex);
return;
}
......
unittest/mysys/Makefile.am
View file @ b72903fe
......@@ -12,7 +12,7 @@ LDADD = $(top_builddir)/unittest/mytap/libmytap.a \
# but don't run them by default (for this, a non "-t" suffix is used).
# You can run them by hand (how: see "test" target in upper dir).
noinst_PROGRAMS = bitmap-t base64-t my_atomic-t \
mf_pagecache_single_1k-t-big mf_pagecache_single_8k-t-big \
mf_pagecache_single_1k-t mf_pagecache_single_8k-t \
mf_pagecache_single_64k-t-big \
mf_pagecache_consist_1k-t-big mf_pagecache_consist_64k-t-big \
mf_pagecache_consist_1kHC-t-big mf_pagecache_consist_64kHC-t-big \
......@@ -25,11 +25,14 @@ mf_pagecache_single_src = mf_pagecache_single.c $(top_srcdir)/mysys/mf_pagecache
mf_pagecache_consist_src = mf_pagecache_consist.c $(top_srcdir)/mysys/mf_pagecache.c test_file.c test_file.h
mf_pagecache_common_cppflags = -DEXTRA_DEBUG -DPAGECACHE_DEBUG -DMAIN
mf_pagecache_single_1k_t_big_SOURCES = $(mf_pagecache_single_src)
mf_pagecache_single_8k_t_big_SOURCES = $(mf_pagecache_single_src)
# Those two take reasonable resources (<100 MB) for < 1 minute
mf_pagecache_single_1k_t_SOURCES = $(mf_pagecache_single_src)
mf_pagecache_single_8k_t_SOURCES = $(mf_pagecache_single_src)
mf_pagecache_single_1k_t_CPPFLAGS = $(mf_pagecache_common_cppflags) -DPAGE_SIZE=1024
mf_pagecache_single_8k_t_CPPFLAGS = $(mf_pagecache_common_cppflags) -DPAGE_SIZE=8192
# All others below are big
mf_pagecache_single_64k_t_big_SOURCES = $(mf_pagecache_single_src)
mf_pagecache_single_1k_t_big_CPPFLAGS = $(mf_pagecache_common_cppflags) -DPAGE_SIZE=1024
mf_pagecache_single_8k_t_big_CPPFLAGS = $(mf_pagecache_common_cppflags) -DPAGE_SIZE=8192
mf_pagecache_single_64k_t_big_CPPFLAGS = $(mf_pagecache_common_cppflags) -DPAGE_SIZE=65536
mf_pagecache_consist_1k_t_big_SOURCES = $(mf_pagecache_consist_src)
......@@ -52,4 +55,4 @@ mf_pagecache_consist_1kWR_t_big_CPPFLAGS = $(mf_pagecache_common_cppflags) -DPA
mf_pagecache_consist_64kWR_t_big_SOURCES = $(mf_pagecache_consist_src)
mf_pagecache_consist_64kWR_t_big_CPPFLAGS = $(mf_pagecache_common_cppflags) -DPAGE_SIZE=65536 -DTEST_WRITERS
CLEANFILES = my_pagecache_debug.log page_cache_test_file_1
CLEANFILES = pagecache_debug.log page_cache_test_file_1
unittest/mytap/tap.c
View file @ b72903fe
......@@ -150,6 +150,8 @@ static signal_entry install_signal[]= {
void
plan(int const count)
{
setvbuf(tapout, 0, _IONBF, 0); /* provide output at once */
/*
Install signal handler
*/
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7