tx

Class BridgeConflictTest

java.lang.Object

tx.BridgeConflictTest

Direct Known Subclasses:

PRBridgeConflictTest

public class BridgeConflictTest
extends Object

A class to test conflicts in transactions.

Field Summary

Fields

Modifier and Type	Field and Description
protected static int	MULTI_THREADS_PER_ONE_VM
protected static String	NOT_IN_TRANS
protected static int	ONE_THREAD_PER_MULTI_VMS
protected int	testConfiguration
static BridgeConflictTest	testInstance
protected static int	UNDEFINED

Constructor Summary

Constructors

Constructor and Description
BridgeConflictTest()

Method Summary

Modifier and Type	Method and Description
protected void	checkTxSet(OpList ops) Check that the current value of the tx set for this thread (the set of keys that have been read or written during this tx) matches the set of keys specified in the oplist.
protected boolean	clientIsEmpty(String clientName) Determines if given client has overridden dataPolicy (using TxPrms-viewDataPolicies) with DataPolicy.EMPTY.
protected void	concConflictTest()
protected OpList	doOps(OpList opList, int numOps, boolean targetSame) Method that will execute operation(s) that either intentionaly write or not write to regions and/or keys in opList.
protected Operation	doOpWithDifferent(OpList opList, Operation operation) Execute an operation that does not operation on the same region/key as any operation in opList.
protected Operation	doOpWithSame(Operation operation) Given an operation, execute an operation that involves that same key and/or region.
protected boolean	entryOpConflictsWith(OpList opList, String regionName, Object key) Determine if an entry operation with the given region and key will conflict with any operation in the operation list.
protected boolean	executeInTx() Return a deciscion on whether or not this configuration supports the 2nd (conflicting thread) running in a tx.
protected boolean	getCommitStatusRR(OpList readOps, OpList t1_ops, OpList newOps, boolean readOpsContainsRR) This writes expected commit status to the blackboard for tests that are testing repeatable read transactions.
protected static int	getNumThreads()
protected static int	getNumVMs()
protected Operation	getWithAnyKey(com.gemstone.gemfire.cache.Region aRegion) Do a get with any key (existing, previous or new).
static void	HydraTask_concConflictTest() Hydra task for serial conflict test
static void	HydraTask_endTask() Hydra task for serial conflict test
static void	HydraTask_initializeConcTest() Hydra task to create a forest of region hierarchies.
static void	HydraTask_initializeSerialTest() Hydra task to create a forest of region hierarchies.
static void	HydraTask_serialConflictTest() Hydra task for serial conflict test with transaction sometimes
static void	HydraTask_serialTxOnlyConflictTest() Hydra task for serial conflict test with transactions
static void	HydraTask_serialTxOnlyRepeatableRead() Hydra task for serial conflict test with repeatable read ops
protected void	initialize()
protected void	logTxSet() Log the tx set for this thread (the set of keys that have been read or written during this tx) matches the set of keys specified in the oplist.
protected boolean	op1HasConflict(Operation op1, Operation op2, boolean op2InTrans, StringBuffer logStr) Assuming that 1) thread1 did op1 (always in a transaction) 2) thread2 did op2 determine if thread1 would have a conflict if it tried to commit first.
protected boolean	op2HasConflict(Operation op1, Operation op2, StringBuffer logStr) Assuming that 1) thread1 did op1 2) thread2 did op2 determine if thread2 would have a conflict if it tried to commit, assuming that thread1 successfully committed first.
protected Operation	putNewOrPreviousKey(com.gemstone.gemfire.cache.Region aRegion) Given a region, create a new entry by randomly choosing either a new or previously used key.
protected void	recordCommitStatus(boolean inTrans, OpList priorOps, OpList newOps) This writes expected commit status to the blackboard for tests that run either in or out of a transaction, and use both transactional and non-transactional operations.
protected boolean	recordCommitStatusTxOnly(OpList priorOps, OpList newOps) This writes expected commit status to the blackboard for tests that run only in transactions and use only transactional (can be rolled back) operations.
protected void	recordNewOps(OpList priorOps, OpList newOps) Given a list of prior ops (done in previous and guaranteed to commit tx) and a list of ops done in the current transactions, determine if the new ops override any previous ops (in a last-one-wins fashion), and modify the priorOps with either replacing a priorOp with a new op or just adding the new op.
protected void	serialConflictTest() Do the serial conflict task for transactional and/or non-transactional threads, and transactional and non-transactional operations (operations that occur immediately and cannot be rolled back).
protected void	serialTxOnlyConflictTest() Do the serial conflict task for transactional threads and transactional operations only (operations can be rolled back).
protected void	serialTxOnlyRepeatableRead() Do the serial conflict task for transactional threads and transactional operations only (operations can be rolled back).
protected String	testConfigurationToString() Return a string representation of the test configuration
protected boolean	thread1HasConflict(OpList opList1, OpList opList2, boolean inTrans) Assuming that 1) thread1 did the operations in opList1 (always in a transaction) 2) thread2 did the operations in opList2 determine if thread1 would have a conflict if it tried to commit first.
protected boolean	thread2HasConflict(OpList opList1, OpList opList2) Assuming that 1) thread1 did the operations in opList1 (always in a transaction) 2) thread2 did the operations in opList2 and is in a transaction determine if thread2 would have a conflict if it tried to commit, assuming that thread1 successfully committed first.
String	toString() Return a string representation of the test configuration
protected void	verifyRepeatableReads(OpList readOps, OpList t1_ops, OpList newOps, boolean readOpsContainsRR) Determines if reads see the correct value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

