bzr commit into mysql-6.0-falcon-team branch (klewis:2940) Bug#41194

[Kevin Lewis]

#At file:///C:/Work/bzr/Merge/mysql-6.0-falcon-team/

 2940 Kevin Lewis	2008-12-19
      Bug#41194 - The Transaction knows about the serial log.  
      Let it make calls to SerialLogRecord functions directly.
      Separate the serial log flush of commit and rollback records
      from when we allow the gophers to start processing them.
      Once those records are flushed, the recovery will be able to 
      process them, but we do not want the gophers to do that until 
      the commit or rollback is fully finished.  
      There is no need for the prepare flush to also start a gopher.
      Also, since the Transaction already knows about the SerialLog,
      there is no reason to pass those calls through Database or Dbb.
modified:
  storage/falcon/Database.cpp
  storage/falcon/Database.h
  storage/falcon/Dbb.cpp
  storage/falcon/Dbb.h
  storage/falcon/SRLCommit.cpp
  storage/falcon/SRLPrepare.cpp
  storage/falcon/SRLRollback.cpp
  storage/falcon/SRLRollback.h
  storage/falcon/SerialLogRecord.cpp
  storage/falcon/SerialLogRecord.h
  storage/falcon/Transaction.cpp
  storage/falcon/TransactionManager.cpp

per-file messages:
  storage/falcon/Database.cpp
    The Transaction knows about the serial log.  There is no
    reason to pass these through Database
  storage/falcon/Database.h
    The Transaction knows about the serial log.  There is no
    reason to pass these through Database
  storage/falcon/Dbb.cpp
    The Transaction knows about the serial log.  There is no
    reason to pass commit, prepare, and rollback through Dbb
  storage/falcon/Dbb.h
    The Transaction knows about the serial log.  There is no
    reason to pass commit, prepare, and rollback through Dbb
  storage/falcon/SRLCommit.cpp
    Do not mark the srlTransaction as committed and wake up 
    a gopher as soon as it is durable.  
    Do that later in Transaction::commit()
  storage/falcon/SRLPrepare.cpp
    No need to wake up a gopher for a prepare.  There is nothing for it to do.
  storage/falcon/SRLRollback.cpp
    Just pass in the transaction like in similar append() functions.
    Do not mark the srlTransaction as rolledBack and wake up 
    a gopher as soon as this transaction rollback is durable.  
    Do that later in Transaction::rollback()
  storage/falcon/SRLRollback.h
    Just pass in the transaction like in similar append() functions.
  storage/falcon/SerialLogRecord.cpp
    The Transaction knows about the serial log.  There is no
    reason to pass the wakeup through SerialLogRecord.
  storage/falcon/SerialLogRecord.h
    The Transaction knows about the serial log.  There is no
    reason to pass the wakeup through SerialLogRecord.
  storage/falcon/Transaction.cpp
    The Transaction knows about the serial log.  Let it make calls
    to SerialLogRecord functions directly.
    Separate the serial log flush of commit and rollback records
    from when we allow the gophers to start processing them.
    Once those records are flushed, the recovery will be able to 
    process them, but we do not want the gophers to do that until 
    the commit or rollback is fully finished.
  storage/falcon/TransactionManager.cpp
    cleanup
=== modified file 'storage/falcon/Database.cpp'
--- a/storage/falcon/Database.cpp	2008-11-20 17:05:50 +0000
+++ b/storage/falcon/Database.cpp	2008-12-19 06:38:58 +0000
@@ -2251,16 +2251,6 @@ void Database::deleteRepositoryBlob(cons
 	repository->deleteBlob (volume, blobId, transaction);	
 }
 
