mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-02-01 11:31:51 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge mysql.com:/space_old/pekka/ndb/version/my41-bug20847

Browse source 
into  mysql.com:/space_old/pekka/ndb/version/my50-bug20847
This commit is contained in:
pekka@mysql.com/orca.ndb.mysql.com 2006-07-07 13:40:47 +02:00
commit c9bc03c3cd
6 changed files with 259 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
ndb/src/kernel/blocks/ERROR_codes.txt
View file

@ -2,7 +2,7 @@ Next QMGR 1
Next NDBCNTR 1000
Next NDBFS 2000
Next DBACC 3002
Next DBTUP 4013
Next DBTUP 4014
Next DBLQH 5043
Next DBDICT 6007
Next DBDIH 7177
@ -437,6 +437,8 @@ Drop Table/Index:
8036: Fail next index drop in TC
6006: Crash participant in create index
4013: verify TUP tab descr before and after next DROP TABLE
System Restart:
---------------

9
ndb/src/kernel/blocks/dbtup/Dbtup.hpp
View file

@ -2185,15 +2185,18 @@ private:
// Public methods
Uint32 getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset);
Uint32 allocTabDescr(const Tablerec* regTabPtr, Uint32* offset);
void freeTabDescr(Uint32 retRef, Uint32 retNo);
void freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal = true);
Uint32 getTabDescrWord(Uint32 index);
void setTabDescrWord(Uint32 index, Uint32 word);
// Private methods
Uint32 sizeOfReadFunction();
void removeTdArea(Uint32 tabDesRef, Uint32 list);
void insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list);
Uint32 itdaMergeTabDescr(Uint32 retRef, Uint32 retNo);
void insertTdArea(Uint32 tabDesRef, Uint32 list);
void itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal);
#ifdef VM_TRACE
void verifytabdes();
#endif
//------------------------------------------------------------------------------------------------------
// Page Memory Manager

7
ndb/src/kernel/blocks/dbtup/DbtupMeta.cpp
View file

@ -601,6 +601,9 @@ void
Dbtup::execDROP_TAB_REQ(Signal* signal)
{
ljamEntry();
if (ERROR_INSERTED(4013)) {
verifytabdes();
}
DropTabReq* req = (DropTabReq*)signal->getDataPtr();
TablerecPtr tabPtr;
@ -719,5 +722,9 @@ void Dbtup::execFSREMOVECONF(Signal* signal)
releaseTabDescr(tabPtr.p);
initTab(tabPtr.p);
if (ERROR_INSERTED(4013)) {
CLEAR_ERROR_INSERT_VALUE;
verifytabdes();
}
}//Dbtup::execFSREMOVECONF()

169
ndb/src/kernel/blocks/dbtup/DbtupTabDesMan.cpp
View file

