mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 12:32:27 +01:00
ce8de7afdf
-new option WITH_MARIA_STORAGE_ENGINE for config.js -correct build errors -build test executables -downport changes for atomic functions from 5.2 -remove LOCK_uuid_generator from C++ files to avoid linker errors -new function my_uuid2str() BitKeeper/deleted/.del-x86-msvc.h: Delete: include/atomic/x86-msvc.h CMakeLists.txt: Windows fixes: -New option WITH_MARIA_STORAGE_ENGINE -Add unit tests include/Makefile.am: replace x86-msvc.h with generic-msvc.h include/config-win.h: my_chmod() support include/my_atomic.h: Downport my_atomic from 5.2 tree include/my_bit.h: Correct unresolved symbol errors on Windows include/my_pthread.h: pthread_mutex_unlock now returns 0 (was void previously) defined PTHREAD_STACK_MIN include/my_sys.h: New function my_uuid2str() define MY_UUID_STRING_LENGTH include/atomic/nolock.h: Downport my_atomic from 5.2 tree libmysqld/CMakeLists.txt: New option WITH_MARIA_STORAGE_ENGINE mysys/CMakeLists.txt: Add missing files mysys/lf_dynarray.c: Fix compiler errors on Windows mysys/my_getncpus.c: Windows port mysys/my_uuid.c: Windows fixes: there is no random() on Windows, use ANSI rand() New function my_uuid2str() mysys/my_winthread.c: Downport from 5.2 tree -Call my_thread_end() before pthread_exit() -Avoid crash if pthread_create is called with NULL attributes sql/CMakeLists.txt: Link mysqld with Maria storage engine sql/item_func.cc: Remove LOCK_uuid_generator from C++ to avoid linker errors. Use dedicated mutex for short uuids sql/item_strfunc.cc: Use my_uuid() and my_uuid2str() functions from mysys. sql/item_strfunc.h: Define MY_UUID_STRING_LENGTH in my_sys.h sql/mysql_priv.h: LOCK_uuid_generator must be declared as extern "C" sql/mysqld.cc: Init and destroy LOCK_uuid_short mutex storage/maria/CMakeLists.txt: -Use the same source files as in Makefile.am -Build test binaries storage/maria/ha_maria.cc: snprintf->my_snprintf storage/maria/lockman.c: Fix compiler error on Windows storage/maria/ma_check.c: Fix compiler error on Windows storage/maria/ma_loghandler.c: Fix compile errors my_open()/my_sync() do not work for directories on Windows storage/maria/ma_recovery.c: Fix compile error on Windows storage/maria/ma_test2.c: Rename variable to avoid naming conflict with Microsoft C runtime function storage/maria/ma_test3.c: Fix build errors on Windows storage/maria/tablockman.c: Fix build errors on Windows storage/maria/unittest/Makefile.am: Add CMakeLists.txt storage/maria/unittest/ma_pagecache_consist.c: Fix build errors on Windows remove loop from get_len() storage/maria/unittest/ma_pagecache_single.c: Fix build errors on Windows storage/maria/unittest/ma_test_loghandler-t.c: Windows fixes -Avoid division by 0 in expressions like x/(RAND_MAX/y), where y is larger than RAND_MAX(==0x7fff on Windows) storage/maria/unittest/ma_test_loghandler_multigroup-t.c: Windows fixes -Avoid division by 0 in expressions like x/(RAND_MAX/y), where y is larger than RAND_MAX(==0x7fff on Windows) -remove loop in get_len() storage/maria/unittest/ma_test_loghandler_multithread-t.c: Windows fixes -Avoid division by 0 in expressions like x/(RAND_MAX/y), where y is larger than RAND_MAX(==0x7fff on Windows) -remove loop in get_len() storage/maria/unittest/ma_test_loghandler_noflush-t.c: Fix build errors on Windows storage/maria/unittest/test_file.c: Correct the code to get file size on Windows. stat() information can be outdated and thus cannot be trusted. On Vista,stat() returns file size=0 until the file is closed at the first time. storage/myisam/CMakeLists.txt: Fix compiler errors on Windows Build test executables storage/myisam/mi_test2.c: Rename variable to avoid naming conflict with Microsoft C runtime function storage/myisam/mi_test3.c: Fix build errors on Windows strings/CMakeLists.txt: Add missing file unittest/unit.pl: Windows: downport unittest changes from 5.2 bk tree unittest/mysys/Makefile.am: Windows: downport unittest changes from 5.2 bk tree unittest/mysys/my_atomic-t.c: Windows: downport unittest changes from 5.2 bk tree unittest/mytap/Makefile.am: Windows: downport unittest changes from 5.2 bk tree unittest/mytap/tap.c: Windows: downport unittest changes from 5.2 bk tree win/configure.js: Add WITH_MARIA_STORAGE_ENGINE configure option unittest/mytap/CMakeLists.txt: Add missing file unittest/mysys/CMakeLists.txt: Add missing file storage/maria/unittest/CMakeLists.txt: Add missing file BitKeeper/etc/ignore: Added comments maria-win.patch to the ignore list include/atomic/generic-msvc.h: Implement atomic operations with MSVC intrinsics
208 lines
6.2 KiB
C
208 lines
6.2 KiB
C
/* Copyright (C) 2006 MySQL AB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
|
|
|
/*
|
|
Analog of DYNAMIC_ARRAY that never reallocs
|
|
(so no pointer into the array may ever become invalid).
|
|
|
|
Memory is allocated in non-contiguous chunks.
|
|
This data structure is not space efficient for sparse arrays.
|
|
|
|
Every element is aligned to sizeof(element) boundary
|
|
(to avoid false sharing if element is big enough).
|
|
|
|
LF_DYNARRAY is a recursive structure. On the zero level
|
|
LF_DYNARRAY::level[0] it's an array of LF_DYNARRAY_LEVEL_LENGTH elements,
|
|
on the first level it's an array of LF_DYNARRAY_LEVEL_LENGTH pointers
|
|
to arrays of elements, on the second level it's an array of pointers
|
|
to arrays of pointers to arrays of elements. And so on.
|
|
|
|
With four levels the number of elements is limited to 4311810304
|
|
(but as in all functions index is uint, the real limit is 2^32-1)
|
|
|
|
Actually, it's wait-free, not lock-free ;-)
|
|
*/
|
|
|
|
#include <my_global.h>
|
|
#include <m_string.h>
|
|
#include <my_sys.h>
|
|
#include <lf.h>
|
|
|
|
void lf_dynarray_init(LF_DYNARRAY *array, uint element_size)
|
|
{
|
|
bzero(array, sizeof(*array));
|
|
array->size_of_element= element_size;
|
|
my_atomic_rwlock_init(&array->lock);
|
|
}
|
|
|
|
static void recursive_free(void **alloc, int level)
|
|
{
|
|
if (!alloc)
|
|
return;
|
|
|
|
if (level)
|
|
{
|
|
int i;
|
|
for (i= 0; i < LF_DYNARRAY_LEVEL_LENGTH; i++)
|
|
recursive_free(alloc[i], level-1);
|
|
my_free((void *)alloc, MYF(0));
|
|
}
|
|
else
|
|
my_free(alloc[-1], MYF(0));
|
|
}
|
|
|
|
void lf_dynarray_destroy(LF_DYNARRAY *array)
|
|
{
|
|
int i;
|
|
for (i= 0; i < LF_DYNARRAY_LEVELS; i++)
|
|
recursive_free(array->level[i], i);
|
|
my_atomic_rwlock_destroy(&array->lock);
|
|
}
|
|
|
|
static const ulong dynarray_idxes_in_prev_levels[LF_DYNARRAY_LEVELS]=
|
|
{
|
|
0, /* +1 here to to avoid -1's below */
|
|
LF_DYNARRAY_LEVEL_LENGTH,
|
|
LF_DYNARRAY_LEVEL_LENGTH * LF_DYNARRAY_LEVEL_LENGTH +
|
|
LF_DYNARRAY_LEVEL_LENGTH,
|
|
LF_DYNARRAY_LEVEL_LENGTH * LF_DYNARRAY_LEVEL_LENGTH *
|
|
LF_DYNARRAY_LEVEL_LENGTH + LF_DYNARRAY_LEVEL_LENGTH *
|
|
LF_DYNARRAY_LEVEL_LENGTH + LF_DYNARRAY_LEVEL_LENGTH
|
|
};
|
|
|
|
static const ulong dynarray_idxes_in_prev_level[LF_DYNARRAY_LEVELS]=
|
|
{
|
|
0, /* +1 here to to avoid -1's below */
|
|
LF_DYNARRAY_LEVEL_LENGTH,
|
|
LF_DYNARRAY_LEVEL_LENGTH * LF_DYNARRAY_LEVEL_LENGTH,
|
|
LF_DYNARRAY_LEVEL_LENGTH * LF_DYNARRAY_LEVEL_LENGTH *
|
|
LF_DYNARRAY_LEVEL_LENGTH,
|
|
};
|
|
|
|
/*
|
|
Returns a valid lvalue pointer to the element number 'idx'.
|
|
Allocates memory if necessary.
|
|
*/
|
|
void *_lf_dynarray_lvalue(LF_DYNARRAY *array, uint idx)
|
|
{
|
|
void * ptr, * volatile * ptr_ptr= 0;
|
|
int i;
|
|
|
|
for (i= LF_DYNARRAY_LEVELS-1; idx < dynarray_idxes_in_prev_levels[i]; i--)
|
|
/* no-op */;
|
|
ptr_ptr= &array->level[i];
|
|
idx-= dynarray_idxes_in_prev_levels[i];
|
|
for (; i > 0; i--)
|
|
{
|
|
if (!(ptr= *ptr_ptr))
|
|
{
|
|
void *alloc= my_malloc(LF_DYNARRAY_LEVEL_LENGTH * sizeof(void *),
|
|
MYF(MY_WME|MY_ZEROFILL));
|
|
if (unlikely(!alloc))
|
|
return(NULL);
|
|
if (my_atomic_casptr(ptr_ptr, &ptr, alloc))
|
|
ptr= alloc;
|
|
else
|
|
my_free(alloc, MYF(0));
|
|
}
|
|
ptr_ptr= ((void **)ptr) + idx / dynarray_idxes_in_prev_level[i];
|
|
idx%= dynarray_idxes_in_prev_level[i];
|
|
}
|
|
if (!(ptr= *ptr_ptr))
|
|
{
|
|
uchar *alloc, *data;
|
|
alloc= my_malloc(LF_DYNARRAY_LEVEL_LENGTH * array->size_of_element +
|
|
max(array->size_of_element, sizeof(void *)),
|
|
MYF(MY_WME|MY_ZEROFILL));
|
|
if (unlikely(!alloc))
|
|
return(NULL);
|
|
/* reserve the space for free() address */
|
|
data= alloc + sizeof(void *);
|
|
{ /* alignment */
|
|
intptr mod= ((intptr)data) % array->size_of_element;
|
|
if (mod)
|
|
data+= array->size_of_element - mod;
|
|
}
|
|
((void **)data)[-1]= alloc; /* free() will need the original pointer */
|
|
if (my_atomic_casptr(ptr_ptr, &ptr, data))
|
|
ptr= data;
|
|
else
|
|
my_free(alloc, MYF(0));
|
|
}
|
|
return ((uchar*)ptr) + array->size_of_element * idx;
|
|
}
|
|
|
|
/*
|
|
Returns a pointer to the element number 'idx'
|
|
or NULL if an element does not exists
|
|
*/
|
|
void *_lf_dynarray_value(LF_DYNARRAY *array, uint idx)
|
|
{
|
|
void * ptr, * volatile * ptr_ptr= 0;
|
|
int i;
|
|
|
|
for (i= LF_DYNARRAY_LEVELS-1; idx < dynarray_idxes_in_prev_levels[i]; i--)
|
|
/* no-op */;
|
|
ptr_ptr= &array->level[i];
|
|
idx-= dynarray_idxes_in_prev_levels[i];
|
|
for (; i > 0; i--)
|
|
{
|
|
if (!(ptr= *ptr_ptr))
|
|
return(NULL);
|
|
ptr_ptr= ((void **)ptr) + idx / dynarray_idxes_in_prev_level[i];
|
|
idx %= dynarray_idxes_in_prev_level[i];
|
|
}
|
|
if (!(ptr= *ptr_ptr))
|
|
return(NULL);
|
|
return ((uchar*)ptr) + array->size_of_element * idx;
|
|
}
|
|
|
|
static int recursive_iterate(LF_DYNARRAY *array, void *ptr, int level,
|
|
lf_dynarray_func func, void *arg)
|
|
{
|
|
int res, i;
|
|
if (!ptr)
|
|
return 0;
|
|
if (!level)
|
|
return func(ptr, arg);
|
|
for (i= 0; i < LF_DYNARRAY_LEVEL_LENGTH; i++)
|
|
if ((res= recursive_iterate(array, ((void **)ptr)[i], level-1, func, arg)))
|
|
return res;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
Calls func(array, arg) on every array of LF_DYNARRAY_LEVEL_LENGTH elements
|
|
in lf_dynarray.
|
|
|
|
DESCRIPTION
|
|
lf_dynarray consists of a set of arrays, LF_DYNARRAY_LEVEL_LENGTH elements
|
|
each. _lf_dynarray_iterate() calls user-supplied function on every array
|
|
from the set. It is the fastest way to scan the array, faster than
|
|
for (i=0; i < N; i++) { func(_lf_dynarray_value(dynarray, i)); }
|
|
|
|
NOTE
|
|
if func() returns non-zero, the scan is aborted
|
|
*/
|
|
int _lf_dynarray_iterate(LF_DYNARRAY *array, lf_dynarray_func func, void *arg)
|
|
{
|
|
int i, res;
|
|
for (i= 0; i < LF_DYNARRAY_LEVELS; i++)
|
|
if ((res= recursive_iterate(array, array->level[i], i, func, arg)))
|
|
return res;
|
|
return 0;
|
|
}
|
|
|