Fennel: LogicalTxnTest Class Reference (original) (raw)

Inheritance diagram for LogicalTxnTest:

Public Member Functions
	LogicalTxnTest ()
void	testCaseSetUp ()
	Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.
void	testTxn (int nActions, int iCheckpoint=-1, int iSvpt=-1)
void	testActions (int nActions, int iFirst)
void	testRollback (int nActions, bool checkpoint=false)
void	testTxnIdSequence ()
void	testRollbackEmpty ()
void	testRollbackShort ()
void	testRollbackLong ()
void	testRollbackSavepointNoGap ()
void	testRollbackSavepointGap ()
void	testRollbackSavepoint (bool gap)
void	testCheckpointCommitSavepoint ()
void	testCommit (int nActions, bool checkpoint=false)
void	testCommitEmpty ()
void	testCommitShort ()
void	testCommitLong ()
void	testCheckpointCommitEmpty ()
void	testCheckpointCommitShort ()
void	testCheckpointCommitLong ()
void	testCheckpointRollbackShort ()
void	testCheckpointRollbackLong ()
virtual LogicalTxnClassId	getParticipantClassId () const
	Returns:the LogicalTxnClassId for this participant; this will be used during recovery to find the correct LogicalTxnParticipantFactory
virtual void	describeParticipant (ByteOutputStream &logStream)
	Called by LogicalTxn the first time an action is logged for this participant.
virtual void	redoLogicalAction (LogicalActionType actionType, ByteInputStream &logStream)
	Performs redo for one logical action during recovery.
virtual void	undoLogicalAction (LogicalActionType actionType, ByteInputStream &logStream)
	Performs undo for one logical action during rollback or recovery.
virtual SharedLogicalTxnParticipant	loadParticipant (LogicalTxnClassId classId, ByteInputStream &logStream)
	Recovers a LogicalTxnParticipant from the log.
virtual void	openStorage (DeviceMode openMode)
virtual void	openSegmentStorage (DeviceMode openMode)
virtual void	openRandomSegment ()
SharedSegment	createLinearDeviceSegment (DeviceId deviceId, uint nPages)
void	closeLinearSegment ()
void	closeRandomSegment ()
void	closeVersionedRandomSegment ()
void	closeSnapshotRandomSegment ()
virtual void	closeStorage ()
Cache &	getCache ()
virtual SharedCache	newCache ()
SharedRandomAccessDevice	openDevice (std::string devName, DeviceMode openMode, uint nDevicePages, DeviceId deviceId)
virtual void	testCaseTearDown ()
	Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.
void	closeDevice (DeviceId deviceId, SharedRandomAccessDevice &pDevice)
TestSuite *	releaseTestSuite ()
void	beforeTestCase (std::string testCaseName)
void	afterTestCase (std::string testCaseName)
virtual void	notifyTrace (std::string source, TraceLevel level, std::string message)
	Receives notification when a trace event occurs.
virtual TraceLevel	getSourceTraceLevel (std::string source)
	Gets the level at which a particular source should be traced.
Static Public Member Functions
static void	readParams (int argc, char **argv)
	Parses the command line.
Static Public Attributes
static ParamName	paramTestSuiteName
static ParamName	paramTraceFileName
static ParamName	paramDictionaryFileName
static ParamName	paramTraceLevel
static ParamName	paramStatsFileName
static ParamName	paramTraceStdout
static ParamName	paramDegreeOfParallelism
static ConfigMap	configMap
	Configuration parameters.
Protected Types
enum	VictimPolicy { victimTwoQ, victimLRU, victimRandom }
	The available victim policy implementations. More...
Protected Member Functions
void	snooze (uint nSeconds)
LogicalTxn *	getLogicalTxn ()
	Returns:LogicalTxn being participated in, or null if no txn in progress; null is also returned during recovery
bool	isLoggingEnabled () const
	Returns:true if actions should be logged; this is false during recovery
Protected Attributes
SharedSegmentFactory	pSegmentFactory
SharedSegment	pLinearSegment
	Segment supporting linear page allocation.
SharedSegment	pRandomSegment
	(Optional) segment supporting random page allocation.
SharedSegment	pVersionedRandomSegment
	(Optional) segment supporting versioned random page allocation.