@ -24,13 +24,15 @@
#define ljam() { jamLine(22000 + __LINE__); }
#define ljamEntry() { jamEntryLine(22000 + __LINE__); }
/* **************************************************************** */
/* *********** TABLE DESCRIPTOR MEMORY MANAGER ******************** */
/* **************************************************************** */
/* This module is used to allocate and deallocate table descriptor */
/* memory attached to fragments (could be allocated per table */
/* instead. Performs its task by a buddy algorithm. */
/* **************************************************************** */
/*
* TABLE DESCRIPTOR MEMORY MANAGER
*
* Each table has a descriptor which is a contiguous array of words.
* The descriptor is allocated from a global array using a buddy
* algorithm. Free lists exist for each power of 2 words. Freeing
* a piece first merges with free right and left neighbours and then
* divides itself up into free list chunks.
*/
Uint32
Dbtup::getTabDescrOffsets(const Tablerec* regTabPtr, Uint32* offset)
@ -59,7 +61,7 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
Uint32 reference = RNIL;
Uint32 allocSize = getTabDescrOffsets(regTabPtr, offset);
/* ---------------------------------------------------------------- */
/* ALWAYS ALLOCATE A MULTIPLE OF 16 BYTES */
/* ALWAYS ALLOCATE A MULTIPLE OF 16 WORDS */
/* ---------------------------------------------------------------- */
allocSize = (((allocSize - 1) >> 4) + 1) << 4;
Uint32 list = nextHigherTwoLog(allocSize - 1); /* CALCULATE WHICH LIST IT BELONGS TO */
@ -72,9 +74,9 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
Uint32 retNo = (1 << i) - allocSize; /* CALCULATE THE DIFFERENCE */
if (retNo >= ZTD_FREE_SIZE) {
ljam();
Uint32 retRef = reference + allocSize; /* SET THE RETURN POINTER */
retNo = itdaMergeTabDescr(retRef, retNo); /* MERGE WITH POSSIBLE RIGHT NEIGHBOURS */
freeTabDescr(retRef, retNo); /* RETURN UNUSED TD SPACE TO THE TD AREA */
// return unused words, of course without attempting left merge
Uint32 retRef = reference + allocSize;
freeTabDescr(retRef, retNo, false);
} else {
ljam();
allocSize = 1 << i;
@ -100,17 +102,19 @@ Uint32 Dbtup::allocTabDescr(const Tablerec* regTabPtr, Uint32* offset)
}//if
}//Dbtup::allocTabDescr()
void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo)
void Dbtup::freeTabDescr(Uint32 retRef, Uint32 retNo, bool normal)
{
itdaMergeTabDescr(retRef, retNo, normal); /* MERGE WITH POSSIBLE NEIGHBOURS */
while (retNo >= ZTD_FREE_SIZE) {
ljam();
Uint32 list = nextHigherTwoLog(retNo);
list--; /* RETURN TO NEXT LOWER LIST */
Uint32 sizeOfChunk = 1 << list;
insertTdArea(sizeOfChunk, retRef, list);
insertTdArea(retRef, list);
retRef += sizeOfChunk;
retNo -= sizeOfChunk;
}//while
ndbassert(retNo == 0);
}//Dbtup::freeTabDescr()
Uint32
@ -127,7 +131,7 @@ Dbtup::setTabDescrWord(Uint32 index, Uint32 word)
tableDescriptor[index].tabDescr = word;
}//Dbtup::setTabDescrWord()
void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list)
void Dbtup::insertTdArea(Uint32 tabDesRef, Uint32 list)
{
ndbrequire(list < 16);
setTabDescrWord(tabDesRef + ZTD_FL_HEADER, ZTD_TYPE_FREE);
@ -144,19 +148,14 @@ void Dbtup::insertTdArea(Uint32 sizeOfChunk, Uint32 tabDesRef, Uint32 list)
setTabDescrWord((tabDesRef + (1 << list)) - ZTD_TR_SIZE, 1 << list);
}//Dbtup::insertTdArea()
/* ---------------------------------------------------------------- */
/* ----------------------- MERGE_TAB_DESCR ------------------------ */
/* ---------------------------------------------------------------- */
/* INPUT: TAB_DESCR_PTR POINTING AT THE CURRENT CHUNK */
/* */
/* SHORTNAME: MTD */
/* -----------------------------------------------------------------*/
Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo)
/*
* Merge to-be-removed chunk (which need not be initialized with header
* and trailer) with left and right buddies. The start point retRef
* moves to left and the size retNo increases to match the new chunk.
*/
void Dbtup::itdaMergeTabDescr(Uint32& retRef, Uint32& retNo, bool normal)
{
/* THE SIZE OF THE PART TO MERGE MUST BE OF THE SAME SIZE AS THE INSERTED PART */
/* THIS IS TRUE EITHER IF ONE PART HAS THE SAME SIZE OR THE SUM OF BOTH PARTS */
/* TOGETHER HAS THE SAME SIZE AS THE PART TO BE INSERTED */
/* FIND THE SIZES OF THE PARTS TO THE RIGHT OF THE PART TO BE REINSERTED */
// merge right
while ((retRef + retNo) < cnoOfTabDescrRec) {
ljam();
Uint32 tabDesRef = retRef + retNo;
@ -170,11 +169,28 @@ Uint32 Dbtup::itdaMergeTabDescr(Uint32 retRef, Uint32 retNo)
removeTdArea(tabDesRef, list);
} else {
ljam();
return retNo;
}//if
}//while
ndbrequire((retRef + retNo) == cnoOfTabDescrRec);
return retNo;
break;
}
}
// merge left
const bool mergeLeft = normal;
while (mergeLeft && retRef > 0) {
ljam();
Uint32 trailerWord = getTabDescrWord(retRef - ZTD_TR_TYPE);
if (trailerWord == ZTD_TYPE_FREE) {
ljam();
Uint32 sizeOfMergedPart = getTabDescrWord(retRef - ZTD_TR_SIZE);
ndbrequire(retRef >= sizeOfMergedPart);
retRef -= sizeOfMergedPart;
retNo += sizeOfMergedPart;
Uint32 list = nextHigherTwoLog(sizeOfMergedPart - 1);
removeTdArea(retRef, list);
} else {
ljam();
break;
}
}
ndbrequire((retRef + retNo) <= cnoOfTabDescrRec);
}//Dbtup::itdaMergeTabDescr()
/* ---------------------------------------------------------------- */
@ -210,3 +226,94 @@ void Dbtup::removeTdArea(Uint32 tabDesRef, Uint32 list)
setTabDescrWord(tabDescrPrevPtr + ZTD_FL_NEXT, tabDescrNextPtr);
}//if
}//Dbtup::removeTdArea()
#ifdef VM_TRACE
void
Dbtup::verifytabdes()
{
struct WordType {
short fl; // free list 0-15
short ti; // table id
WordType() : fl(-1), ti(-1) {}
};
WordType* wt = new WordType [cnoOfTabDescrRec];
uint free_frags = 0;
// free lists
{
for (uint i = 0; i < 16; i++) {
Uint32 desc2 = RNIL;
Uint32 desc = cfreeTdList[i];
while (desc != RNIL) {
const Uint32 size = (1 << i);
ndbrequire(size >= ZTD_FREE_SIZE);
ndbrequire(desc + size <= cnoOfTabDescrRec);
{ Uint32 index = desc + ZTD_FL_HEADER;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);
}
{ Uint32 index = desc + ZTD_FL_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
{ Uint32 index = desc + size - ZTD_TR_TYPE;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_FREE);
}
{ Uint32 index = desc + size - ZTD_TR_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
{ Uint32 index = desc + ZTD_FL_PREV;
ndbrequire(tableDescriptor[index].tabDescr == desc2);
}
for (uint j = 0; j < size; j++) {
ndbrequire(wt[desc + j].fl == -1);
wt[desc + j].fl = i;
}
desc2 = desc;
desc = tableDescriptor[desc + ZTD_FL_NEXT].tabDescr;
free_frags++;
}
}
}
// tables
{
for (uint i = 0; i < cnoOfTablerec; i++) {
TablerecPtr ptr;
ptr.i = i;
ptrAss(ptr, tablerec);
if (ptr.p->tableStatus == DEFINED) {
Uint32 offset[10];
const Uint32 alloc = getTabDescrOffsets(ptr.p, offset);
const Uint32 desc = ptr.p->readKeyArray - offset[3];
Uint32 size = alloc;
if (size % ZTD_FREE_SIZE != 0)
size += ZTD_FREE_SIZE - size % ZTD_FREE_SIZE;
ndbrequire(desc + size <= cnoOfTabDescrRec);
{ Uint32 index = desc + ZTD_FL_HEADER;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);
}
{ Uint32 index = desc + ZTD_FL_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
{ Uint32 index = desc + size - ZTD_TR_TYPE;
ndbrequire(tableDescriptor[index].tabDescr == ZTD_TYPE_NORMAL);
}
{ Uint32 index = desc + size - ZTD_TR_SIZE;
ndbrequire(tableDescriptor[index].tabDescr == size);
}
for (uint j = 0; j < size; j++) {
ndbrequire(wt[desc + j].ti == -1);
wt[desc + j].ti = i;
}
}
}
}
// all words
{
for (uint i = 0; i < cnoOfTabDescrRec; i++) {
bool is_fl = wt[i].fl != -1;
bool is_ti = wt[i].ti != -1;
ndbrequire(is_fl != is_ti);
}
}
delete [] wt;
ndbout << "verifytabdes: frags=" << free_frags << endl;
}
#endif

