com.bigdata.concurrent

Class StressTestNonBlockingLockManagerWithTxDag

java.lang.Object

junit.framework.Assert

junit.framework.TestCase

com.bigdata.concurrent.AbstractStressTestNonBlockingLockManager

com.bigdata.concurrent.StressTestNonBlockingLockManagerWithTxDag

All Implemented Interfaces:

junit.framework.Test

public class StressTestNonBlockingLockManagerWithTxDag
extends AbstractStressTestNonBlockingLockManager

Stress tests where a TxDag is used to detect deadlock.

Version:

$Id$

Author:

Bryan Thompson

Nested Class Summary

Nested classes/interfaces inherited from class com.bigdata.concurrent.AbstractStressTestNonBlockingLockManager

AbstractStressTestNonBlockingLockManager.Generate, AbstractStressTestNonBlockingLockManager.TestOptions, AbstractStressTestNonBlockingLockManager.Wait10ResourceTask<T>

Field Summary

Fields inherited from class com.bigdata.concurrent.AbstractStressTestNonBlockingLockManager

DEBUG, INFO, log

Constructor Summary

Constructors

Constructor and Description
StressTestNonBlockingLockManagerWithTxDag()
StressTestNonBlockingLockManagerWithTxDag(String name)

Method Summary

Methods

Modifier and Type	Method and Description
void	test_multipleResourceLocking_resources10_waitsFor_deadlocks_locktries10() Test where each operation locks one or more resources.
void	test_multipleResourceLocking_resources3_waitsFor_deadlocks_locktries3() Test where each operation locks one or more resources.
void	test_singleResourceLocking_serialized_waitsFor_highConcurrency_taskTimeout() Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized.
void	test_singleResourceLocking_serialized_waitsFor_highConcurrency() Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized.
void	test_singleResourceLocking_serialized_waitsFor_lowConcurrency2() Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized.
void	test_singleResourceLocking_serialized_waitsFor_lowConcurrency5_withTaskDeath() Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized and where 10% of all tasks die a horrid death.
void	test_singleResourceLocking_waitsFor_defaultConcurrency20() Test where each operation locks only a single resource using a thread pool with 20 core threads.
void	test_singleResourceLocking_waitsFor_highConcurrency100() Test where each operation locks only a single resource (high concurrency condition with 100 threads).
void	test_singleResourceLocking_waitsFor_lowConcurrency5() Test where each operation locks only a single resource (low concurrency condition w/ 5 threads).

Methods inherited from class com.bigdata.concurrent.AbstractStressTestNonBlockingLockManager

doComparisonTest, setUpComparisonTest, tearDownComparisonTest

Methods inherited from class junit.framework.TestCase

assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertEquals, assertFalse, assertFalse, assertNotNull, assertNotNull, assertNotSame, assertNotSame, assertNull, assertNull, assertSame, assertSame, assertTrue, assertTrue, countTestCases, createResult, fail, fail, failNotEquals, failNotSame, failSame, format, getName, run, run, runBare, runTest, setName, setUp, tearDown, toString

Methods inherited from class java.lang.Object

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

Constructor Detail

StressTestNonBlockingLockManagerWithTxDag

public StressTestNonBlockingLockManagerWithTxDag()

StressTestNonBlockingLockManagerWithTxDag

public StressTestNonBlockingLockManagerWithTxDag(String name)

Method Detail

test_singleResourceLocking_waitsFor_lowConcurrency5

public void test_singleResourceLocking_waitsFor_lowConcurrency5()
                                                         throws Exception

Test where each operation locks only a single resource (low concurrency condition w/ 5 threads). There is no timeout. All tasks should run to completion. Since modestly large number of resources (100) is used and since each task declares a single resource lock, the maximum observed concurrency should be the #of tasks in the thread pool.

Throws:

Exception

test_singleResourceLocking_waitsFor_defaultConcurrency20

public void test_singleResourceLocking_waitsFor_defaultConcurrency20()
                                                              throws Exception

Test where each operation locks only a single resource using a thread pool with 20 core threads. Since there is no timeout, all tasks should run to completion. The maximum observed concurrency SHOULD be equal to the size of the thread pool.

Throws:

Exception

test_singleResourceLocking_waitsFor_highConcurrency100

public void test_singleResourceLocking_waitsFor_highConcurrency100()
                                                            throws Exception

Test where each operation locks only a single resource (high concurrency condition with 100 threads).

Throws:

Exception

test_singleResourceLocking_serialized_waitsFor_lowConcurrency2

public void test_singleResourceLocking_serialized_waitsFor_lowConcurrency2()
                                                                    throws Exception

Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized.

Throws:

Exception

test_singleResourceLocking_serialized_waitsFor_lowConcurrency5_withTaskDeath

public void test_singleResourceLocking_serialized_waitsFor_lowConcurrency5_withTaskDeath()
                                                                                  throws Exception

Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized and where 10% of all tasks die a horrid death.

Throws:

Exception

test_singleResourceLocking_serialized_waitsFor_highConcurrency

public void test_singleResourceLocking_serialized_waitsFor_highConcurrency()
                                                                    throws Exception

Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized.

Throws:

Exception

test_singleResourceLocking_serialized_waitsFor_highConcurrency_taskTimeout

public void test_singleResourceLocking_serialized_waitsFor_highConcurrency_taskTimeout()
                                                                                throws Exception

Test where each operation locks only a single resource and there is only one resource to be locked so that all operations MUST be serialized. The task timeout is non-zero, so long-running tasks will be cancelled. This test stresses the logic in lock() that is responsible for backing out a lock requests when a task is cancelled either while awaiting its locks or while running.

Throws:

Exception

test_multipleResourceLocking_resources3_waitsFor_deadlocks_locktries3

public void test_multipleResourceLocking_resources3_waitsFor_deadlocks_locktries3()
                                                                           throws Exception

Test where each operation locks one or more resources.

Note: This condition provides the basis for deadlocks. FIXME We don't have real-deadlocks w/o 2PL since we are processing the lock requests atomically (all requests for a given task are posted at once). So we don't really need TxDag for that. Modify to support 2PL and to use TxDag when 2PL is possible and locks are not predeclared (you can not use 2PL if you predeclare locks).

Throws:

Exception

test_multipleResourceLocking_resources10_waitsFor_deadlocks_locktries10

public void test_multipleResourceLocking_resources10_waitsFor_deadlocks_locktries10()
                                                                             throws Exception

Test where each operation locks one or more resources.

Note: This condition provides the basis for deadlocks. In fact, since we have 10 resource locks for each operation and only 100 resources the chances of a deadlock on any given operation are extremely high. FIXME We don't have real-deadlocks w/o 2PL since we are processing the lock requests atomically (all requests for a given task are posted at once). So we don't really need TxDag for that. Modify to support 2PL and to use TxDag when 2PL is possible and locks are not predeclared (you can not use 2PL if you predeclare locks).

Throws:

Exception