SharedSegment	pSnapshotRandomSegment
	(Optional) segment supporting snapshot random page allocation.
VictimPolicy	victimPolicy
	VictimPolicy to instantiate.
CacheParams	cacheParams
	Parameters for cache initialization.
SharedCache	pCache
	Cache instance being tested.
SharedRandomAccessDevice	pRandomAccessDevice
	The default cached device.
uint	nMemPages
	Size of cache in memory pages.
uint	nDiskPages
	Size of device in disk pages.
uint	cbPageFull
	Disk page size.
DeviceId	dataDeviceId
	Fixed ID to assign to data device.
TestSuite *	pTestSuite
	Boost test suite.
boost::shared_ptr< TestBase >	pTestObj
std::ofstream	traceStream
	Output file stream for tracing.
StrictMutex	traceMutex
	Protects traceStream.
std::string	testName
	Name of test.
TraceLevel	traceLevel
	Level at which to trace test execution.
FileStatsTarget	statsTarget
	Output for stats.
StatsTimer	statsTimer
	Timer for stats collection.
bool	traceStdout
	Copy trace output to stdout.
bool	traceFile
	Copy trace output to file.
TestCaseGroup	defaultTests
TestCaseGroup	extraTests
Static Protected Attributes
static bool	runAll
	Run all test cases, including the extra tests.
static std::string	runSingle
	Run only the test case of this name.
Private Types
typedef std::pair< int, int >	ExpectedRange
Private Member Functions
void	rollbackFull ()
void	commit ()
void	checkpointTxnLog (LogicalTxnLogCheckpointMemento &)
SharedLogicalRecoveryLog	createRecoveryLog ()
Private Attributes
SharedLogicalTxnLog	pTxnLog
LogicalTxnLogCheckpointMemento	firstCheckpointMemento
LogicalTxnLogCheckpointMemento	intermediateCheckpointMemento
LogicalTxnLogCheckpointMemento	finalCheckpointMemento
SavepointId	svptId
PseudoUuid	onlineUuid
std::vector< ExpectedRange >	expected
Static Private Attributes
static const int	participantDescription
static const LogicalActionType	ACTION_TEST

Detailed Description

Definition at line 40 of file LogicalTxnTest.cpp.

Member Typedef Documentation

Member Enumeration Documentation

The available victim policy implementations.

Enumerator:

| victimTwoQ | | | -------------- | | | victimLRU | | | victimRandom | |

Definition at line 44 of file CacheTestBase.h.

Constructor & Destructor Documentation

| LogicalTxnTest::LogicalTxnTest | ( | | ) | [inline, explicit] | | ------------------------------ | - | | - | -------------------- |

Definition at line 64 of file LogicalTxnTest.cpp.

References PseudoUuid::generateInvalid(), onlineUuid, testCheckpointCommitEmpty(), testCheckpointCommitLong(), testCheckpointCommitSavepoint(), testCheckpointCommitShort(), testCheckpointRollbackLong(), testCheckpointRollbackShort(), testCommitEmpty(), testCommitLong(), testCommitShort(), testRollbackEmpty(), testRollbackLong(), testRollbackSavepointGap(), testRollbackSavepointNoGap(), testRollbackShort(), and testTxnIdSequence().

Member Function Documentation

| void LogicalTxnTest::rollbackFull | ( | | ) | [private] | | --------------------------------- | - | | - | ----------- |

| void LogicalTxnTest::commit | ( | | ) | [private] | | --------------------------- | - | | - | ----------- |

| void LogicalTxnTest::testCaseSetUp | ( | | ) | [inline, virtual] | | ---------------------------------- | - | | - | ------------------- |

Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.

Default is no-op.

Reimplemented from TestBase.

Definition at line 88 of file LogicalTxnTest.cpp.

References expected.

void LogicalTxnTest::testTxn	(	int	nActions,
int	iCheckpoint = -1,
int	iSvpt = -1
)

Definition at line 387 of file LogicalTxnTest.cpp.