testInstance

public static BridgeConflictTest testInstance

testConfiguration

protected int testConfiguration

NOT_IN_TRANS

protected static final String NOT_IN_TRANS

See Also:

Constant Field Values

ONE_THREAD_PER_MULTI_VMS

protected static final int ONE_THREAD_PER_MULTI_VMS

See Also:

Constant Field Values

MULTI_THREADS_PER_ONE_VM

protected static final int MULTI_THREADS_PER_ONE_VM

See Also:

Constant Field Values

UNDEFINED

protected static final int UNDEFINED

See Also:

Constant Field Values

Constructor Detail

BridgeConflictTest

public BridgeConflictTest()

Method Detail

HydraTask_initializeConcTest

public static void HydraTask_initializeConcTest()

Hydra task to create a forest of region hierarchies. This task can be called from more than one thread in the same VM.

HydraTask_initializeSerialTest

public static void HydraTask_initializeSerialTest()

Hydra task to create a forest of region hierarchies. This task can be called from more than one thread in the same VM.

getNumVMs

protected static int getNumVMs()

getNumThreads

protected static int getNumThreads()

initialize

protected void initialize()

HydraTask_serialConflictTest

public static void HydraTask_serialConflictTest()

Hydra task for serial conflict test with transaction sometimes

HydraTask_serialTxOnlyConflictTest

public static void HydraTask_serialTxOnlyConflictTest()

Hydra task for serial conflict test with transactions

HydraTask_serialTxOnlyRepeatableRead

public static void HydraTask_serialTxOnlyRepeatableRead()

Hydra task for serial conflict test with repeatable read ops

HydraTask_endTask

public static void HydraTask_endTask()

Hydra task for serial conflict test

HydraTask_concConflictTest

public static void HydraTask_concConflictTest()

Hydra task for serial conflict test

concConflictTest

protected void concConflictTest()

serialTxOnlyConflictTest

protected void serialTxOnlyConflictTest()

Do the serial conflict task for transactional threads and transactional operations only (operations can be rolled back). This configuration is for two VMs with 1 thread each, or a single VM with two threads. First round: The first thread in the round does random operations in a transaction. All other threads in the round either do operations to create a conflict or not create a conflict, always in a transaction. Second round: The first thread expects a successful commit. All other threads will either commit successfully or fail depending on whether they created conflicts or not.

serialTxOnlyRepeatableRead

protected void serialTxOnlyRepeatableRead()

Do the serial conflict task for transactional threads and transactional operations only (operations can be rolled back). This configuration is for two VMs with 1 thread each, or a single VM with two threads. This method is to test conflicts caused by a fix for feature 36688, where gets now note the committed state whereas they used to be noops. This fix also introduces repeatable reads. First round: The first thread in the round does a begin The other thread in the round does a begin and either a repeatable read or a nonrepeatable read. Second round: The first thread does ops and commits (expects a successful commit). The other thread does ops that either conflict or not and will attempt a commit, expecting either success or failure depending on whether the ops created a conflict or not.

serialConflictTest

protected void serialConflictTest()

