#At file:///home/os136802/mysql/develop/repo/falcon-newdeps2-ann/ based on revid:olav@stripped
2740 Olav Sandstaa 2008-12-03
WL#4654 New transaction dependency manager for Falcon
Implements a new dependency manager for Falcon that uses start events and commit events for transactions
for determining the relative state between transactions and for determining when a transaction can
be removed. The transaction id is used as start event and a new "commitId" is used as commit event.
Both the transaction id and the new commit id is generated from the transaction id sequence.
The old dependency manager is removed. This eliminates the states array and the dependency counter
from each transaction.
modified:
storage/falcon/Transaction.cpp
storage/falcon/Transaction.h
storage/falcon/TransactionManager.cpp
storage/falcon/TransactionManager.h
per-file messages:
storage/falcon/Transaction.cpp
Replaces the us of the states array and the dependency counter with the new start event (transactionId) and commit events (commitId) for tracking dependencies/relative state between transactions.
Optimizations for read-only transactions have been removed or disabled.
Removed code for old dependency manager.
storage/falcon/Transaction.h
Add a new commit id that is used as commit event by the new dependency manager. Removes the old states array and the dependency counter.
storage/falcon/TransactionManager.cpp
New dependency manager: Use the new start (transactionId) and commit events (commitId) for determining when transactions can be deleted.
Optimizations for read-only transactions have been removed.
Code for the old dependency manger has been removed.
storage/falcon/TransactionManager.h
Removed old dependency manager.
=== modified file 'storage/falcon/Transaction.cpp'
=== modified file 'storage/falcon/Transaction.cpp'
--- a/storage/falcon/Transaction.cpp 2008-12-03 11:08:59 +0000
+++ b/storage/falcon/Transaction.cpp 2008-12-03 13:20:17 +0000
@@ -1,4 +1,4 @@
-/* Copyright (C) 2006 MySQL AB
+/* Copyright (C) 2006 MySQL AB, 2008 Sun Microsystems, Inc.
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
@@ -49,6 +49,10 @@
extern uint falcon_lock_wait_timeout;
+extern volatile int Talloc; // These are temporary for debug tracing
+extern volatile int Tdelete; // of number of allocated transaction objects.
+
+
static const char *stateNames [] = {
"Active",
"Limbo",
@@ -78,8 +82,8 @@
Transaction::Transaction(Connection *cnct, TransId seq)
{
- states = NULL;
- statesAllocated = 0;
+ Talloc++;
+
savePoints = NULL;
freeSavePoints = NULL;
useCount = 1;
@@ -90,7 +94,6 @@
syncSavepoints.setName("Transaction::syncSavepoints");
firstRecord = NULL;
lastRecord = NULL;
- dependencies = 0;
initialize(cnct, seq);
}
@@ -101,7 +104,6 @@
ASSERT(savePoints == NULL);
ASSERT(freeSavePoints == NULL);
ASSERT(firstRecord == NULL);
- ASSERT(dependencies == 0);
connection = cnct;
isolationLevel = connection->isolationLevel;
mySqlThreadId = connection->mySqlThreadId;
@@ -109,6 +111,7 @@
TransactionManager *transactionManager = database->transactionManager;
systemTransaction = database->systemConnection == connection;
transactionId = seq;
+ commitId = 0;
chillPoint = &firstRecord;
commitTriggers = false;
hasUpdates = false;
@@ -132,7 +135,6 @@
debugThawedRecords = 0;
debugThawedBytes = 0;
committedRecords = 0;
- numberStates = 0;
blockedBy = 0;
deletedRecords = 0;
inList = true;
@@ -160,46 +162,13 @@
syncIsActive.lock(NULL, Exclusive);
Transaction *oldest = transactionManager->findOldest();
oldestActive = (oldest) ? oldest->transactionId : transactionId;
- int count = transactionManager->activeTransactions.count;
-
- if (count > statesAllocated)
- {
- delete [] states;
- statesAllocated = count;
- states = new TransState[statesAllocated];
- }
-
- if (count)
- for (Transaction *transaction = transactionManager->activeTransactions.first; transaction; transaction = transaction->next)
- if (transaction->isActive() &&
- !transaction->systemTransaction &&
- transaction->transactionId < transactionId)
- {
- Sync syncDependency(&transaction->syncObject, "Transaction::initialize(2)");
- syncDependency.lock(Shared);
-
- if (transaction->isActive() &&
- !transaction->systemTransaction &&
- transaction->transactionId < transactionId)
- {
- transaction->addRef();
- INTERLOCKED_INCREMENT(transaction->dependencies);
- TransState *state = states + numberStates;
- state->transaction = transaction;
- state->transactionId = transaction->transactionId;
- state->state = transaction->state;
- ++numberStates;
- ASSERT(transaction->transactionId == state->transactionId);
- }
- }
-
state = Active;
}
Transaction::~Transaction()
{
- ASSERT(dependencies == 0);
-
+ Tdelete++;
+
if (state == Active)
{
Log::debug("Deleting apparently active transaction %d\n", transactionId);
@@ -212,7 +181,6 @@
if (inList)
database->transactionManager->removeTransaction(this);
- delete [] states;
delete [] xid;
delete backloggedRecords;
chillPoint = &firstRecord;
@@ -241,12 +209,15 @@
releaseSavepoints();
- if (!hasUpdates)
- {
- commitNoUpdates();
-
- return;
- }
+ // NOTE: temporary disabled the optimization for read only transactions.
+ // This will be included in a follow up patch
+
+ //if (!hasUpdates)
+ // {
+ // commitNoUpdates();
+ //
+ // return;
+ // }
TransactionManager *transactionManager = database->transactionManager;
addRef();
@@ -275,7 +246,13 @@
if (hasLocks)
releaseRecordLocks();
- database->serialLog->preCommit(this);
+ // NOTE: The if test can be removed when the handling of read-only
+ // transactions has been re-implemented
+
+ if (hasUpdates)
+ database->serialLog->preCommit(this);
+ else
+ writePending = false;
Sync syncRec(&syncRecords,"Transaction::commit(1.5)");
syncRec.lock(Shared);
@@ -297,7 +274,6 @@
}
syncRec.unlock();
- releaseDependencies();
database->flushInversion(this);
// Transfer transaction from active list to committed list, set committed state
@@ -308,6 +284,10 @@
syncActiveTransactions.lock(Exclusive);
syncCommitted.lock(Exclusive);
+ // Set the commit transition id for this transaction
+
+ commitId = INTERLOCKED_INCREMENT(transactionManager->transactionSequence);
+
transactionManager->activeTransactions.remove(this);
transactionManager->committedTransactions.append(this);
state = Committed;
@@ -324,9 +304,16 @@
xidLength = 0;
// If there's no reason to stick around, just go away
-
- if ((dependencies == 0) && !writePending)
- commitRecords();
+
+ // NOTE: This call to commitRecords() is temporarily commented out.
+ // A call to commitRecords() are taken care of in
+ // TransactionManager::purgeTransactions().
+ // It is likely that this call will be totally removed in one of the
+ // next patches as I do not think it is ever called here due to
+ // still having pending writes - but I will investigate this further
+
+ //if ((dependencies == 0) && !writePending)
+ // commitRecords();
connection = NULL;
@@ -338,6 +325,9 @@
void Transaction::commitNoUpdates(void)
{
+ // NOTE: This method is not in use by the new dependency manager.
+ // It will be re-enabled in a follow-up patch
+
TransactionManager *transactionManager = database->transactionManager;
addRef();
ASSERT(!deferredIndexes);
@@ -352,7 +342,6 @@
Sync syncActiveTransactions(&transactionManager->activeTransactions.syncObject, "Transaction::commitNoUpdates(2)");
syncActiveTransactions.lock(Shared);
- releaseDependencies();
if (xid)
{
@@ -363,10 +352,7 @@
Sync sync(&syncObject, "Transaction::commitNoUpdates(3)");
sync.lock(Exclusive);
-
- if (dependencies)
- transactionManager->expungeTransaction(this);
-
+
// If there's no reason to stick around, just go away
connection = NULL;
@@ -441,7 +427,6 @@
ASSERT(writePending);
writePending = false;
- releaseDependencies();
if (hasUpdates)
database->serialLog->preCommit(this);
@@ -458,11 +443,7 @@
Sync syncActiveTransactions (&transactionManager->activeTransactions.syncObject, "Transaction::rollback(active)");
syncActiveTransactions.lock (Exclusive);
++transactionManager->rolledBack;
-
- while (dependencies)
- transactionManager->expungeTransaction(this);
-
- ASSERT(dependencies == 0);
+
inList = false;
transactionManager->activeTransactions.remove(this);
syncActiveTransactions.unlock();
@@ -472,20 +453,6 @@
}
-void Transaction::expungeTransaction(Transaction * transaction)
-{
- ASSERT(states != NULL || numberStates == 0);
-
- for (TransState *s = states, *end = s + numberStates; s < end; ++s)
- if (s->transaction == transaction)
- {
- if (COMPARE_EXCHANGE_POINTER(&s->transaction, transaction, NULL))
- transaction->releaseDependency();
-
- break;
- }
-}
-
void Transaction::prepare(int xidLen, const UCHAR *xidPtr)
{
if (state != Active)
@@ -750,11 +717,11 @@
if (transId > transactionId)
return false;
- // If the transaction was active when we started, use it's state at that point
+ // If the other transaction committed after we started then it should not
+ // be visible to us
- for (int n = 0; n < numberStates; ++n)
- if (states [n].transactionId == transId)
- return false;
+ if (transaction->commitId > transactionId)
+ return false;
return true;
}
@@ -790,26 +757,6 @@
return false;
}
-void Transaction::releaseDependencies()
-{
- if (!numberStates)
- return;
-
- for (TransState *state = states, *end = states + numberStates; state < end; ++state)
- {
- Transaction *transaction = state->transaction;
-
- if (transaction)
- {
- if (COMPARE_EXCHANGE_POINTER(&state->transaction, transaction, NULL))
- {
- ASSERT(transaction->transactionId == state->transactionId || transaction->transactionId == 0);
- ASSERT(transaction->state != Initializing);
- transaction->releaseDependency();
- }
- }
- }
-}
/*
* Transaction is fully mature and about to go away.
@@ -852,6 +799,14 @@
State Transaction::getRelativeState(Record* record, uint32 flags)
{
+ // If this is a Record object it has no assosiated transaction
+ // and is always visible
+
+ if (!record->isVersion())
+ {
+ return CommittedVisible;
+ }
+
blockingRecord = record;
State state = getRelativeState(record->getTransaction(), record->getTransactionId(), flags);
blockingRecord = NULL;
@@ -880,14 +835,22 @@
// If the transaction is no longer around, and the record is,
// then it must be committed.
+ // Check if the transaction started after us.
+ // With the old dependency manager this test might have been
+ // hit but with the new dependency manager this will never
+ // happen. Still leave it in until further evaluation.
+
if (transactionId < transId)
return CommittedInvisible;
// Be sure it was not active when we started.
- for (int n = 0; n < numberStates; ++n)
- if (states [n].transactionId == transId)
- return CommittedInvisible;
+ // The dependency manager ensures that transactions that were
+ // active at the time this transaction started will not be
+ // deleted at least not until also we are committed.
+ // Since the transaction pointer is NULL here,
+ // the transaction is not deleted and hence was not active at
+ // the time we started.
}
return CommittedVisible;
@@ -962,9 +925,17 @@
ASSERT(writePending);
ASSERT(state == Committed);
releaseDeferredIndexes();
-
- if (dependencies == 0)
- commitRecords();
+
+ // NOTE: This call to commitRecords() is temporarily commented out.
+ // A call to commitRecords() are taken care of in
+ // TransactionManager::purgeTransactions().
+ // We might want to include a call to commitRecords() her but in
+ // order to perform the "dependencies == 0" check with the new
+ // dependency manager we should probably have to do a shared lock
+ // on the activelist. Need to experiment with this a bit.
+
+ //if (dependencies == 0)
+ // commitRecords();
// Log::log(LogXARecovery, "%d: WriteComplete %sTransaction %d\n",
// database->deltaTime, (systemTransaction ? "System " : ""), transactionId);
@@ -1371,9 +1342,9 @@
void Transaction::print(void)
{
- Log::debug(" %p Id %d, state %d, updates %d, wrtPend %d, states %d, dependencies %d, records %d\n",
+ Log::debug(" %p Id %d, state %d, updates %d, wrtPend %d, records %d\n",
this, transactionId, state, hasUpdates, writePending,
- numberStates, dependencies, firstRecord != NULL);
+ firstRecord != NULL);
}
void Transaction::printBlocking(int level)
@@ -1439,7 +1410,12 @@
void Transaction::getInfo(InfoTable* infoTable)
{
- if (!(state == Available && dependencies == 0))
+ // NOTE: The field for number of dependencies will be removed in
+ // a follow-up patch.
+ // Need to decide if we want to include the startEvent and endEvent
+ // in this table.
+
+ if (!(state == Available))
{
int n = 0;
infoTable->putString(n++, stateNames[state]);
@@ -1447,7 +1423,7 @@
infoTable->putInt(n++, transactionId);
infoTable->putInt(n++, hasUpdates);
infoTable->putInt(n++, writePending);
- infoTable->putInt(n++, dependencies);
+ infoTable->putInt(n++, 0); // Number of dependencies, will be removed
infoTable->putInt(n++, oldestActive);
infoTable->putInt(n++, firstRecord != NULL);
infoTable->putInt(n++, (waitingFor) ? waitingFor->transactionId : 0);
@@ -1464,17 +1440,6 @@
}
}
-void Transaction::releaseDependency(void)
-{
- ASSERT(useCount >= 2);
- ASSERT(dependencies > 0);
- INTERLOCKED_DECREMENT(dependencies);
-
- if ((dependencies == 0) && !writePending && firstRecord)
- commitRecords();
- releaseCommittedTransaction();
-}
-
void Transaction::fullyCommitted(void)
{
ASSERT(inList);
@@ -1490,20 +1455,21 @@
{
release();
- if ((useCount == 1) && (state == Committed) && (dependencies == 0) && !writePending)
- if (COMPARE_EXCHANGE(&inList, (INTERLOCK_TYPE) true, (INTERLOCK_TYPE) false))
- database->transactionManager->removeCommittedTransaction(this);
-}
-
-void Transaction::validateDependencies(bool noDependencies)
-{
- for (TransState *state = states, *end = states + numberStates; state < end; ++state)
- if (state->transaction)
- {
- ASSERT(!noDependencies);
- ASSERT(state->transaction->transactionId == state->transactionId);
- }
-}
+ // NOTE: This is commented out due to in order to replacing the
+ // "dependencies == 0" test we have to lock the active transaction list.
+ // This should have no effect on Falcon due to that the if test will
+ // never evaluate to true when called from Transaction::fullyCommitted().
+ // Only when called from Transaction::releaseDependency() (which now is
+ // deleted) would the if test occasionally be true.
+ // The "removeCommittedTransaction" funcionality will be taken care
+ // of by TransactionManager::purgeTransaction.
+ // This code will likely be removed by a follow-up patch.
+
+ //if ((useCount == 1) && (state == Committed) && (dependencies == 0) && !writePending)
+ // if (COMPARE_EXCHANGE(&inList, (INTERLOCK_TYPE) true, (INTERLOCK_TYPE) false))
+ // database->transactionManager->removeCommittedTransaction(this);
+}
+
void Transaction::printBlockage(void)
{
=== modified file 'storage/falcon/Transaction.h'
--- a/storage/falcon/Transaction.h 2008-12-03 11:08:59 +0000
+++ b/storage/falcon/Transaction.h 2008-12-03 13:20:17 +0000
@@ -1,4 +1,4 @@
-/* Copyright (C) 2006 MySQL AB
+/* Copyright (C) 2006 MySQL AB, 2008 Sun Microsystems, Inc.
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
@@ -90,9 +90,7 @@
void removeRecordNoLock (RecordVersion *record);
void removeRecord(RecordVersion *record);
void removeRecord (RecordVersion *record, RecordVersion **ptr);
- void expungeTransaction (Transaction *transaction);
void commitRecords();
- void releaseDependencies();
bool visible (Transaction *transaction, TransId transId, int forWhat);
bool needToLock(Record* record);
void addRecord (RecordVersion *record);
@@ -108,7 +106,6 @@
void truncateTable(Table* table);
bool hasRecords(Table* table);
void writeComplete(void);
- void releaseDependency(void);
int createSavepoint();
void releaseSavepoint(int savepointId);
void releaseSavepoints(void);
@@ -127,7 +124,6 @@
void fullyCommitted(void);
void releaseCommittedTransaction(void);
void commitNoUpdates(void);
- void validateDependencies(bool noDependencies);
void validateRecords(void);
void printBlocking(int level);
void releaseDeferredIndexes(void);
@@ -141,7 +137,8 @@
Connection *connection;
Database *database;
- TransId transactionId;
+ TransId transactionId; // used also as startEvent by dep.mgr.
+ TransId commitId; // used as commitEvent by dep.mgr.
TransId oldestActive;
TransId blockedBy;
int curSavePointId;
@@ -157,12 +154,10 @@
Bitmap *backloggedRecords;
time_t startTime;
int deferredIndexCount;
- int statesAllocated;
int isolationLevel;
int xidLength;
int mySqlThreadId;
UCHAR *xid;
- TransState *states;
bool commitTriggers;
bool systemTransaction;
bool hasUpdates;
@@ -187,9 +182,7 @@
RecordVersion **chillPoint; // points to a pointer to the first non-chilled record
int scanIndexCount;
- volatile int numberStates;
volatile INTERLOCK_TYPE state;
- volatile INTERLOCK_TYPE dependencies;
volatile INTERLOCK_TYPE useCount;
volatile INTERLOCK_TYPE inList;
=== modified file 'storage/falcon/TransactionManager.cpp'
--- a/storage/falcon/TransactionManager.cpp 2008-12-03 11:08:59 +0000
+++ b/storage/falcon/TransactionManager.cpp 2008-12-03 13:20:17 +0000
@@ -1,4 +1,4 @@
-/* Copyright (C) 2006 MySQL AB
+/* Copyright (C) 2006 MySQL AB, 2008 Sun Microsystems, Inc.
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
@@ -15,6 +15,8 @@
#include <memory.h>
+#include <stdio.h> // Temporarily, will be removed before falcon-team tree
+#include <limits.h>
#include "Engine.h"
#include "TransactionManager.h"
#include "Transaction.h"
@@ -30,12 +32,16 @@
#include "Thread.h"
static const int EXTRA_TRANSACTIONS = 10;
+static const TransId TRANS_ID_MAX = UINT_MAX;
#ifdef _DEBUG
#undef THIS_FILE
static const char THIS_FILE[]=__FILE__;
#endif
+volatile int Talloc = 0; // Temp. will be removed. Used for tracing
+volatile int Tdelete = 0; // new and delete of trans objects.
+
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
@@ -111,46 +117,11 @@
Transaction* TransactionManager::startTransaction(Connection* connection)
{
Sync sync (&activeTransactions.syncObject, "TransactionManager::startTransaction");
- sync.lock (Shared);
- Transaction *transaction;
-
- for (transaction = activeTransactions.first; transaction; transaction = transaction->next)
- if (transaction->state == Available && transaction->dependencies == 0)
- if (COMPARE_EXCHANGE(&transaction->state, Available, Initializing))
- {
- // Check again that the dependencies are zero. The transaction
- // object might have been re-use between the previous if-test
- // and the actual change of state
-
- if (transaction->dependencies != 0)
- {
- // Return the transaction object back to the list
-
- transaction->state = Available;
- }
- else
- {
- ASSERT(transaction->dependencies == 0);
- transaction->initialize(connection, INTERLOCKED_INCREMENT(transactionSequence));
-
- return transaction;
- }
- }
-
- sync.unlock();
sync.lock(Exclusive);
- transaction = new Transaction (connection, INTERLOCKED_INCREMENT(transactionSequence));
+ Transaction *transaction = new Transaction (connection, INTERLOCKED_INCREMENT(transactionSequence));
activeTransactions.append(transaction);
- // And, just for yucks, add another 10 Available transactions
-
- for (int n = 0; n < EXTRA_TRANSACTIONS; ++n)
- {
- Transaction *trans = new Transaction(connection, 0);
- activeTransactions.append(trans);
- }
-
return transaction;
}
@@ -302,30 +273,46 @@
void TransactionManager::purgeTransactions()
{
+ Sync syncActive(&activeTransactions.syncObject, "TransactionManager::purgeTransaction");
+ syncActive.lock(Shared);
+
Sync syncCommitted(&committedTransactions.syncObject, "Transaction::purgeTransactions");
syncCommitted.lock(Exclusive);
+
+ fprintf(stderr, "TM::purgeTransactions: active=%d committed=%d alloc=%d delete=%d diff=%d\n", activeTransactions.count, committedTransactions.count, Talloc, Tdelete, (Talloc-Tdelete));
+
+ // Find the transaction id of the oldest active transaction
+
+ TransId oldestActive = TRANS_ID_MAX;
+
+ if (activeTransactions.first != NULL)
+ {
+ oldestActive = activeTransactions.first->transactionId;
+ }
+ syncActive.unlock();
// Check for any fully mature transactions to ditch
-
- for (Transaction *transaction, *next = committedTransactions.first; (transaction = next);)
+
+ Transaction* transaction = committedTransactions.first;
+
+ while ((transaction != NULL) &&
+ (transaction->state == Committed) &&
+ (transaction->commitId < oldestActive) &&
+ !transaction->writePending)
{
- next = transaction->next;
+ transaction->commitRecords();
- if ((transaction->state == Committed) &&
- (transaction->dependencies == 0) &&
- !transaction->writePending)
+ if (COMPARE_EXCHANGE(&transaction->inList, (INTERLOCK_TYPE) true, (INTERLOCK_TYPE) false))
{
- transaction->commitRecords();
-
- if (COMPARE_EXCHANGE(&transaction->inList, (INTERLOCK_TYPE) true, (INTERLOCK_TYPE) false))
- {
- committedTransactions.remove(transaction);
- transaction->release();
- }
+ committedTransactions.remove(transaction);
+ transaction->release();
}
+
+ transaction = committedTransactions.first;
}
}
+
void TransactionManager::getSummaryInfo(InfoTable* infoTable)
{
Sync syncActive (&activeTransactions.syncObject, "TransactionManager::getSummaryInfo(2)");
@@ -374,7 +361,6 @@
Transaction *transaction;
int active = 0;
int available = 0;
- int dependencies = 0;
time_t maxTime = 0;
for (transaction = activeTransactions.first; transaction; transaction = transaction->next)
@@ -387,9 +373,6 @@
else if (transaction->state == Available)
{
++available;
-
- if (transaction->dependencies)
- ++dependencies;
}
int pendingCleanup = committedTransactions.count;
@@ -399,8 +382,8 @@
priorRolledBack = rolledBack;
if ((active || numberCommitted || numberRolledBack) && Log::isActive(LogInfo))
- Log::log (LogInfo, "%d: Transactions: %d committed, %d rolled back, %d active, %d/%d available, %d post-commit, oldest %d seconds\n",
- database->deltaTime, numberCommitted, numberRolledBack, active, available, dependencies, pendingCleanup, maxTime);
+ Log::log (LogInfo, "%d: Transactions: %d committed, %d rolled back, %d active, %d available, %d post-commit, oldest %d seconds\n",
+ database->deltaTime, numberCommitted, numberRolledBack, active, available, pendingCleanup, maxTime);
}
void TransactionManager::removeCommittedTransaction(Transaction* transaction)
@@ -412,16 +395,6 @@
transaction->release();
}
-void TransactionManager::expungeTransaction(Transaction *transaction)
-{
- Sync syncActiveTrans(&activeTransactions.syncObject, "TransactionManager::removeTransaction");
- syncActiveTrans.lock(Shared);
-
- for (Transaction *trans = activeTransactions.first; trans; trans = trans->next)
- if ((trans->state != Available && trans->state != Initializing))
- //&& trans->transactionId > transaction->transactionId)
- trans->expungeTransaction(transaction);
-}
Transaction* TransactionManager::findTransaction(TransId transactionId)
{
@@ -445,24 +418,6 @@
return NULL;
}
-void TransactionManager::validateDependencies(void)
-{
- Sync syncActive(&activeTransactions.syncObject, "TransactionManager::validateDepedendencies(1)");
- syncActive.lock(Shared);
- Transaction *transaction;
-
- for (transaction = activeTransactions.first; transaction; transaction = transaction->next)
- if (transaction->isActive())
- transaction->validateDependencies(false);
-
- syncActive.unlock();
-
- Sync syncCommitted(&committedTransactions.syncObject, "TransactionManager::validateDepedendencies(2)");
- syncCommitted.lock(Shared);
-
- for (transaction = committedTransactions.first; transaction; transaction = transaction->next)
- transaction->validateDependencies(true);
-}
void TransactionManager::removeTransaction(Transaction* transaction)
{
=== modified file 'storage/falcon/TransactionManager.h'
--- a/storage/falcon/TransactionManager.h 2008-12-03 11:08:59 +0000
+++ b/storage/falcon/TransactionManager.h 2008-12-03 13:20:17 +0000
@@ -1,4 +1,4 @@
-/* Copyright (C) 2006 MySQL AB
+/* Copyright (C) 2006 MySQL AB, 2008 Sun Microsystems, Inc.
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
@@ -44,9 +44,7 @@
void purgeTransactions();
void getSummaryInfo(InfoTable* infoTable);
void reportStatistics(void);
- void expungeTransaction(Transaction *transaction);
Transaction* findTransaction(TransId transactionId);
- void validateDependencies(void);
void removeCommittedTransaction(Transaction* transaction);
void removeTransaction(Transaction* transaction);
void printBlockage(void);
| Thread |
|---|
| • bzr commit into mysql-6.0-falcon-ann branch (olav:2740) WL#4654 | Olav Sandstaa | 3 Dec |
