public static void SetUpEnvWithTxnAndLocking(string envHome,
out DatabaseEnvironment env, out Transaction txn,
uint maxLock, uint maxLocker, uint maxObject, uint partition)
{
// Configure env and locking subsystem.
LockingConfig lkConfig = new LockingConfig();
/*
* If the maximum number of locks/lockers/objects
* is given, then the LockingConfig is set. Unless,
* it is not set to any value.
*/
if (maxLock != 0)
lkConfig.MaxLocks = maxLock;
if (maxLocker != 0)
lkConfig.MaxLockers = maxLocker;
if (maxObject != 0)
lkConfig.MaxObjects = maxObject;
if (partition != 0)
lkConfig.Partitions = partition;
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.UseTxns = true;
envConfig.UseMPool = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.UseLocking = true;
envConfig.NoLocking = false;
env = DatabaseEnvironment.Open(envHome, envConfig);
txn = env.BeginTransaction();
}
public static void LockingEnvSetUp(string testHome,
string testName, out DatabaseEnvironment env,
uint maxLock, uint maxLocker, uint maxObject,
uint partition)
{
// Configure env and locking subsystem.
LockingConfig lkConfig = new LockingConfig();
/*
* If the maximum number of locks/lockers/objects
* is given, then the LockingConfig is set. Unless,
* it is not set to any value.
*/
if (maxLock != 0)
lkConfig.MaxLocks = maxLock;
if (maxLocker != 0)
lkConfig.MaxLockers = maxLocker;
if (maxObject != 0)
lkConfig.MaxObjects = maxObject;
if (partition != 0)
lkConfig.Partitions = partition;
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.UseLocking = true;
envConfig.ErrorPrefix = testName;
env = DatabaseEnvironment.Open(testHome, envConfig);
}
public static void Config(XmlElement xmlElement,
ref LockingConfig lockingConfig, bool compulsory)
{
byte[,] matrix = new byte[6, 6];
uint value = new uint();
if (Configuration.ConfigByteMatrix(xmlElement, "Conflicts",
ref matrix, compulsory) == true)
lockingConfig.Conflicts = matrix;
Configuration.ConfigDeadlockPolicy(xmlElement, "DeadlockResolution",
ref lockingConfig.DeadlockResolution, compulsory);
if (Configuration.ConfigUint(xmlElement, "MaxLockers",
ref value, compulsory))
lockingConfig.MaxLockers = value;
if (Configuration.ConfigUint(xmlElement, "MaxLocks",
ref value, compulsory))
lockingConfig.MaxLocks = value;
if (Configuration.ConfigUint(xmlElement, "MaxObjects",
ref value, compulsory))
lockingConfig.MaxObjects = value;
if (Configuration.ConfigUint(xmlElement, "Partitions",
ref value, compulsory))
lockingConfig.Partitions = value;
}
/*
* Create and open environment and database.
*/
public static int DBInit(out DatabaseEnvironment env,
string home, string progName, uint maxLock,
uint doUnLink)
{
DatabaseEnvironmentConfig envConfig;
LockingConfig lkConfig;
/* Configure locking subsystem. */
lkConfig = new LockingConfig();
lkConfig.MaxLocks = maxLock;
/* Configure environment. */
envConfig = new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.ErrorPrefix = progName;
envConfig.LockSystemCfg = lkConfig;
envConfig.UseLocking = true;
/*
* Optionally remove the environment region and
* open the environment.
*/
try {
if (doUnLink == 1)
DatabaseEnvironment.Remove(home, true);
env = DatabaseEnvironment.Open(home, envConfig);
} catch (Exception e) {
Console.WriteLine("{0}:{1}\n{2}",
e.Source, e.Message, e.StackTrace);
env = null;
return EXIT_FAILURE;
}
/*
try
{
env = DatabaseEnvironment.Open(home, envConfig);
}
catch(Exception e)
{
Console.WriteLine("{0}:{1}\n{2}",
e.Source, e.Message, e.StackTrace);
env = null;
return ExConstants.EXIT_FAILURE;
}
*/
return EXIT_SUCCESS;
}
public static void Confirm(XmlElement xmlElement,
LockingConfig lockingConfig, bool compulsory)
{
Configuration.ConfirmByteMatrix(xmlElement, "Conflicts",
lockingConfig.Conflicts, compulsory);
Configuration.ConfirmDeadlockPolicy(xmlElement,
"DeadlockResolution",
lockingConfig.DeadlockResolution, compulsory);
Configuration.ConfirmUint(xmlElement, "MaxLockers",
lockingConfig.MaxLockers, compulsory);
Configuration.ConfirmUint(xmlElement, "MaxLocks",
lockingConfig.MaxLocks, compulsory);
Configuration.ConfirmUint(xmlElement, "MaxObjects",
lockingConfig.MaxObjects, compulsory);
Configuration.ConfirmUint(xmlElement, "Partitions",
lockingConfig.Partitions, compulsory);
}
public void TestConfig()
{
testName = "TestConfig";
// Configure the fields/properties.
LockingConfig lockingConfig = new LockingConfig();
XmlElement xmlElem = Configuration.TestSetUp(
testFixtureName, testName);
// Configure LockingConfig
Config(xmlElem, ref lockingConfig, true);
// Confirm LockingConfig
Confirm(xmlElem, lockingConfig, true);
}
public void TestLockStats()
{
testName = "TestLockManyAndStats";
testHome = testFixtureHome + "/" + testName;
Configuration.ClearDir(testHome);
// Configure locking subsystem.
LockingConfig lkConfig = new LockingConfig();
lkConfig.MaxLockers = 60;
lkConfig.MaxLocks = 50;
lkConfig.MaxObjects = 70;
lkConfig.Partitions = 20;
// Configure and open environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.Create = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.UseLocking = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
envConfig.ErrorPrefix = testName;
envConfig.NoLocking = false;
envConfig.LockTimeout = 1000;
envConfig.TxnTimeout = 2000;
envConfig.MPoolSystemCfg.CacheSize = new CacheInfo(0, 10485760, 1);
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Get and confirm locking subsystem statistics.
LockStats stats = env.LockingSystemStats();
env.PrintLockingSystemStats(true, true);
Assert.AreEqual(1000, stats.LockTimeoutLength);
Assert.AreEqual(60, stats.MaxLockersInTable);
Assert.AreEqual(50, stats.MaxLocksInTable);
Assert.AreEqual(70, stats.MaxObjectsInTable);
Assert.AreNotEqual(0, stats.MaxUnusedID);
Assert.AreEqual(20, stats.nPartitions);
Assert.AreNotEqual(0, stats.RegionNoWait);
Assert.AreNotEqual(0, stats.RegionSize);
Assert.AreEqual(0, stats.RegionWait);
Assert.AreEqual(2000, stats.TxnTimeoutLength);
env.PrintLockingSystemStats();
env.Close();
}
public void TestLockStats()
{
testName = "TestLockStats";
SetUpTest(true);
// Configure locking subsystem.
LockingConfig lkConfig = new LockingConfig();
lkConfig.MaxLockers = 60;
lkConfig.MaxLocks = 50;
lkConfig.MaxObjects = 70;
lkConfig.Partitions = 20;
lkConfig.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Configure and open environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.FreeThreaded = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.LockTimeout = 1000;
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.MPoolSystemCfg.CacheSize = new CacheInfo(0, 104800, 1);
envConfig.NoLocking = false;
envConfig.TxnTimeout = 2000;
envConfig.UseLocking = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Get and confirm locking subsystem statistics.
LockStats stats = env.LockingSystemStats();
env.PrintLockingSystemStats(true, true);
Assert.AreEqual(0, stats.AllocatedLockers);
Assert.AreNotEqual(0, stats.AllocatedLocks);
Assert.AreNotEqual(0, stats.AllocatedObjects);
Assert.AreEqual(0, stats.InitLockers);
Assert.AreNotEqual(0, stats.InitLocks);
Assert.AreNotEqual(0, stats.InitObjects);
Assert.AreEqual(0, stats.LastAllocatedLockerID);
Assert.AreEqual(0, stats.LockConflictsNoWait);
Assert.AreEqual(0, stats.LockConflictsWait);
Assert.AreEqual(0, stats.LockDeadlocks);
Assert.AreEqual(0, stats.LockDowngrades);
Assert.AreEqual(0, stats.LockerNoWait);
Assert.AreEqual(0, stats.Lockers);
Assert.AreEqual(0, stats.LockerWait);
Assert.AreEqual(9, stats.LockModes);
Assert.AreEqual(0, stats.LockPuts);
Assert.AreEqual(0, stats.LockRequests);
Assert.AreEqual(0, stats.Locks);
Assert.AreEqual(0, stats.LockSteals);
Assert.AreEqual(1000, stats.LockTimeoutLength);
Assert.AreEqual(0, stats.LockTimeouts);
Assert.AreEqual(0, stats.LockUpgrades);
Assert.AreEqual(0, stats.MaxBucketLength);
Assert.AreEqual(0, stats.MaxLockers);
Assert.AreEqual(60, stats.MaxLockersInTable);
Assert.AreEqual(0, stats.MaxLocks);
Assert.AreEqual(0, stats.MaxLocksInBucket);
Assert.AreEqual(50, stats.MaxLocksInTable);
Assert.AreEqual(0, stats.MaxLockSteals);
Assert.AreEqual(0, stats.MaxObjects);
Assert.AreEqual(0, stats.MaxObjectsInBucket);
Assert.AreEqual(70, stats.MaxObjectsInTable);
Assert.AreEqual(0, stats.MaxObjectSteals);
Assert.AreEqual(0, stats.MaxPartitionLockNoWait);
Assert.AreEqual(0, stats.MaxPartitionLockWait);
Assert.AreNotEqual(0, stats.MaxUnusedID);
Assert.AreEqual(20, stats.nPartitions);
Assert.AreEqual(0, stats.ObjectNoWait);
Assert.AreEqual(0, stats.Objects);
Assert.AreEqual(0, stats.ObjectSteals);
Assert.AreEqual(0, stats.ObjectWait);
Assert.LessOrEqual(0, stats.PartitionLockNoWait);
Assert.AreEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.AreNotEqual(0, stats.RegionSize);
Assert.AreEqual(0, stats.RegionWait);
Assert.AreNotEqual(0, stats.TableSize);
Assert.AreEqual(2000, stats.TxnTimeoutLength);
Assert.AreEqual(0, stats.TxnTimeouts);
env.PrintLockingSystemStats();
Transaction txn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
dbConfig.FreeThreaded = true;
BTreeDatabase db = BTreeDatabase.Open(
testName + ".db", dbConfig, txn);
txn.Commit();
testLockStatsEnv = env;
testLockStatsDb = db;
// Use some locks, to ensure the stats work when populated.
txn = testLockStatsEnv.BeginTransaction();
for (int i = 0; i < 500; i++)
{
testLockStatsDb.Put(
new DatabaseEntry(BitConverter.GetBytes(i)),
new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes(
Configuration.RandomString(i))), txn);
testLockStatsDb.Sync();
}
txn.Commit();
env.PrintLockingSystemStats();
stats = env.LockingSystemStats();
Assert.Less(0, stats.LastAllocatedLockerID);
Assert.Less(0, stats.LockDowngrades);
Assert.LessOrEqual(0, stats.LockerNoWait);
Assert.Less(0, stats.Lockers);
Assert.LessOrEqual(0, stats.LockerWait);
Assert.Less(0, stats.LockPuts);
Assert.Less(0, stats.LockRequests);
Assert.Less(0, stats.Locks);
Assert.LessOrEqual(0, stats.LockSteals);
Assert.LessOrEqual(0, stats.LockTimeouts);
Assert.LessOrEqual(0, stats.LockUpgrades);
Assert.Less(0, stats.MaxBucketLength);
Assert.Less(0, stats.MaxLockers);
Assert.Less(0, stats.MaxLocks);
Assert.Less(0, stats.MaxLocksInBucket);
Assert.LessOrEqual(0, stats.MaxLockSteals);
Assert.Less(0, stats.MaxObjects);
Assert.Less(0, stats.MaxObjectsInBucket);
Assert.LessOrEqual(0, stats.MaxObjectSteals);
Assert.LessOrEqual(0, stats.MaxPartitionLockNoWait);
Assert.LessOrEqual(0, stats.MaxPartitionLockWait);
Assert.Less(0, stats.MaxUnusedID);
Assert.LessOrEqual(0, stats.ObjectNoWait);
Assert.Less(0, stats.Objects);
Assert.LessOrEqual(0, stats.ObjectSteals);
Assert.LessOrEqual(0, stats.ObjectWait);
Assert.Less(0, stats.PartitionLockNoWait);
Assert.LessOrEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.LessOrEqual(0, stats.RegionWait);
Assert.LessOrEqual(0, stats.TxnTimeouts);
// Force a deadlock to ensure the stats work.
txn = testLockStatsEnv.BeginTransaction();
testLockStatsDb.Put(new DatabaseEntry(BitConverter.GetBytes(10)),
new DatabaseEntry(ASCIIEncoding.ASCII.GetBytes(
Configuration.RandomString(200))), txn);
Thread thread1 = new Thread(GenerateDeadlock);
thread1.Start();
while (DeadlockDidPut == 0)
Thread.Sleep(10);
try
{
testLockStatsDb.Get(new DatabaseEntry(
BitConverter.GetBytes(100)), txn);
}
catch (DeadlockException) { }
// Abort unconditionally - we don't care about the transaction
txn.Abort();
thread1.Join();
stats = env.LockingSystemStats();
Assert.Less(0, stats.LockConflictsNoWait);
Assert.LessOrEqual(0, stats.LockConflictsWait);
db.Close();
env.Close();
}
public void TestLockStatPrint()
{
testName = "TestLockStatPrint";
SetUpTest(true);
string[] messageInfo = new string[]
{
"Last allocated locker ID",
"Current maximum unused locker ID",
"Number of lock modes",
"Initial number of locks allocated",
"Initial number of lockers allocated",
"Initial number of lock objects allocated",
"Maximum number of locks possible",
"Maximum number of lockers possible",
"Maximum number of lock objects possible",
"Current number of locks allocated",
"Current number of lockers allocated",
"Current number of lock objects allocated",
"Number of lock object partitions",
"Size of object hash table",
"Number of current locks",
"Maximum number of locks at any one time",
"Maximum number of locks in any one bucket",
"Maximum number of locks stolen by for an empty partition",
"Maximum number of locks stolen for any one partition",
"Number of current lockers",
"Maximum number of lockers at any one time",
"Number of hits in the thread locker cache",
"Total number of lockers reused",
"Number of current lock objects",
"Maximum number of lock objects at any one time",
"Maximum number of lock objects in any one bucket",
"Maximum number of objects stolen by for an empty partition",
"Maximum number of objects stolen for any one partition",
"Total number of locks requested",
"Total number of locks released",
"Total number of locks upgraded",
"Total number of locks downgraded",
"Lock requests not available due to conflicts, for which we waited",
"Lock requests not available due to conflicts, for which we did not wait",
"Number of deadlocks",
"Lock timeout value",
"Number of locks that have timed out",
"Transaction timeout value",
"Number of transactions that have timed out",
"Region size",
"The number of partition locks that required waiting (0%)",
"The maximum number of times any partition lock was waited for (0%)",
"The number of object queue operations that required waiting (0%)",
"The number of locker allocations that required waiting (0%)",
"The number of region locks that required waiting (0%)",
"Maximum hash bucket length"
};
// Configure locking subsystem.
LockingConfig lkConfig = new LockingConfig();
lkConfig.MaxLockers = 60;
lkConfig.MaxLocks = 50;
lkConfig.MaxObjects = 70;
lkConfig.Partitions = 20;
lkConfig.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Configure and open an environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.LockTimeout = 1000;
envConfig.NoLocking = false;
envConfig.UseLocking = true;
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Confirm message file does not exist.
string messageFile = testHome + "/" + "msgfile";
Assert.AreEqual(false, File.Exists(messageFile));
// Call set_msgfile() of env.
env.Msgfile = messageFile;
// Print env statistic to message file.
env.PrintLockingSystemStats();
// Confirm message file exists now.
Assert.AreEqual(true, File.Exists(messageFile));
env.Msgfile = "";
int counter = 0;
string line;
line = null;
// Read the message file line by line.
System.IO.StreamReader file = new System.IO.StreamReader(@"" + messageFile);
while ((line = file.ReadLine()) != null)
{
string[] tempStr = line.Split('\t');
// Confirm the content of the message file.
Assert.AreEqual(tempStr[1], messageInfo[counter]);
counter++;
}
Assert.AreNotEqual(counter, 0);
file.Close();
env.Close();
}
public void TestLockStats()
{
testName = "TestLockStats";
SetUpTest(true);
// Configure locking subsystem.
LockingConfig lkConfig = new LockingConfig();
lkConfig.MaxLockers = 60;
lkConfig.MaxLocks = 50;
lkConfig.MaxObjects = 70;
lkConfig.Partitions = 20;
lkConfig.DeadlockResolution = DeadlockPolicy.DEFAULT;
// Configure and open environment.
DatabaseEnvironmentConfig envConfig =
new DatabaseEnvironmentConfig();
envConfig.Create = true;
envConfig.FreeThreaded = true;
envConfig.LockSystemCfg = lkConfig;
envConfig.LockTimeout = 1000;
envConfig.MPoolSystemCfg = new MPoolConfig();
envConfig.MPoolSystemCfg.CacheSize = new CacheInfo(0, 104800, 1);
envConfig.NoLocking = false;
envConfig.TxnTimeout = 2000;
envConfig.UseLocking = true;
envConfig.UseMPool = true;
envConfig.UseTxns = true;
DatabaseEnvironment env =
DatabaseEnvironment.Open(testHome, envConfig);
// Get and confirm locking subsystem statistics.
LockStats stats = env.LockingSystemStats();
env.PrintLockingSystemStats(true, true);
Assert.AreEqual(0, stats.LastAllocatedLockerID);
Assert.AreEqual(0, stats.LockConflictsNoWait);
Assert.AreEqual(0, stats.LockConflictsWait);
Assert.AreEqual(0, stats.LockDeadlocks);
Assert.AreEqual(0, stats.LockDowngrades);
Assert.AreEqual(0, stats.LockerNoWait);
Assert.AreEqual(0, stats.Lockers);
Assert.AreEqual(0, stats.LockerWait);
Assert.AreEqual(9, stats.LockModes);
Assert.AreEqual(0, stats.LockPuts);
Assert.AreEqual(0, stats.LockRequests);
Assert.AreEqual(0, stats.Locks);
Assert.AreEqual(0, stats.LockSteals);
Assert.AreEqual(1000, stats.LockTimeoutLength);
Assert.AreEqual(0, stats.LockTimeouts);
Assert.AreEqual(0, stats.LockUpgrades);
Assert.AreEqual(0, stats.MaxBucketLength);
Assert.AreEqual(0, stats.MaxLockers);
Assert.AreEqual(60, stats.MaxLockersInTable);
Assert.AreEqual(0, stats.MaxLocks);
Assert.AreEqual(0, stats.MaxLocksInBucket);
Assert.AreEqual(50, stats.MaxLocksInTable);
Assert.AreEqual(0, stats.MaxLockSteals);
Assert.AreEqual(0, stats.MaxObjects);
Assert.AreEqual(0, stats.MaxObjectsInBucket);
Assert.AreEqual(70, stats.MaxObjectsInTable);
Assert.AreEqual(0, stats.MaxObjectSteals);
Assert.AreEqual(0, stats.MaxPartitionLockNoWait);
Assert.AreEqual(0, stats.MaxPartitionLockWait);
Assert.AreNotEqual(0, stats.MaxUnusedID);
Assert.AreEqual(20, stats.nPartitions);
Assert.AreEqual(0, stats.ObjectNoWait);
Assert.AreEqual(0, stats.Objects);
Assert.AreEqual(0, stats.ObjectSteals);
Assert.AreEqual(0, stats.ObjectWait);
Assert.LessOrEqual(0, stats.PartitionLockNoWait);
Assert.AreEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.AreNotEqual(0, stats.RegionSize);
Assert.AreEqual(0, stats.RegionWait);
Assert.AreEqual(2000, stats.TxnTimeoutLength);
Assert.AreEqual(0, stats.TxnTimeouts);
env.PrintLockingSystemStats();
Transaction txn = env.BeginTransaction();
BTreeDatabaseConfig dbConfig = new BTreeDatabaseConfig();
dbConfig.Creation = CreatePolicy.IF_NEEDED;
dbConfig.Env = env;
dbConfig.FreeThreaded = true;
BTreeDatabase db = BTreeDatabase.Open(
testName + ".db", dbConfig, txn);
txn.Commit();
testLockStatsEnv = env;
testLockStatsDb = db;
Thread thread1 = new Thread(new ThreadStart(Read));
Thread thread2 = new Thread(new ThreadStart(Write));
thread1.Start();
Thread.Sleep(1000);
thread2.Start();
thread1.Join();
thread2.Join();
env.PrintLockingSystemStats();
stats = env.LockingSystemStats();
Assert.Less(0, stats.LastAllocatedLockerID);
Assert.Less(0, stats.LockConflictsNoWait);
Assert.LessOrEqual(0, stats.LockConflictsWait);
Assert.LessOrEqual(0, stats.LockDeadlocks);
Assert.Less(0, stats.LockDowngrades);
Assert.LessOrEqual(0, stats.LockerNoWait);
Assert.Less(0, stats.Lockers);
Assert.LessOrEqual(0, stats.LockerWait);
Assert.Less(0, stats.LockPuts);
Assert.Less(0, stats.LockRequests);
Assert.Less(0, stats.Locks);
Assert.LessOrEqual(0, stats.LockSteals);
Assert.LessOrEqual(0, stats.LockTimeouts);
Assert.LessOrEqual(0, stats.LockUpgrades);
Assert.Less(0, stats.MaxBucketLength);
Assert.Less(0, stats.MaxLockers);
Assert.Less(0, stats.MaxLocks);
Assert.Less(0, stats.MaxLocksInBucket);
Assert.LessOrEqual(0, stats.MaxLockSteals);
Assert.Less(0, stats.MaxObjects);
Assert.Less(0, stats.MaxObjectsInBucket);
Assert.LessOrEqual(0, stats.MaxObjectSteals);
Assert.LessOrEqual(0, stats.MaxPartitionLockNoWait);
Assert.LessOrEqual(0, stats.MaxPartitionLockWait);
Assert.Less(0, stats.MaxUnusedID);
Assert.Less(0, stats.ObjectNoWait);
Assert.Less(0, stats.Objects);
Assert.LessOrEqual(0, stats.ObjectSteals);
Assert.LessOrEqual(0, stats.ObjectWait);
Assert.Less(0, stats.PartitionLockNoWait);
Assert.LessOrEqual(0, stats.PartitionLockWait);
Assert.Less(0, stats.RegionNoWait);
Assert.LessOrEqual(0, stats.RegionWait);
Assert.Less(0, stats.TxnTimeouts);
db.Close();
env.Close();
}