Do the serial conflict task for transactional and/or non-transactional threads, and transactional and non-transactional operations (operations that occur immediately and cannot be rolled back). This configuration is for 2 threads only (either 2 VMs with 1 thread each, or 1 VM with 2 threads. First round: The first thread in the round does random operations, always in a transaction The second thread randomly chooses to be in a transaction or not, and randomly chooses both transactional and non-transactional operations. Second round: The first thread commits; it can succeed for fail based on what the second thread did. If the first thread failed its commit, this commit (if in a transaction) will succeed. If the first thread suceeded in its commit, then this thread will fail if it caused conflicts, and succeed if it did not.

doOps

protected OpList doOps(OpList opList,
                       int numOps,
                       boolean targetSame)

Method that will execute operation(s) that either intentionaly write or not write to regions and/or keys in opList.

Parameters:

opList - A list of operations we want to consider for potential to intentionally write or not write to same regions/keys.

numOps - The number of operations this method should execute.

targetSame - True if the operations done by this method should do operations that use the same regions/keys as opList, false otherwise.

doOpWithSame

protected Operation doOpWithSame(Operation operation)

Given an operation, execute an operation that involves that same key and/or region.

Parameters:

Operation - - the operation to base the new operation on.

Returns:

The operation that was executed.

doOpWithDifferent

protected Operation doOpWithDifferent(OpList opList,
                                      Operation operation)

Execute an operation that does not operation on the same region/key as any operation in opList.

Parameters:

opList - The list of operations to consider (to avoid their regions/keys).

operation - The operation to consider for not generating a specific region/key write. This is so we can scrutinize one particular operation (this should be an operation in the opList) so the resulting operation can target specific regions/keys.

Returns:

The operation that was executed.

entryOpConflictsWith

protected boolean entryOpConflictsWith(OpList opList,
                                       String regionName,
                                       Object key)

Determine if an entry operation with the given region and key will conflict with any operation in the operation list.

Parameters:

opList - Operations to used to determine conflicts.

regionName - The name of a region to consider for conflicts with opList.

key - The key for regionName to considert for conflicts with opList.

putNewOrPreviousKey

protected Operation putNewOrPreviousKey(com.gemstone.gemfire.cache.Region aRegion)

Given a region, create a new entry by randomly choosing either a new or previously used key.

Parameters:

aRegion - Put into this region.

getWithAnyKey

protected Operation getWithAnyKey(com.gemstone.gemfire.cache.Region aRegion)

Do a get with any key (existing, previous or new).

Parameters:

aRegion - The region to do the get on.

recordCommitStatusTxOnly

protected boolean recordCommitStatusTxOnly(OpList priorOps,
                                           OpList newOps)

This writes expected commit status to the blackboard for tests that run only in transactions and use only transactional (can be rolled back) operations. This test is configured for multi VMs and threads. As a result, a key in the blackboard is written for this thread's expected commit success/failure status.

Parameters:

priorOps - The list of operations done by the first thread.

newOps - The list of operations done by the second thread (has only one op).

getCommitStatusRR

protected boolean getCommitStatusRR(OpList readOps,
                                    OpList t1_ops,
                                    OpList newOps,
                                    boolean readOpsContainsRR)

This writes expected commit status to the blackboard for tests that are testing repeatable read transactions. As a result, a key in the blackboard is written for this thread's expected commit success/failure status. First round: The first thread in the round does a begin The other thread in the round does a begin and either a repeatable read or a nonrepeatable read. Second round: The first thread does ops and commits (expects a successful commit). The other thread does ops that either conflict or not and will attempt a commit, expecting either success or failure depending on whether the ops created a conflict or not.

Parameters:

readOps - The list of operations done by round 1, thread 2.

t1_ops - The List of operations done by round 2, thread 1.

newOps - The list of operations done by round 2, thread 2.

readOpsContainsRR - True if the readOps contained a repeatable read, false otherwise.

verifyRepeatableReads

protected void verifyRepeatableReads(OpList readOps,
                                     OpList t1_ops,
                                     OpList newOps,
                                     boolean readOpsContainsRR)

Determines if reads see the correct value. First round: The first thread in the round does a begin The other thread in the round does a begin and either a repeatable read or a nonrepeatable read. Second round: The first thread does ops and commites (expects a successful commit). The other thread does ops that either conflict or not and will attempt a commit, expecting either success or failure depending on whether the ops created a conflict or not.

Parameters:

readOps - The list of operations done by round 1, thread 2.

t1_ops - The List of operations done by round 2, thread 1.

newOps - The list of operations done by round 2, thread 2.

readOpsContainsRR - True if the readOps contained a repeatable read, false otherwise.

recordCommitStatus

protected void recordCommitStatus(boolean inTrans,
                                  OpList priorOps,
                                  OpList newOps)

This writes expected commit status to the blackboard for tests that run either in or out of a transaction, and use both transactional and non-transactional operations. This test is configured for only two threads. As a result, two keys in the blackboard shared map are written to indicated the expected commit success/failure of each of the two thread: TxBB.FirstInRoundCommitStatus and TxBB.SecondInRoundCommitStatus.

Parameters:

inTrans - True if the second thread is in a transaction, false otherwise. The first thread is always in a transaction.

priorOps - The list of operations done by the first thread.

newOps - The list of operations done by the second thread (has only one op).

thread1HasConflict

protected boolean thread1HasConflict(OpList opList1,
                                     OpList opList2,
                                     boolean inTrans)

Assuming that 1) thread1 did the operations in opList1 (always in a transaction) 2) thread2 did the operations in opList2 determine if thread1 would have a conflict if it tried to commit first.