References ACTION_TEST, checkpointTxnLog(), DeviceMode::createNew, LogicalTxn::createSavepoint(), LogicalTxn::endLogicalAction(), firstCheckpointMemento, LogicalTxnParticipant::getLogicalTxn(), intermediateCheckpointMemento, LogicalTxnLog::newLogicalTxnLog(), onlineUuid, SegStorageTestBase::openStorage(), CacheTestBase::pCache, SegStorageTestBase::pLinearSegment, SegStorageTestBase::pSegmentFactory, LogicalTxnParticipant::pTxn, pTxnLog, and svptId.

Referenced by testCheckpointCommitSavepoint(), testCommit(), testRollback(), testRollbackSavepoint(), and testTxnIdSequence().

void LogicalTxnTest::testActions	(	int	nActions,
int	iFirst
)

void LogicalTxnTest::testRollback	(	int	nActions,
bool	checkpoint = false
)

| void LogicalTxnTest::testTxnIdSequence | ( | | ) | | -------------------------------------- | - | | - |

| void LogicalTxnTest::testRollbackEmpty | ( | | ) | | -------------------------------------- | - | | - |

| void LogicalTxnTest::testRollbackShort | ( | | ) | | -------------------------------------- | - | | - |

| void LogicalTxnTest::testRollbackLong | ( | | ) | | ------------------------------------- | - | | - |

| void LogicalTxnTest::testRollbackSavepointNoGap | ( | | ) | | ----------------------------------------------- | - | | - |

| void LogicalTxnTest::testRollbackSavepointGap | ( | | ) | | --------------------------------------------- | - | | - |

void LogicalTxnTest::testRollbackSavepoint	(	bool	gap	)

| void LogicalTxnTest::testCheckpointCommitSavepoint | ( | | ) | | -------------------------------------------------- | - | | - |

void LogicalTxnTest::testCommit	(	int	nActions,
bool	checkpoint = false
)

Definition at line 365 of file LogicalTxnTest.cpp.

References commit(), createRecoveryLog(), expected, firstCheckpointMemento, intermediateCheckpointMemento, and testTxn().

Referenced by testCheckpointCommitEmpty(), testCheckpointCommitLong(), testCheckpointCommitShort(), testCommitEmpty(), testCommitLong(), and testCommitShort().

| void LogicalTxnTest::testCommitEmpty | ( | | ) | | ------------------------------------ | - | | - |

| void LogicalTxnTest::testCommitShort | ( | | ) | | ------------------------------------ | - | | - |

| void LogicalTxnTest::testCommitLong | ( | | ) | | ----------------------------------- | - | | - |

| void LogicalTxnTest::testCheckpointCommitEmpty | ( | | ) | | ---------------------------------------------- | - | | - |

| void LogicalTxnTest::testCheckpointCommitShort | ( | | ) | | ---------------------------------------------- | - | | - |

| void LogicalTxnTest::testCheckpointCommitLong | ( | | ) | | --------------------------------------------- | - | | - |

| void LogicalTxnTest::testCheckpointRollbackShort | ( | | ) | | ------------------------------------------------ | - | | - |

| void LogicalTxnTest::testCheckpointRollbackLong | ( | | ) | | ----------------------------------------------- | - | | - |

| LogicalTxnClassId LogicalTxnTest::getParticipantClassId | ( | | ) | const [virtual] | | ------------------------------------------------------- | - | | - | ----------------- |

void LogicalTxnTest::describeParticipant	(	ByteOutputStream &	logStream	)	[virtual]

Performs redo for one logical action during recovery.

The implementation must consume ALL log data for this action, even if some of it turns out to be unneeded.

Parameters:

actionType	the type of action to redo; the rest of the action parameters should be read from the LogicalTxn's input stream
logStream	stream from which to read action data

Implements LogicalTxnParticipant.

Definition at line 173 of file LogicalTxnTest.cpp.

References ACTION_TEST, expected, and ByteInputStream::readValue().

00176 { 00177
00178 BOOST_CHECK_EQUAL(actionType,ACTION_TEST); 00179 int i; 00180 logStream.readValue(i); 00181 BOOST_CHECK(.empty()); 00182 ExpectedRange &range = expected.front(); 00183 BOOST_CHECK_EQUAL(i,range.first); 00184 range.first++; 00185 if (range.first > range.second) { 00186 expected.erase(expected.begin()); 00187 } 00188 }

