Transaction resources not released across program invocations using MVCC

Question

I'm evaluating Berkley DB XML v2.4.13 for use in a new software product and have encountered problems with multiversion concurrency control.
I'm using the Java API and JRE 1.6.0_07. The platform is Windows XP Professional SP3.
When I create a transaction with snapshot isolation enabled, execute some XQueries that read/update the contents of a document and then commit or abort it, the resources allocated to the transaction do not appear to get released. I've used EnvironmentConfig.setTxnMaxActive() to increase the number of active transactions allowed but this just allows me to run my program more times before it eventually hangs.
When I set EnvironmentConfig.setTxnMaxActive() to a small number the program hangs before completing the first time I run it. When I set
EnvironmentConfig.setTxnMaxActive() to a high value then I can run my program several times before it hangs. Note that the program runs to
completion and exits cleanly. I used the task manager to verify that all processes started by the program are gone when it completes. So
it appears that the resources allocated to a transaction are persisted in the database across program invocations. As a result the program
eventually hangs after running it several times. The number of times it can be run before hanging is directly proportional to how many active
transactions I've set with EnvironmentConfig.setTxnMaxActive(). It appears as if I'm not shutting down the environment cleanly but I've
read the documentation several times and am following the examples exactly. I've committed every transaction and have closed the XmlContainer,
XmlManager and the Environment.
When I use read-uncommitted, read-committed or serializable transaction isolation everything works fine. I'm only seeing this problem when
I use snapshot isolation. Am I doing something wrong or is this a known problem? If this is a known problem is there a work around?
Here's a copy of the program source code. Thanks in advance for any help you can provide.
package dbxml;
import java.io.File;
import com.sleepycat.dbxml.*;
import com.sleepycat.db.*;
public class txn
public static void main(String args[])
double partId = Double.parseDouble(args[0]);
int partCnt = Integer.parseInt(args[1]);
XmlTransaction txn = null;
Environment myEnv = null;
XmlManager myManager = null;
XmlContainer parts = null;
XmlQueryExpression qe;
XmlResults results;
XmlQueryContext context;
String readQry = "collection('parts.dbxml')/part[@number=$partId]";
String updQry = "replace value of node collection('parts.dbxml')/part[@number=$partId]/description with $desc";
try
EnvironmentConfig envConf = new EnvironmentConfig();
// If the environment doesn't exist, create it.
envConf.setAllowCreate(true);
// Turn on the transactional subsystem.
envConf.setTransactional(true);
// Initialize the in-memory cache
envConf.setInitializeCache(true);
// Initialize the locking subsystem.
envConf.setInitializeLocking(true);
// Initialize the logging subsystem.
envConf.setInitializeLogging(true);
envConf.setLockDetectMode(LockDetectMode.MINWRITE);
envConf.setLockTimeout(5000);
envConf.setTxnMaxActive(200);
envConf.setCacheMax(10000);
envConf.setMaxLocks(10000);
envConf.setMaxLockers(10000);
envConf.setMaxLockObjects(10000);
File envHome = new File("./dbxml/src/dbxml/dbhome");
myEnv = new Environment(envHome, envConf);
XmlManagerConfig managerConfig = new XmlManagerConfig();
managerConfig.setAdoptEnvironment(true);
myManager = new XmlManager(myEnv, managerConfig);
XmlContainerConfig containerConf = new XmlContainerConfig();
containerConf.setTransactional(true);
containerConf.setAllowCreate(true);
// Turn on container-level multiversion concurrency control
containerConf.setMultiversion(true);
parts = myManager.openContainer("parts.dbxml", containerConf);
TransactionConfig txnConfig = new TransactionConfig();
// set the transaction isolation-level
txnConfig.setSnapshot(true);
for (int i = 0; i < partCnt; i++, partId++)
// start a transaction
txn = myManager.createTransaction(null, txnConfig);
context = myManager.createQueryContext();
context.setVariableValue("partId", new XmlValue(partId));
context.setVariableValue("desc", new XmlValue(System.currentTimeMillis()));
qe = myManager.prepare(txn, readQry, context);
results = qe.execute(txn, context);
while (results.hasNext())
String part = results.next().asString();
System.out.println(part);
results.delete();
qe.delete();
// Prepare (compile) the query
qe = myManager.prepare(txn, updQry, context);
results = qe.execute(txn, context);
txn.commit();
results.delete();
qe.delete();
txn.delete();
txn = myManager.createTransaction(null, txnConfig);
qe = myManager.prepare(txn, readQry, context);
results = qe.execute(txn, context);
while (results.hasNext())
String part = results.next().asString();
System.out.println(part);
txn.commit();
results.delete();
context.delete();
qe.delete();
txn.delete();
catch (Exception e)
try
if (txn != null)
txn.abort();
catch(XmlException xe)
xe.printStackTrace();
e.printStackTrace();
finally
try
System.out.println("Shutting Down ...");
if (parts != null)
System.out.println("Closing Container");
parts.close();
if (myManager != null)
System.out.println("Closing Manager");
myManager.close();
System.out.println("Shut Down Complete");
catch (Exception xe)
xe.printStackTrace();
}

Answer 1

From the documentation I linked for you:
The environment should also be configured for sufficient transactions
using [DB_ENV-&gt;set_tx_max|http://www.oracle.com/technology/documentation/berkeley-db/db/api_c/env_set_tx_max.html]. The maximum number of transactions
needs to include all transactions executed concurrently by the
application plus all cursors configured for snapshot isolation.
Further, the transactions are retained until the last page they created
is evicted from cache, so in the extreme case, an additional transaction
may be needed for each page in the cache. Note that cache sizes under
500MB are increased by 25%, so the calculation of number of pages needs
to take this into account.As you can see, to calculate the maximum number of transactions you should configure for, you should use the following formula:
number_of_txns = cache_size / page_size + number_of_concurrently_active_transactionsThis will give you a worst case figure - in practice you may find that a lower number will suffice.
You'll also notice that transactions remain allocated "until the last page they created is evicted from the cache", so you should find that checkpointing will also reduce the number of transactions necessary at any one time.
Using snapshot semantics only on read-only operations will give you the full value provided by MVCC. This means that the read-only (snapshot) transactions will take copies (snapshots) of the pages that are write-locked, but the transactions that write will wait on the write-lock. Using snapshot semantics this way will reduce deadlocks as intended - using snapshot semantics for write transactions just introduces [a new way to get a deadlock|http://www.oracle.com/technology/documentation/berkeley-db/db/api_c/txn_begin.html#DB_TXN_SNAPSHOT]:
The error DB_LOCK_DEADLOCK will be returned from update operations if a snapshot transaction attempts to update data which was modified after the snapshot transaction read it.John