-void Database::commit(Transaction *transaction)
-{
-	dbb->commit(transaction);
-}
-
-void Database::rollback(Transaction *transaction)
-{
-	dbb->rollback(transaction->transactionId, transaction->hasUpdates);
-}
-
 void Database::renameTable(Table* table, const char* newSchema, const char* newName)
 {
 	newSchema = getSymbol(newSchema);

=== modified file 'storage/falcon/Database.h'
--- a/storage/falcon/Database.h	2008-10-16 01:04:03 +0000
+++ b/storage/falcon/Database.h	2008-12-19 06:38:58 +0000
@@ -116,8 +116,6 @@ public:
 
 	void			shutdownNow();
 	void			dropDatabase();
-	void			rollback (Transaction *transaction);
-	void			commit (Transaction *transaction);
 	void			start();
 	void			deleteRepositoryBlob(const char *schema, const char *repositoryName, int volume,
int64 blobId, Transaction *transaction);
 	void			deleteRepository (Repository *repository);

=== modified file 'storage/falcon/Dbb.cpp'
--- a/storage/falcon/Dbb.cpp	2008-10-30 00:22:54 +0000
+++ b/storage/falcon/Dbb.cpp	2008-12-19 06:38:58 +0000
@@ -1169,34 +1169,6 @@ void Dbb::reportStatistics()
 	priorFlushWrites = flushWrites;
 }
 
-void Dbb::commit(Transaction *transaction)
-{
-	if (transaction->hasUpdates)
-		serialLog->logControl->commit.append(transaction);
-}
-
-void Dbb::prepareTransaction(TransId transId, int xidLength, const UCHAR *xid)
-{
-	serialLog->logControl->prepare.append(transId, xidLength, xid);
-}
-
-void Dbb::rollback(TransId transId, bool updateTransaction)
-{
-	if (updateTransaction)
-		{
-		if (serialLog)
-			serialLog->logControl->rollback.append(transId, updateTransaction);
-		//flush();
-		}
-}
-
-/***
-void Dbb::setRecovering(bool flag)
-{
-	recovering = flag;
-}
-***/
-
 void Dbb::enableSerialLog()
 {
 	Bdb *bdb = fetchPage(HEADER_PAGE, PAGE_header, Exclusive);

=== modified file 'storage/falcon/Dbb.h'
--- a/storage/falcon/Dbb.h	2008-10-30 00:22:54 +0000
+++ b/storage/falcon/Dbb.h	2008-12-19 06:38:58 +0000
@@ -113,10 +113,7 @@ public:
 	void	createSection(int32 sectionId, TransId transId);
 	void	dropDatabase();
 	void	enableSerialLog();
-	void	rollback (TransId transId, bool updateTransaction);
 	void	updateRecord(int32 sectionId, int32 recordId, Stream *stream, TransId transId, bool
earlyWrite);
-	void	prepareTransaction(TransId transId, int xidLength, const UCHAR *xid);
-	void	commit(Transaction *transaction);
 	void	reportStatistics();
 	bool	hasDirtyPages();
 	bool	deleteShadow (DatabaseCopy *shadow);

=== modified file 'storage/falcon/SRLCommit.cpp'
--- a/storage/falcon/SRLCommit.cpp	2007-10-04 20:45:34 +0000
+++ b/storage/falcon/SRLCommit.cpp	2008-12-19 06:38:58 +0000
@@ -46,18 +46,16 @@ void SRLCommit::append(Transaction *tran
 	transaction->addRef();
 	START_RECORD(srlCommit, "SRLCommit::append");
 	putInt(transaction->transactionId);
-	//uint64 commitBlockNumber = log->nextBlockNumber;
 	uint64 commitBlockNumber = log->getWriteBlockNumber();
 	SerialLogTransaction *srlTransaction =
log->getTransaction(transaction->transactionId);
-	
+	srlTransaction->setTransaction(transaction);
+
+	// Flush transactions with changes immediately for durability
+
 	if (transaction->hasUpdates)
 		log->flush(false, commitBlockNumber, &sync);
 	else
 		sync.unlock();
-
-	srlTransaction->setTransaction(transaction);
-	srlTransaction->setState(sltCommitted);
-	wakeup();
 }
 
 void SRLCommit::read()

=== modified file 'storage/falcon/SRLPrepare.cpp'
--- a/storage/falcon/SRLPrepare.cpp	2008-07-24 08:45:03 +0000
+++ b/storage/falcon/SRLPrepare.cpp	2008-12-19 06:38:58 +0000
@@ -47,15 +47,13 @@ void SRLPrepare::append(TransId transId,
 	putInt(transId);
 	putInt(xidLength);
 	putData(xidLength, xid);
-	SerialLogTransaction *transaction = log->getTransaction(transId);
+	SerialLogTransaction *srlTransaction = log->getTransaction(transId);
 
 	log->flush(false, log->nextBlockNumber, &sync);
 
-	if (transaction)
-		transaction->setState(sltPrepared);
+	if (srlTransaction)
+		srlTransaction->setState(sltPrepared);
 
-	if (transaction)
-		wakeup();
 }
 
 void SRLPrepare::read()

=== modified file 'storage/falcon/SRLRollback.cpp'
--- a/storage/falcon/SRLRollback.cpp	2008-07-24 08:45:03 +0000
+++ b/storage/falcon/SRLRollback.cpp	2008-12-19 06:38:58 +0000
@@ -38,23 +38,16 @@ SRLRollback::~SRLRollback()
 
 }
 