Performs undo for one logical action during rollback or recovery.

The implementation must consume ALL log data for this action, even if some of it turns out to be unneeded.

Parameters:

actionType	the type of action to undo; the rest of the action parameters should be read from the LogicalTxn's input stream
logStream	stream from which to read action data

Implements LogicalTxnParticipant.

Definition at line 156 of file LogicalTxnTest.cpp.

References ACTION_TEST, expected, and ByteInputStream::readValue().

00159 { 00160
00161 BOOST_CHECK_EQUAL(actionType,ACTION_TEST); 00162 int i; 00163 logStream.readValue(i); 00164 BOOST_CHECK(.empty()); 00165 ExpectedRange &range = expected.front(); 00166 BOOST_CHECK_EQUAL(i,range.first); 00167 range.first--; 00168 if (range.first < range.second) { 00169 expected.erase(expected.begin()); 00170 } 00171 }

Recovers a LogicalTxnParticipant from the log.

Using the classId to determine the participant type to create, the factory reads required constructor parameters from the log input stream. The factory may peool participant instances; i.e. when the same constructor parameters are encountered a second time, the factory can return the same instance. (TODO: refine this when parallelized recovery is implemented.) The implementation must consume ALL log data for this record, even if some of it turns out to be unneeded.

Parameters:

classId	the LogicalTxnClassId recorded when the participant was logged while online
logStream	the log information written by the participant's describeParticipant() implementation

Returns:

reference to loaded participant

Implements LogicalTxnParticipantFactory.

Definition at line 426 of file LogicalTxnTest.cpp.

References getParticipantClassId(), participantDescription, and ByteInputStream::readValue().

void SegStorageTestBase::openStorage	(	DeviceMode	openMode	)	[virtual, inherited]

Reimplemented from CacheTestBase.

Reimplemented in SegmentTestBase.

Definition at line 31 of file SegStorageTestBase.cpp.

References SegStorageTestBase::openSegmentStorage(), and CacheTestBase::openStorage().