101
ndb/test/ndbapi/testDict.cpp
View file

@ -233,6 +233,101 @@ int runCreateAndDrop(NDBT_Context* ctx, NDBT_Step* step){
return NDBT_OK;
}
int runCreateAndDropAtRandom(NDBT_Context* ctx, NDBT_Step* step)
{
myRandom48Init(NdbTick_CurrentMillisecond());
Ndb* pNdb = GETNDB(step);
NdbDictionary::Dictionary* pDic = pNdb->getDictionary();
int loops = ctx->getNumLoops();
int numTables = NDBT_Tables::getNumTables();
bool* tabList = new bool [ numTables ];
int tabCount;
{
for (int num = 0; num < numTables; num++) {
(void)pDic->dropTable(NDBT_Tables::getTable(num)->getName());
tabList[num] = false;
}
tabCount = 0;
}
NdbRestarter restarter;
int result = NDBT_OK;
int bias = 1; // 0-less 1-more
int i = 0;
while (i < loops) {
g_info << "loop " << i << " tabs " << tabCount << "/" << numTables << endl;
int num = myRandom48(numTables);
const NdbDictionary::Table* pTab = NDBT_Tables::getTable(num);
char tabName[200];
strcpy(tabName, pTab->getName());
if (tabList[num] == false) {
if (bias == 0 && myRandom48(100) < 80)
continue;
g_info << tabName << ": create" << endl;
if (pDic->createTable(*pTab) != 0) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": create failed: " << err << endl;
result = NDBT_FAILED;
break;
}
const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);
if (pTab2 == NULL) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": verify create: " << err << endl;
result = NDBT_FAILED;
break;
}
tabList[num] = true;
assert(tabCount < numTables);
tabCount++;
if (tabCount == numTables)
bias = 0;
}
else {
if (bias == 1 && myRandom48(100) < 80)
continue;
g_info << tabName << ": drop" << endl;
if (restarter.insertErrorInAllNodes(4013) != 0) {
g_err << "error insert failed" << endl;
result = NDBT_FAILED;
break;
}
if (pDic->dropTable(tabName) != 0) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": drop failed: " << err << endl;
result = NDBT_FAILED;
break;
}
const NdbDictionary::Table* pTab2 = pDic->getTable(tabName);
if (pTab2 != NULL) {
g_err << tabName << ": verify drop: table exists" << endl;
result = NDBT_FAILED;
break;
}
if (pDic->getNdbError().code != 709 &&
pDic->getNdbError().code != 723) {
const NdbError err = pDic->getNdbError();
g_err << tabName << ": verify drop: " << err << endl;
result = NDBT_FAILED;
break;
}
tabList[num] = false;
assert(tabCount > 0);
tabCount--;
if (tabCount == 0)
bias = 1;
}
i++;
}
delete [] tabList;
return result;
}
int runCreateAndDropWithData(NDBT_Context* ctx, NDBT_Step* step){
Ndb* pNdb = GETNDB(step);
int loops = ctx->getNumLoops();
@ -1849,6 +1944,12 @@ TESTCASE("CreateAndDrop",
"Try to create and drop the table loop number of times\n"){
INITIALIZER(runCreateAndDrop);
}
TESTCASE("CreateAndDropAtRandom",
"Try to create and drop table at random loop number of times\n"
"Uses all available tables\n"
"Uses error insert 4013 to make TUP verify table descriptor"){
INITIALIZER(runCreateAndDropAtRandom);
}
TESTCASE("CreateAndDropWithData",
"Try to create and drop the table when it's filled with data\n"
"do this loop number of times\n"){

4
ndb/test/run-test/daily-basic-tests.txt
View file

@ -464,6 +464,10 @@ max-time: 1500
cmd: testDict
args: -n CreateAndDrop
max-time: 1500
cmd: testDict
args: -n CreateAndDropAtRandom -l 200 T1
max-time: 1500
cmd: testDict
args: -n CreateAndDropWithData