-void SRLRollback::append(TransId transId, bool updateTransaction)
+void SRLRollback::append(Transaction *transaction)
 {
 	START_RECORD(srlRollback, "SRLRollback::append");
-	putInt(transId);
+	putInt(transaction->transactionId);
 	uint64 commitBlockNumber = log->nextBlockNumber;
-	SerialLogTransaction *transaction = log->findTransaction(transId);
 
-	if (updateTransaction)
+	if (transaction->hasUpdates)
 		log->flush(false, commitBlockNumber, &sync);
 	else
 		sync.unlock();
-	
-	if (transaction)
-		{
-		transaction->setState(sltRolledBack);
-		wakeup();
-		}
 }
 
 void SRLRollback::read()

=== modified file 'storage/falcon/SRLRollback.h'
--- a/storage/falcon/SRLRollback.h	2007-09-20 15:44:25 +0000
+++ b/storage/falcon/SRLRollback.h	2008-12-19 06:38:58 +0000
@@ -33,7 +33,7 @@ public:
 	virtual void print();
 	virtual void pass1();
 	virtual void read();
-	void append(TransId transId, bool updateTransaction);
+	void append(Transaction *transaction);
 	SRLRollback();
 	virtual ~SRLRollback();
 

=== modified file 'storage/falcon/SerialLogRecord.cpp'
--- a/storage/falcon/SerialLogRecord.cpp	2008-11-20 17:05:50 +0000
+++ b/storage/falcon/SerialLogRecord.cpp	2008-12-19 06:38:58 +0000
@@ -226,11 +226,6 @@ void SerialLogRecord::startRecord()
 	log->startRecord();
 }
 