Referenced by SegStorageTestBase::openRandomSegment(), SegmentTestBase::openStorage(), LhxHashTableTest::testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LbmEntryTest::testCaseSetUp(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), testTxn(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

void SegStorageTestBase::openSegmentStorage	(	DeviceMode	openMode	)	[virtual, inherited]

| void SegStorageTestBase::openRandomSegment | ( | | ) | [virtual, inherited] | | ------------------------------------------ | - | | - | ---------------------- |

SharedSegment SegStorageTestBase::createLinearDeviceSegment	(	DeviceId	deviceId,
uint	nPages
)	[inherited]

| void SegStorageTestBase::closeLinearSegment | ( | | ) | [inherited] | | ------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeRandomSegment | ( | | ) | [inherited] | | ------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeVersionedRandomSegment | ( | | ) | [inherited] | | ---------------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeSnapshotRandomSegment | ( | | ) | [inherited] | | --------------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeStorage | ( | | ) | [virtual, inherited] | | ------------------------------------- | - | | - | ---------------------- |

Reimplemented from CacheTestBase.

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 102 of file SegStorageTestBase.cpp.

References SegStorageTestBase::closeLinearSegment(), SegStorageTestBase::closeRandomSegment(), CacheTestBase::closeStorage(), and SegStorageTestBase::closeVersionedRandomSegment().

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::openRandomSegment(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), SegmentTestBase::testSingleThread(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

| Cache & CacheTestBase::getCache | ( | | ) | [inherited] | | -------------------------------------------------- | - | | - | ------------- |

| SharedCache CacheTestBase::newCache | ( | | ) | [virtual, inherited] | | --------------------------------------------------------------------------------------------- | - | | - | ---------------------- |

| void CacheTestBase::testCaseTearDown | ( | | ) | [virtual, inherited] | | ------------------------------------ | - | | - | ---------------------- |

Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.

Default is no-op.

Reimplemented from TestBase.

Reimplemented in LbmEntryTest, LbmLoadBitmapTest, LbmSearchTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, BTreeReadersTest, BTreeTest, ExecStreamTestBase, and LhxHashTableTest.

Definition at line 125 of file CacheTestBase.cpp.

References CacheTestBase::closeStorage().

Referenced by LhxHashTableTest::testCaseTearDown(), ExecStreamTestBase::testCaseTearDown(), BTreeTest::testCaseTearDown(), BTreeReadersTest::testCaseTearDown(), and LbmEntryTest::testCaseTearDown().

void TestBase::snooze	(	uint	nSeconds	)	[protected, inherited]

void TestBase::readParams	(	int	argc,
char **	argv
)	[static, inherited]

Parses the command line.

format: [-v] [-t TEST | -all] {param=val}* [CONFIGFILE | -] Normally, the test program runs the default test cases. With the option "-all", runs the extra test cases as well. With the option "-t TEST", runs only the single test case named TEST. CONFIGFILE is read to load configuration parameters. Configuration parameters can also be set ad hoc, from the command line, as pairs name=val. These take precedence.

Definition at line 108 of file TestBase.cpp.

References TestBase::configMap, ConfigMap::dumpParams(), ConfigMap::isParamSet(), ConfigMap::mergeFrom(), TestBase::paramDictionaryFileName, ConfigMap::readParams(), TestBase::runAll, TestBase::runSingle, ConfigMap::setStringParam(), and verbose.

00109 { 00110 bool verbose = false; 00111 ConfigMap adhocMap; 00112 00113 for (int i = 1; i < argc; ++i) { 00114 std::string arg = argv[i]; 00115 if (argv[i][0] == '-') { 00116 if (arg == "-v") { 00117 verbose = true; 00118 } else if (arg == "-") { 00119 configMap.readParams(std::cin); 00120 } else if (arg == "-all") { 00121 runAll = true; 00122 } else if (arg == "-t") {
00123 permAssert(i + 1 < argc); 00124 runSingle = argv[++i]; 00125 } else if (arg[1] == 't') { 00126 runSingle = arg.substr(2); 00127 } 00128 } else { 00129 int i = arg.find("="); 00130 if ((0 < i) && (i < arg.size())) { 00131
00132 std::string key = arg.substr(0,i); 00133 std::string val = arg.substr(i + 1); 00134 adhocMap.setStringParam(key,val); 00135 } else { 00136
00137 std::ifstream configFile(arg.c_str()); 00138 assert(configFile.good()); 00139 configMap.readParams(configFile); 00140 } 00141 } 00142 } 00143 configMap.mergeFrom(adhocMap); 00144 00145
00146
00147 if (.isParamSet(paramDictionaryFileName)) { 00148 std::string dictFileName = "dictWords"; 00149 configMap.setStringParam(paramDictionaryFileName,dictFileName); 00150 } 00151 00152 if (verbose) { 00153 configMap.dumpParams(std::cout); 00154 } 00155 }

| TestSuite * TestBase::releaseTestSuite | ( | | ) | [inherited] | | ---------------------------------------------------------------------------------------------- | - | | - | ------------- |

void TestBase::beforeTestCase	(	std::string	testCaseName	)	[inherited]

void TestBase::afterTestCase	(	std::string	testCaseName	)	[inherited]

void TestBase::notifyTrace	(	std::string	source,
TraceLevel	level,
std::string	message
)	[virtual, inherited]

TraceLevel TestBase::getSourceTraceLevel	(	std::string	source	)	[virtual, inherited]

| LogicalTxn * LogicalTxnParticipant::getLogicalTxn | ( | | ) | [inline, protected, inherited] | | -------------------------------------------------------------------------- | - | | - | -------------------------------- |

Returns:

LogicalTxn being participated in, or null if no txn in progress; null is also returned during recovery

Definition at line 111 of file LogicalTxnParticipant.h.

References LogicalTxnParticipant::pTxn.

Referenced by commit(), BTreeWriter::deleteCurrent(), FtrsTableWriter::execute(), DatabaseTest::executeIncrementAction(), BTreeWriter::insertTupleFromBuffer(), rollbackFull(), testActions(), testCheckpointCommitSavepoint(), testRollbackSavepoint(), testTxn(), and testTxnIdSequence().

00112 { 00113 return pTxn; 00114 }

| bool LogicalTxnParticipant::isLoggingEnabled | ( | | ) | const [inline, protected, inherited] | | -------------------------------------------- | - | | - | -------------------------------------- |