Parameters:

opList1 - The list of operations done by thread1.

opList2 - The list of operations done by thread2.

inTrans - True if opList2 was done in a transaction, false otherwise.

Returns:

True if thread1 will have a conflict (because of opList2) if it tries to commit, false otherwise.

op1HasConflict

protected boolean op1HasConflict(Operation op1,
                                 Operation op2,
                                 boolean op2InTrans,
                                 StringBuffer logStr)

Assuming that 1) thread1 did op1 (always in a transaction) 2) thread2 did op2 determine if thread1 would have a conflict if it tried to commit first.

Parameters:

op1 - The operation done by thread1.

op2 - The operation done by thread2.

inTrans - True if op2 was done in a transaction, false otherwise.

logStr - A buffer to append any logging to.

Returns:

True if thread1 will have a conflict (because of op2) if it tries to commit, false otherwise.

clientIsEmpty

protected boolean clientIsEmpty(String clientName)

Determines if given client has overridden dataPolicy (using TxPrms-viewDataPolicies) with DataPolicy.EMPTY.

Parameters:

clientName - (for proxySerialConflict tests, 'client1' or 'client2')

thread2HasConflict

protected boolean thread2HasConflict(OpList opList1,
                                     OpList opList2)

Assuming that 1) thread1 did the operations in opList1 (always in a transaction) 2) thread2 did the operations in opList2 and is in a transaction determine if thread2 would have a conflict if it tried to commit, assuming that thread1 successfully committed first.

Parameters:

opList1 - The list of operations done by thread1.

opList2 - The list of operations done by thread2.

Returns:

True if thread2 will have a conflict (because of the operations in opList1) if it tries to commit after thread1 successfuly commits, false otherwise.

op2HasConflict

protected boolean op2HasConflict(Operation op1,
                                 Operation op2,
                                 StringBuffer logStr)

Assuming that 1) thread1 did op1 2) thread2 did op2 determine if thread2 would have a conflict if it tried to commit, assuming that thread1 successfully committed first.

Parameters:

op1 - The operation done by thread1.

op2 - The operation done by thread2.

logStr - A buffer to append any logging to.

Returns:

True if thread2 will have a conflict (because of the op1) if it tries to commit after thread1 successfuly commits, false otherwise.

recordNewOps

protected void recordNewOps(OpList priorOps,
                            OpList newOps)

Given a list of prior ops (done in previous and guaranteed to commit tx) and a list of ops done in the current transactions, determine if the new ops override any previous ops (in a last-one-wins fashion), and modify the priorOps with either replacing a priorOp with a new op or just adding the new op.

Parameters:

priorOps - The operations done (and guaranteed to commit) by previous transactions.

newOps - The operations done by the current tx and may or may not successfully commit.

checkTxSet

protected void checkTxSet(OpList ops)

Check that the current value of the tx set for this thread (the set of keys that have been read or written during this tx) matches the set of keys specified in the oplist.

logTxSet

protected void logTxSet()

Log the tx set for this thread (the set of keys that have been read or written during this tx) matches the set of keys specified in the oplist.

executeInTx

protected boolean executeInTx()

Return a deciscion on whether or not this configuration supports the 2nd (conflicting thread) running in a tx. This method just uses the nextBoolean to determine, but this can be method can be overridden to provide different behavior. For example, with PartitionedRegions, we cannot target a thread in a remote VM, so there is no way to create a conflict if both threads are transactional (because their keySets won't intersect). (So, we'll override this method in PRConflictTest.java.)

toString

public String toString()

Return a string representation of the test configuration

Overrides:

toString in class Object

testConfigurationToString

protected String testConfigurationToString()

Return a string representation of the test configuration