-void SerialLogRecord::wakeup()
-{
-	log->wakeup();
-}
-
 void SerialLogRecord::putStream(Stream *stream)
 {
 	putInt(stream->totalLength);

=== modified file 'storage/falcon/SerialLogRecord.h'
--- a/storage/falcon/SerialLogRecord.h	2008-11-14 02:30:11 +0000
+++ b/storage/falcon/SerialLogRecord.h	2008-12-19 06:38:58 +0000
@@ -98,7 +98,6 @@ public:
 	int				getInt(const UCHAR** ptr);
 	const UCHAR*	getData(int32 length);
 	void			putStream (Stream *stream);
-	void			wakeup();
 	void			startRecord();
 	void			putData(uint32 length, const UCHAR *data);
 	void			putInt(int32 number);

=== modified file 'storage/falcon/Transaction.cpp'
--- a/storage/falcon/Transaction.cpp	2008-12-16 22:48:55 +0000
+++ b/storage/falcon/Transaction.cpp	2008-12-19 06:38:58 +0000
@@ -37,6 +37,7 @@
 #include "TransactionManager.h"
 #include "SerialLog.h"
 #include "SerialLogControl.h"
+#include "SerialLogTransaction.h"
 #include "InfoTable.h"
 #include "Thread.h"
 #include "Format.h"
@@ -269,7 +270,7 @@ void Transaction::commit()
 	// Write the commit message to the serial log for durability.
 	// If a crash happens after this, the recover will commit.
 
-	database->commit(this);
+	database->serialLog->logControl->commit.append(this);
 
 	// Transfer transaction from active list to committed list, set committed state
 
@@ -298,6 +299,12 @@ void Transaction::commit()
 	syncActiveTransactions.unlock();
 	
 	syncIsActive.unlock(); // signal waiting transactions
+	
+	// signal a gopher to start processing this transaction
+
+	SerialLogTransaction *srlTransaction =
database->serialLog->getTransaction(transactionId);
+	srlTransaction->setState(sltCommitted);
+	database->serialLog->wakeup();
 
 	delete [] xid;
 	xid = NULL;
@@ -414,12 +421,13 @@ void Transaction::rollback()
 
 	ASSERT(writePending);
 	writePending = false;
-	
+
 	if (hasUpdates)
+		{
 		database->serialLog->preCommit(this);
-		
-	database->rollback(this);
-	
+		database->serialLog->logControl->rollback.append(this);
+		}
+
 	if (xid)
 		{
 		delete [] xid;
@@ -436,6 +444,16 @@ void Transaction::rollback()
 	syncActiveTransactions.unlock();
 	state = RolledBack;
 	syncIsActive.unlock();
+
+	// Finish the SerialLogTransaction and signal a gopher
+
+	if (hasUpdates)
+		{
+		SerialLogTransaction *srlTransaction =
database->serialLog->getTransaction(transactionId);
+		srlTransaction->setState(sltRolledBack);
+		database->serialLog->wakeup();
+		}
+
 	release();
 }
 
@@ -458,7 +476,10 @@ void Transaction::prepare(int xidLen, co
 		
 	database->pageWriter->waitForWrites(this);
 	state = Limbo;
-	database->dbb->prepareTransaction(transactionId, xidLength, xid);
+
+	// Flush a prepare record to the serial log
+
+	database->serialLog->logControl->prepare.append(transactionId, xidLength, xid);
 
 	Sync sync(&syncDeferredIndexes, "Transaction::prepare");
 	sync.lock(Shared);
@@ -1421,26 +1442,11 @@ void Transaction::getInfo(InfoTable* inf
 void Transaction::fullyCommitted(void)
 {
 	ASSERT(inList);
+	ASSERT(!isActive());
 
 	if (useCount < 2)
 		Log::debug("Transaction::fullyCommitted: Unusual use count=%d\n", useCount);
 
-	// The commit record is flushed to the serial log before the transaction
-	// is fully committed and waiting threads are signalled.  This gopher may
-	// have picked up that record too soon, so wait for that transaction.
-
-	while (isActive())
-		{
-		try
-			{
-			Sync sync(&syncIsActive, "Transaction::fullyCommitted");
-			sync.lock(Shared, 1000);
-			}
-		catch  (...)
-			{
-			}
-		}
-
 	writeComplete();
 	releaseCommittedTransaction();
 }

=== modified file 'storage/falcon/TransactionManager.cpp'
--- a/storage/falcon/TransactionManager.cpp	2008-12-16 20:40:38 +0000
+++ b/storage/falcon/TransactionManager.cpp	2008-12-19 06:38:58 +0000
@@ -365,9 +365,9 @@ void TransactionManager::purgeTransactio
 
 	// Check for any fully mature transactions to ditch
   
-    Transaction* transaction = committedTransactions.first;
+	Transaction* transaction = committedTransactions.first;
 
-    while ((transaction != NULL) &&
+	while ((transaction != NULL) &&
 		   (transaction->state == Committed) &&
 		   (transaction->commitId < oldestActive) &&
 		   !transaction->writePending)