#At file:///G:/bzr/mysql-6.0-falcon-team/ based on revid:vvaintroub@stripped
3070 Vladislav Vaintroub 2009-03-23 [merge]
merge
added:
storage/falcon/TransactionState.cpp
storage/falcon/TransactionState.h
modified:
storage/falcon/Connection.cpp
storage/falcon/Database.cpp
storage/falcon/Makefile.am
storage/falcon/Record.cpp
storage/falcon/Record.h
storage/falcon/RecordVersion.cpp
storage/falcon/RecordVersion.h
storage/falcon/Table.cpp
storage/falcon/Transaction.cpp
storage/falcon/Transaction.h
storage/falcon/TransactionManager.cpp
=== modified file 'storage/falcon/Connection.cpp'
--- a/storage/falcon/Connection.cpp 2009-02-23 22:42:36 +0000
+++ b/storage/falcon/Connection.cpp 2009-03-23 14:57:48 +0000
@@ -1718,7 +1718,7 @@ void Connection::detachDatabase()
try
{
- if (transaction && transaction->state == Active)
+ if (transaction && transaction->getState() == Active)
transaction->rollback();
}
catch (SQLException &exception)
=== modified file 'storage/falcon/Database.cpp'
--- a/storage/falcon/Database.cpp 2009-03-09 12:12:14 +0000
+++ b/storage/falcon/Database.cpp 2009-03-23 14:57:48 +0000
@@ -1611,7 +1611,7 @@ void Database::shutdown()
if (systemConnection &&
systemConnection->transaction &&
- systemConnection->transaction->state == Active)
+ systemConnection->transaction->getState() == Active)
systemConnection->commit();
if (repositoryManager)
=== modified file 'storage/falcon/Makefile.am'
--- a/storage/falcon/Makefile.am 2009-03-10 12:37:26 +0000
+++ b/storage/falcon/Makefile.am 2009-03-23 14:57:48 +0000
@@ -205,6 +205,7 @@ falcon_headers= Agent.h Alias.h Applicat
TimeStamp.h \
Transaction.h \
TransactionManager.h \
+ TransactionState.h \
Trigger.h \
TriggerRecord.h \
Types.h Unicode.h UnTable.h User.h UserRole.h \
@@ -389,6 +390,7 @@ falcon_sources= Agent.cpp Alias.cpp \
TimeStamp.cpp \
Transaction.cpp \
TransactionManager.cpp \
+ TransactionState.cpp \
Trigger.cpp \
Unicode.cpp UnTable.cpp User.cpp \
UserRole.cpp Validation.cpp Value.cpp ValueEx.cpp Values.cpp \
=== modified file 'storage/falcon/Record.cpp'
--- a/storage/falcon/Record.cpp 2009-03-07 01:37:19 +0000
+++ b/storage/falcon/Record.cpp 2009-03-23 14:57:48 +0000
@@ -536,6 +536,11 @@ Transaction* Record::getTransaction()
return NULL;
}
+TransactionState* Record::getTransactionState() const
+{
+ return NULL;
+}
+
bool Record::isSuperceded()
{
return false;
=== modified file 'storage/falcon/Record.h'
--- a/storage/falcon/Record.h 2009-02-26 20:04:31 +0000
+++ b/storage/falcon/Record.h 2009-03-23 14:57:48 +0000
@@ -89,6 +89,7 @@ static const int recEndChain = 11; // e
class Format;
class Table;
class Transaction;
+class TransactionState;
class Value;
class Stream;
class Database;
@@ -104,6 +105,7 @@ class Record
{
public:
virtual Transaction* getTransaction();
+ virtual TransactionState* getTransactionState() const;
virtual TransId getTransactionId();
virtual int getSavePointId();
virtual void setSuperceded (bool flag);
=== modified file 'storage/falcon/RecordVersion.cpp'
--- a/storage/falcon/RecordVersion.cpp 2009-03-03 07:09:29 +0000
+++ b/storage/falcon/RecordVersion.cpp 2009-03-23 14:57:48 +0000
@@ -23,6 +23,7 @@
#include "Configuration.h"
#include "RecordVersion.h"
#include "Transaction.h"
+#include "TransactionState.h"
#include "TransactionManager.h"
#include "Table.h"
#include "Connection.h"
@@ -47,10 +48,16 @@ RecordVersion::RecordVersion(Table *tbl,
{
virtualOffset = 0;
transaction = trans;
+ transState = trans->transactionState;
transactionId = transaction->transactionId;
savePointId = transaction->curSavePointId;
superceded = false;
+ // Add a use count on the transaction state to ensure it lives as long
+ // as the record version object
+
+ transState->addRef();
+
if ((priorVersion = oldVersion))
{
priorVersion->addRef();
@@ -66,7 +73,7 @@ RecordVersion::RecordVersion(Table *tbl,
recordNumber = -1;
}
-RecordVersion::RecordVersion(Database* database, Serialize *stream) : Record(database, stream)
+RecordVersion::RecordVersion(Database* database, Serialize *stream) : Record(database, stream), transState(NULL)
{
// Reconstitute a record version and recursively restore all
// prior versions from 'stream'
@@ -104,6 +111,11 @@ RecordVersion::~RecordVersion()
while (prior)
prior = prior->releaseNonRecursive();
+
+ // Release the use count on the transaction state object
+
+ if (transState)
+ transState->release();
}
// Release the priorRecord reference without doing it recursively.
@@ -143,7 +155,7 @@ Record* RecordVersion::fetchVersionRecur
{
if (IS_READ_COMMITTED(trans->isolationLevel))
{
- int state = (recTransaction) ? recTransaction->state : 0;
+ int state = (recTransaction) ? recTransaction->transactionState->state : 0;
if (!transaction || state == Committed || recTransaction == trans)
return (getRecordData()) ? this : NULL;
@@ -295,6 +307,11 @@ Transaction* RecordVersion::getTransacti
return transaction;
}
+TransactionState* RecordVersion::getTransactionState() const
+{
+ return transState;
+}
+
bool RecordVersion::isSuperceded()
{
return superceded;
=== modified file 'storage/falcon/RecordVersion.h'
--- a/storage/falcon/RecordVersion.h 2009-01-14 22:33:44 +0000
+++ b/storage/falcon/RecordVersion.h 2009-03-23 14:57:48 +0000
@@ -27,6 +27,7 @@
#include "Record.h"
class Transaction;
+class TransactionState;
class SyncObject;
class RecordVersion : public Record
@@ -37,6 +38,7 @@ public:
virtual bool isSuperceded();
virtual Transaction* getTransaction();
+ virtual TransactionState* getTransactionState() const;
virtual TransId getTransactionId();
virtual int getSavePointId();
virtual void setSuperceded (bool flag);
@@ -73,6 +75,9 @@ public:
TransId transactionId;
int savePointId;
bool superceded;
+
+private:
+ TransactionState *transState;
};
#endif // !defined(AFX_RECORDVERSION_H__84FD1965_A97F_11D2_AB5C_0000C01D2301__INCLUDED_)
=== modified file 'storage/falcon/Table.cpp'
--- a/storage/falcon/Table.cpp 2009-03-09 12:12:14 +0000
+++ b/storage/falcon/Table.cpp 2009-03-23 14:57:48 +0000
@@ -2661,7 +2661,7 @@ bool Table::checkUniqueRecordVersion(int
syncPrior.unlock(); // release lock before wait
syncUnique->unlock(); // release lock before wait
- state = transaction->getRelativeState(activeTransaction,
+ state = transaction->getRelativeState(activeTransaction->transactionState,
activeTransaction->transactionId, WAIT_IF_ACTIVE);
if (state != Deadlock)
@@ -3768,7 +3768,7 @@ bool Table::validateUpdate(int32 recordN
Transaction *transaction = record->getTransaction();
- if (!transaction || transaction->state == Committed)
+ if (!transaction || transaction->getState() == Committed)
{
SET_RECORD_ACTIVE(record, false);
record->release(REC_HISTORY);
=== modified file 'storage/falcon/Transaction.cpp'
--- a/storage/falcon/Transaction.cpp 2009-03-05 09:20:35 +0000
+++ b/storage/falcon/Transaction.cpp 2009-03-23 14:57:48 +0000
@@ -20,6 +20,7 @@
#include <memory.h>
#include "Engine.h"
#include "Transaction.h"
+#include "TransactionState.h"
#include "Configuration.h"
#include "Database.h"
#include "Dbb.h"
@@ -89,12 +90,12 @@ Transaction::Transaction(Connection *cnc
freeSavePoints = NULL;
useCount = 1;
syncObject.setName("Transaction::syncObject");
- syncIsActive.setName("Transaction::syncActive");
syncDeferredIndexes.setName("Transaction::syncDeferredIndexes");
syncRecords.setName("Transaction::syncRecords");
syncSavepoints.setName("Transaction::syncSavepoints");
firstRecord = NULL;
lastRecord = NULL;
+ transactionState = new TransactionState();
initialize(cnct, seq);
}
@@ -112,14 +113,14 @@ void Transaction::initialize(Connection*
transactionManager = database->transactionManager;
systemTransaction = database->systemConnection == connection;
transactionId = seq;
- commitId = 0;
+ transactionState->transactionId = seq;
+ transactionState->commitId = 0;
chillPoint = &firstRecord;
commitTriggers = false;
hasUpdates = false;
hasLocks = false;
writePending = true;
pendingPageWrites = false;
- waitingFor = NULL;
curSavePointId = 0;
deferredIndexes = NULL;
backloggedRecords = NULL;
@@ -143,7 +144,7 @@ void Transaction::initialize(Connection*
if (seq == 0)
{
- state = Available;
+ transactionState->state = Available;
systemTransaction = false;
writePending = false;
@@ -159,21 +160,21 @@ void Transaction::initialize(Connection*
startTime = database->deltaTime;
blockingRecord = NULL;
thread = Thread::getThread("Transaction::initialize");
- syncIsActive.lock(NULL, Exclusive);
- state = Active;
+ transactionState->syncIsActive.lock(NULL, Exclusive);
+ transactionState->state = Active;
}
Transaction::~Transaction()
{
Tdelete++;
- if (state == Active)
+ if (transactionState->state == Active)
{
Log::debug("Deleting apparently active transaction %d\n", transactionId);
ASSERT(false);
- if (syncIsActive.ourExclusiveLock())
- syncIsActive.unlock();
+ if (transactionState->syncIsActive.ourExclusiveLock())
+ transactionState->syncIsActive.unlock();
}
if (inList)
@@ -196,6 +197,9 @@ Transaction::~Transaction()
if (deferredIndexes)
releaseDeferredIndexes();
+
+ if (transactionState)
+ transactionState->release();
}
void Transaction::commit()
@@ -217,7 +221,7 @@ void Transaction::commit()
Log::log(LogXARecovery, "%d: Commit %sTransaction %d\n",
database->deltaTime, (systemTransaction ? "System " : ""), transactionId);
- if (state == Active)
+ if (transactionState->state == Active)
{
Sync sync(&syncDeferredIndexes, "Transaction::commit(1)");
sync.lock(Shared);
@@ -279,11 +283,11 @@ void Transaction::commit()
// Set the commit transition id for this transaction
- commitId = INTERLOCKED_INCREMENT(transactionManager->transactionSequence);
+ transactionState->commitId = INTERLOCKED_INCREMENT(transactionManager->transactionSequence);
transactionManager->activeTransactions.remove(this);
transactionManager->committedTransactions.append(this);
- state = Committed;
+ transactionState->state = Committed;
// This is one of the few points where we have an exclusive lock on both the
// active and committed transaction list. Although this has nothing to do
@@ -298,7 +302,7 @@ void Transaction::commit()
syncCommitted.unlock();
syncActiveTransactions.unlock();
- syncIsActive.unlock(); // signal waiting transactions
+ transactionState->syncIsActive.unlock(); // signal waiting transactions
// signal a gopher to start processing this transaction
@@ -350,10 +354,11 @@ void Transaction::commitNoUpdates(void)
connection = NULL;
transactionId = 0;
+ transactionState->transactionId = 0;
writePending = false;
- state = Available;
+ transactionState->state = Available;
syncActiveTransactions.unlock();
- syncIsActive.unlock();
+ transactionState->syncIsActive.unlock();
release();
}
@@ -445,8 +450,8 @@ void Transaction::rollback()
inList = false;
transactionManager->activeTransactions.remove(this);
syncActiveTransactions.unlock();
- state = RolledBack;
- syncIsActive.unlock();
+ transactionState->state = RolledBack;
+ transactionState->syncIsActive.unlock();
// Finish the SerialLogTransaction and signal a gopher
@@ -463,7 +468,7 @@ void Transaction::rollback()
void Transaction::prepare(int xidLen, const UCHAR *xidPtr)
{
- if (state != Active)
+ if (transactionState->state != Active)
throw SQLEXCEPTION (RUNTIME_ERROR, "transaction is not active");
Log::log(LogXARecovery, "Prepare transaction %d: xidLen = %d\n", transactionId, xidLen);
@@ -478,7 +483,7 @@ void Transaction::prepare(int xidLen, co
}
database->pageWriter->waitForWrites(this);
- state = Limbo;
+ transactionState->state = Limbo;
// Flush a prepare record to the serial log
@@ -591,8 +596,9 @@ void Transaction::thaw(DeferredIndex * d
void Transaction::addRecord(RecordVersion * record)
{
ASSERT(record->recordNumber >= 0);
+
hasUpdates = true;
-
+
if (record->state == recLock)
hasLocks = true;
else if (record->state == recDeleted)
@@ -715,19 +721,34 @@ bool Transaction::visible(Transaction *
if (!transaction)
return true;
+ return visible(transaction->transactionState, forWhat);
+}
+
+
+/***
+@brief Determine if changes by another transaction are visible to this.
+@details This function is called for Consistent-Read transactions to determine
+ if the sent trans was committed before this transaction started. If not,
+ it is invisible to this transaction.
+***/
+
+bool Transaction::visible(const TransactionState* transState, int forWhat) const
+{
+ ASSERT(transState != NULL);
+
// If we're the transaction in question, consider us committed
- if (transId == transactionId)
+ if (transactionState == transState)
return true;
// If we're the system transaction, just use the state of the other transaction
if (database->systemConnection->transaction == this)
- return transaction->state == Committed;
+ return transState->state == Committed;
// If the other transaction is not yet committed, the trans is not visible.
- if (transaction->state != Committed)
+ if (transState->state != Committed)
return false;
// The other transaction is committed.
@@ -744,12 +765,13 @@ bool Transaction::visible(Transaction *
// If the other transaction committed after we started then it is not
// be visible to us
- if (transaction->commitId > transactionId)
+ if (transState->commitId > transactionId)
return false;
return true;
}
+
/***
@brief Determine if there is a need to lock this record for update.
***/
@@ -765,12 +787,12 @@ bool Transaction::needToLock(Record* rec
candidate != NULL;
candidate = candidate->getPriorVersion())
{
- Transaction *transaction = candidate->getTransaction();
- TransId transId = candidate->getTransactionId();
+ TransactionState* transState = candidate->getTransactionState();
+ ASSERT(transState != NULL);
- if (visible(transaction, transId, FOR_WRITING))
+ if (visible(transState, FOR_WRITING))
if (candidate->state == recDeleted)
- if (!transaction || transaction->state == Committed)
+ if (transState->state == Committed)
return false; // Committed and deleted
else
return true; // Just in case this rolls back.
@@ -832,24 +854,30 @@ State Transaction::getRelativeState(Reco
}
blockingRecord = record;
- State state = getRelativeState(record->getTransaction(), record->getTransactionId(), flags);
+ State state = getRelativeState(record->getTransactionState(), record->getTransactionId(), flags);
blockingRecord = NULL;
return state;
}
+
/***
@brief Get the relative state between this transaction and another.
***/
-State Transaction::getRelativeState(Transaction *transaction, TransId transId, uint32 flags)
+State Transaction::getRelativeState(TransactionState* transState, TransId transId, uint32 flags)
{
+ // Note: The structure of this method is still based on the
+ // original getRelativeState() - should be carefully rewritten
+
if (transactionId == transId)
return Us;
- // A record may still have the transId even after the trans itself has been deleted.
-
- if (!transaction)
+ // The following if test replaces the original if (!transaction)
+ // This could be improved by combining it with the last if test
+ // at the end of this function.
+
+ if (transState->state == Committed && transState->commitId < transactionId)
{
// All calls to getRelativeState are for the purpose of writing.
// So only ConsistentRead can get CommittedInvisible.
@@ -869,13 +897,13 @@ State Transaction::getRelativeState(Tran
return CommittedVisible;
}
- if (transaction->isActive())
+ if (transState->isActive())
{
if (flags & DO_NOT_WAIT)
return Active;
bool isDeadlock;
- waitForTransaction(transaction, 0 , &isDeadlock);
+ waitForTransaction(transState, 0 , &isDeadlock);
if (isDeadlock)
return Deadlock;
@@ -883,20 +911,21 @@ State Transaction::getRelativeState(Tran
return WasActive; // caller will need to re-fetch
}
- if (transaction->state == Committed)
+ if (transState->state == Committed)
{
// Return CommittedVisible if the other trans has a lower TransId and
// it was committed when we started.
- if (visible (transaction, transId, FOR_WRITING))
+ if (visible (transState, FOR_WRITING))
return CommittedVisible;
return CommittedInvisible;
}
- return (State) transaction->state;
+ return (State) transState->state;
}
+
void Transaction::dropTable(Table* table)
{
releaseDeferredIndexes(table);
@@ -942,7 +971,7 @@ bool Transaction::hasRecords(Table* tabl
void Transaction::writeComplete(void)
{
ASSERT(writePending);
- ASSERT(state == Committed);
+ ASSERT(transactionState->state == Committed);
releaseDeferredIndexes();
// Log::log(LogXARecovery, "%d: WriteComplete %sTransaction %d\n",
@@ -959,6 +988,7 @@ bool Transaction::waitForTransaction(Tra
}
+
// Wait for transaction, unless it would lead to deadlock.
// Returns the state of transation.
//
@@ -971,50 +1001,66 @@ bool Transaction::waitForTransaction(Tra
// use inline assembly or intrinsics to generate memory barrier instead of
// volatile.
-State Transaction::waitForTransaction(Transaction *transaction, TransId transId,
+State Transaction::waitForTransaction(TransactionState* transState, TransId transId,
bool *deadlock)
{
+ ASSERT(transState != NULL);
+
*deadlock = false;
State state;
- if(transaction)
- transaction->addRef();
+ // Increase the use count on the transaction state object to ensure
+ // the object the waitingFor pointer refers to does not get deleted
+
+ if(transState)
+ transState->addRef();
Sync syncActiveTransactions(&transactionManager->activeTransactions.syncObject,
"Transaction::waitForTransaction(1)");
syncActiveTransactions.lock(Shared);
- if (!transaction)
+ // If a transaction state object is not given, locate it by searching
+ // for the transaction in the active list
+
+ if (!transState)
{
+ Transaction* transaction;
+
// transaction parameter is not given, find transaction using its ID.
for (transaction = transactionManager->activeTransactions.first; transaction;
transaction = transaction->next)
{
if (transaction->transactionId == transId)
{
- transaction->addRef();
break;
}
}
+
+ // If the transaction is not found in the active list it is committed
+
+ if (!transaction)
+ return Committed;
+
+ transState = transaction->transactionState;
+ transState->addRef();
}
- if (!transaction)
- return Committed;
+ ASSERT(transState != NULL);
- if (transaction->state == Available || transaction->state == Committed)
+ if (transState->state == Available || transState->state == Committed)
{
- state = (State)transaction->state;
- transaction->release();
+ state = (State)transState->state;
+ transState->release();
return state;
}
- if (!COMPARE_EXCHANGE_POINTER(&waitingFor, NULL, transaction))
+ if (!COMPARE_EXCHANGE_POINTER(&transactionState->waitingFor, NULL, transState))
FATAL("waitingFor was not NULL");
- volatile Transaction *trans;
- for (trans = transaction->waitingFor; trans; trans = trans->waitingFor)
- if (trans == this)
+ volatile TransactionState *trans;
+ for (trans = transState->waitingFor; trans; trans = trans->waitingFor)
+ if (trans == transactionState)
{
*deadlock = true;
break;
@@ -1025,40 +1071,24 @@ State Transaction::waitForTransaction(Tr
try
{
syncActiveTransactions.unlock();
- transaction->waitForTransaction();
+ transState->waitForTransaction();
}
catch(...)
{
- if (!COMPARE_EXCHANGE_POINTER(&waitingFor, transaction, NULL))
- FATAL("waitingFor was not %p",transaction);
+ if (!COMPARE_EXCHANGE_POINTER(&transactionState->waitingFor, transState, NULL))
+ FATAL("waitingFor was not %p", transState);
throw;
}
}
- if (!COMPARE_EXCHANGE_POINTER(&waitingFor, transaction, NULL))
- FATAL("waitingFor was not %p",transaction);
+ if (!COMPARE_EXCHANGE_POINTER(&transactionState->waitingFor, transState, NULL))
+ FATAL("waitingFor was not %p", transState);
- state = (State)transaction->state;
- transaction->release();
+ state = (State)transState->state;
- return state;
-}
+ transState->release();
-void Transaction::waitForTransaction()
-{
- /***
- Thread *exclusiveThread = syncActive.getExclusiveThread();
-
- if (exclusiveThread)
- {
- char buffer[1024];
- connection->getCurrentStatement(buffer, sizeof(buffer));
- Log::debug("Blocking on %d: %s\n", exclusiveThread->threadId, buffer);
- }
- ***/
-
- Sync sync(&syncIsActive, "Transaction::waitForTransaction(2)");
- sync.lock(Shared, falcon_lock_wait_timeout * 1000);
+ return state;
}
void Transaction::addRef()
@@ -1339,7 +1369,7 @@ void Transaction::releaseRecordLocks(voi
void Transaction::print(void)
{
Log::debug(" %p Id %d, state %d, updates %d, wrtPend %d, records %d\n",
- this, transactionId, state, hasUpdates, writePending,
+ this, transactionId, transactionState->state, hasUpdates, writePending,
firstRecord != NULL);
}
@@ -1411,10 +1441,10 @@ void Transaction::getInfo(InfoTable* inf
// Need to decide if we want to include the startEvent and endEvent
// in this table.
- if (!(state == Available))
+ if (!(transactionState->state == Available))
{
int n = 0;
- infoTable->putString(n++, stateNames[state]);
+ infoTable->putString(n++, stateNames[transactionState->state]);
infoTable->putInt(n++, mySqlThreadId);
infoTable->putInt(n++, transactionId);
infoTable->putInt(n++, hasUpdates);
@@ -1422,7 +1452,7 @@ void Transaction::getInfo(InfoTable* inf
infoTable->putInt(n++, 0); // Number of dependencies, will be removed
infoTable->putInt(n++, 0); // was oldestActive);
infoTable->putInt(n++, firstRecord != NULL);
- infoTable->putInt(n++, (waitingFor) ? waitingFor->transactionId : 0);
+ infoTable->putInt(n++, (transactionState->waitingFor) ? transactionState->waitingFor->transactionId : 0);
char buffer[512];
@@ -1557,5 +1587,5 @@ void Transaction::validateRecords(void)
bool Transaction::committedBefore(TransId transactionId)
{
- return (commitId && commitId < transactionId);
+ return (transactionState->commitId && transactionState->commitId < transactionId);
}
=== modified file 'storage/falcon/Transaction.h'
--- a/storage/falcon/Transaction.h 2009-03-07 01:37:19 +0000
+++ b/storage/falcon/Transaction.h 2009-03-23 14:57:48 +0000
@@ -27,6 +27,7 @@
#include "SyncObject.h"
#include "SerialLog.h"
#include "SavePoint.h"
+#include "TransactionState.h"
static const int NO_TRANSACTION = 0;
@@ -44,27 +45,6 @@ class InfoTable;
class Thread;
class TransactionManager;
-// Transaction States
-
-enum State {
- Active, // 0
- Limbo, // 1
- Committed, // 2
- RolledBack, // 3
-
- // The following are 'relative states'. See getRelativeState()
-
- Us, // 4
- CommittedVisible, // 5
- CommittedInvisible, // 6
- WasActive, // 7
- Deadlock, // 8
-
- // And the remaining are for transactions pending reuse
-
- Available, // 9
- Initializing // 10
- };
struct TransState {
Transaction *transaction;
@@ -87,12 +67,13 @@ public:
Transaction(Connection *connection, TransId seq);
State getRelativeState(Record* record, uint32 flags);
- State getRelativeState (Transaction *transaction, TransId transId, uint32 flags);
+ State getRelativeState (TransactionState* ts, TransId transId, uint32 flags);
void removeRecordNoLock (RecordVersion *record);
void removeRecord(RecordVersion *record);
void removeRecord (RecordVersion *record, RecordVersion **ptr);
void commitRecords();
bool visible (Transaction *transaction, TransId transId, int forWhat);
+ bool visible(const TransactionState* transState, int forWhat) const;
bool needToLock(Record* record);
void addRecord (RecordVersion *record);
void prepare(int xidLength, const UCHAR *xid);
@@ -100,9 +81,9 @@ public:
void commit();
void release();
void addRef();
- void waitForTransaction();
+ //void waitForTransaction();
bool waitForTransaction (TransId transId);
- State waitForTransaction (Transaction *transaction, TransId transId, bool *deadlock);
+ State waitForTransaction (TransactionState* ts, TransId transId, bool *deadlock);
void dropTable(Table* table);
void truncateTable(Table* table);
bool hasRecords(Table* table);
@@ -134,19 +115,22 @@ public:
inline bool isActive()
{
- return state == Active || state == Limbo;
+ return transactionState->state == Active || transactionState->state == Limbo;
+ }
+
+ State getState() const
+ {
+ return static_cast<State>(transactionState->state);
}
Connection *connection;
Database *database;
TransactionManager *transactionManager;
TransId transactionId; // used also as startEvent by dep.mgr.
- TransId commitId; // used as commitEvent by dep.mgr.
TransId blockedBy;
int curSavePointId;
Transaction *next; // next in database
Transaction *prior; // next in database
- volatile Transaction *waitingFor;
SavePoint *savePoints;
SavePoint *freeSavePoints;
SavePoint localSavePoints[LOCAL_SAVE_POINTS];
@@ -167,7 +151,6 @@ public:
bool pendingPageWrites;
bool hasLocks;
SyncObject syncObject;
- SyncObject syncIsActive; // locked while transaction is active
SyncObject syncDeferredIndexes;
SyncObject syncRecords;
SyncObject syncSavepoints;
@@ -183,8 +166,8 @@ public:
uint32 deletedRecords; // active deleted records (exclusive of backllogged ones)
RecordVersion **chillPoint; // points to a pointer to the first non-chilled record
int scanIndexCount;
+ TransactionState* transactionState;
- volatile INTERLOCK_TYPE state;
volatile INTERLOCK_TYPE useCount;
volatile INTERLOCK_TYPE inList;
=== modified file 'storage/falcon/TransactionManager.cpp'
--- a/storage/falcon/TransactionManager.cpp 2009-03-18 13:31:34 +0000
+++ b/storage/falcon/TransactionManager.cpp 2009-03-23 14:57:48 +0000
@@ -19,6 +19,7 @@
#include "Engine.h"
#include "TransactionManager.h"
#include "Transaction.h"
+#include "TransactionState.h"
#include "Sync.h"
#include "Interlock.h"
#include "SQLError.h"
@@ -40,6 +41,11 @@ static const char THIS_FILE[]=__FILE__;
volatile int Talloc = 0; // Temp. will be removed. Used for tracing
volatile int Tdelete = 0; // new and delete of trans objects.
+// These are for debugging to trac number of object allocations
+extern volatile INTERLOCK_TYPE TSalloc;
+extern volatile INTERLOCK_TYPE TSdelete;
+
+
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
@@ -54,7 +60,7 @@ TransactionManager::TransactionManager(D
priorCommitted = 0;
priorRolledBack = 0;
rolledBackTransaction = new Transaction(database->systemConnection, 0);
- rolledBackTransaction->state = RolledBack;
+ rolledBackTransaction->transactionState->state = RolledBack;
rolledBackTransaction->inList = false;
syncObject.setName("TransactionManager::syncObject");
activeTransactions.syncObject.setName("TransactionManager::activeTransactions");
@@ -68,7 +74,7 @@ TransactionManager::~TransactionManager(
for (Transaction *transaction; (transaction = activeTransactions.first);)
{
transaction->inList = false;
- transaction->state = Committed;
+ transaction->transactionState->state = Committed;
activeTransactions.first = transaction->next;
transaction->release();
}
@@ -113,8 +119,8 @@ Transaction* TransactionManager::startTr
Transaction *transaction;
for(transaction = activeTransactions.first; transaction; transaction = transaction->next)
- if (transaction->state == Available)
- if (COMPARE_EXCHANGE(&transaction->state, Available, Initializing))
+ if (transaction->transactionState->state == Available)
+ if (COMPARE_EXCHANGE(&transaction->transactionState->state, Available, Initializing))
{
transaction->initialize(connection, INTERLOCKED_INCREMENT(transactionSequence));
return transaction;
@@ -214,7 +220,7 @@ void TransactionManager::commitByXid(int
again = false;
for (Transaction *transaction = activeTransactions.first; transaction; transaction = transaction->next)
- if (transaction->state == Limbo && transaction->isXidEqual(xidLength, xid))
+ if (transaction->getState() == Limbo && transaction->isXidEqual(xidLength, xid))
{
sync.unlock();
transaction->commit();
@@ -235,7 +241,7 @@ void TransactionManager::rollbackByXid(i
again = false;
for (Transaction *transaction = activeTransactions.first; transaction; transaction = transaction->next)
- if (transaction->state == Limbo && transaction->isXidEqual(xidLength, xid))
+ if (transaction->getState() == Limbo && transaction->isXidEqual(xidLength, xid))
{
sync.unlock();
transaction->rollback();
@@ -324,8 +330,8 @@ void TransactionManager::purgeTransactio
Transaction* transaction = committedTransactions.first;
while ((transaction != NULL) &&
- (transaction->state == Committed) &&
- (transaction->commitId <= oldestActive) &&
+ (transaction->getState() == Committed) &&
+ (transaction->transactionState->commitId <= oldestActive) &&
!transaction->writePending)
{
transaction->commitRecords();
@@ -365,10 +371,10 @@ void TransactionManager::getSummaryInfo(
for (transaction = activeTransactions.first; transaction; transaction = transaction->next)
{
- if (transaction->state == Active)
+ if (transaction->getState() == Active)
++numberActive;
- if (transaction->state == Committed)
+ if (transaction->getState() == Committed)
++numberPendingCommit;
}
syncActive.unlock();
@@ -398,13 +404,13 @@ void TransactionManager::reportStatistic
time_t maxTime = 0;
for (transaction = activeTransactions.first; transaction; transaction = transaction->next)
- if (transaction->state == Active)
+ if (transaction->getState() == Active)
{
++active;
time_t ageTime = database->deltaTime - transaction->startTime;
maxTime = MAX(ageTime, maxTime);
}
- else if (transaction->state == Available)
+ else if (transaction->getState() == Available)
{
++available;
}
@@ -455,7 +461,7 @@ Transaction* TransactionManager::findTra
void TransactionManager::removeTransaction(Transaction* transaction)
{
- if (transaction->state == Committed)
+ if (transaction->getState() == Committed)
{
Sync sync(&committedTransactions.syncObject, "TransactionManager::removeTransaction(1)");
sync.lock(Exclusive);
@@ -488,7 +494,7 @@ void TransactionManager::printBlockage(v
sync.lock (Shared);
for (Transaction *trans = activeTransactions.first; trans; trans = trans->next)
- if (trans->state == Active && !trans->waitingFor)
+ if (trans->getState() == Active && !trans->transactionState->waitingFor)
trans->printBlocking(0);
Synchronize::freezeSystem();
@@ -497,6 +503,6 @@ void TransactionManager::printBlockage(v
void TransactionManager::printBlocking(Transaction* transaction, int level)
{
for (Transaction *trans = activeTransactions.first; trans; trans = trans->next)
- if (trans->state == Active && trans->waitingFor == transaction)
+ if (trans->getState() == Active && trans->transactionState->waitingFor == transaction->transactionState)
trans->printBlocking(level);
}
=== added file 'storage/falcon/TransactionState.cpp'
--- a/storage/falcon/TransactionState.cpp 1970-01-01 00:00:00 +0000
+++ b/storage/falcon/TransactionState.cpp 2009-03-23 14:57:48 +0000
@@ -0,0 +1,48 @@
+/* Copyright (C) 2009 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
+ the Free Software Foundation; version 2 of the License.
+
+ 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 */
+
+
+#include "TransactionState.h"
+#include "Interlock.h"
+#include "Sync.h"
+
+extern uint falcon_lock_wait_timeout;
+
+TransactionState::TransactionState() : commitId(0), waitingFor(NULL), useCount(1)
+{
+ syncIsActive.setName("TransactionState::syncIaActive");
+}
+
+
+void TransactionState::waitForTransaction()
+{
+ Sync sync(&syncIsActive, "TransactionState::waitForTransaction");
+ sync.lock(Shared, falcon_lock_wait_timeout * 1000);
+}
+
+
+void TransactionState::addRef()
+{
+ INTERLOCKED_INCREMENT(useCount);
+}
+
+
+void TransactionState::release()
+{
+ ASSERT(useCount > 0);
+
+ if (INTERLOCKED_DECREMENT(useCount) == 0)
+ delete this;
+}
=== added file 'storage/falcon/TransactionState.h'
--- a/storage/falcon/TransactionState.h 1970-01-01 00:00:00 +0000
+++ b/storage/falcon/TransactionState.h 2009-03-23 14:57:48 +0000
@@ -0,0 +1,79 @@
+/* Copyright (C) 2009 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
+ the Free Software Foundation; version 2 of the License.
+
+ 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 */
+
+#if !defined(TRANSACTION_STATE_H)
+#define TRANSACTION_STATE_H
+
+#include "Engine.h"
+#include "SyncObject.h"
+
+// Transaction States
+
+enum State {
+ Active, // 0
+ Limbo, // 1
+ Committed, // 2
+ RolledBack, // 3
+
+ // The following are 'relative states'. See getRelativeState()
+
+ Us, // 4
+ CommittedVisible, // 5
+ CommittedInvisible, // 6
+ WasActive, // 7
+ Deadlock, // 8
+
+ // And the remaining are for transactions pending reuse
+
+ Available, // 9
+ Initializing // 10
+ };
+
+
+// TransactionState stores the main state information for a Transaction.
+// The reason for having this as a separate class instead of having it
+// stored in the Transaction object is that we want to be able to purge
+// transaction objects earlier than when record versions are scavanged.
+// To be able to do that we let the TransactionState object live as long
+// as there is RecordVersions refering to it while we purge the Transaction
+// objects earlier.
+
+class TransactionState
+{
+public:
+ TransactionState();
+
+ void waitForTransaction();
+
+ bool isActive() const
+ {
+ return state == Active || state == Limbo;
+ }
+
+ void addRef();
+ void release();
+
+public:
+ TransId transactionId; // used also as startEvent by dep.mgr.
+ TransId commitId; // used as commitEvent by dep.mgr.
+ volatile INTERLOCK_TYPE state;
+ SyncObject syncIsActive;
+ volatile TransactionState* waitingFor; // Used for deadlock detection
+
+private:
+ volatile INTERLOCK_TYPE useCount;
+};
+
+#endif
Attachment: [text/bzr-bundle] bzr/vvaintroub@mysql.com-20090323181718-dmzfhsgx1cl0pfal.bundle
| Thread |
|---|
| • bzr commit into mysql-6.0-falcon-team branch (vvaintroub:3070) | Vladislav Vaintroub | 23 Mar |
