Log file utilization problem

Question

I've encountered a problem with log file utilization during a somwhat long transaction during which some data is inserted in a StoredMap.
I've set the minUtilization property to 75%. During insertion, things seem to go smoothly, but at one point log files are created WAY more rapidly than what the amount of data would call for. The test involves inserting 750K entries for a total of 9Mb, the total size of log files is 359 Mb. Using DbSpace shows that the first few log files use approx 65% of their total space, but most only use 2%.
I understand that during a transaction, the Cleaner may not clean the log files involved. What I don't understand is why are most of the log files only using 2%:
File Size (KB) % Used
00000000 9763 56
00000001 9764 68
00000002 9765 68
00000003 9765 69
00000004 9765 69
00000005 9765 69
00000006 9765 68
00000007 9765 70
00000008 9764 68
00000009 9765 61
0000000a 9763 61
0000000b 9764 25
0000000c 9763 2
0000000d 9763 1
0000000e 9763 2
0000000f 9763 1
00000010 9764 2
00000011 9764 1
00000012 9764 2
00000013 9764 1
00000014 9764 2
00000015 9763 1
00000016 9763 2
00000017 9763 1
00000018 9763 2
00000019 9763 1
0000001a 9765 2
0000001b 9765 1
0000001c 9765 2
0000001d 9763 1
0000001e 9765 2
0000001f 9765 1
00000020 9764 2
00000021 9765 1
00000022 9765 2
00000023 9765 1
00000024 9763 2
00000025 7028 2
TOTALS 368319 21
I've created a test class that reproduces the problem. It might be possible to make it even more simple, but I haven't had time to work on it to much.
Executing this test with 500K values does not reproduce the problem. Can someone please help me shed some light on this issue?
I'm using 3.2.13 and the following properties file:
je.env.isTransactional=true
je.env.isLocking=true
je.env.isReadOnly=false
je.env.recovery=true
je.log.fileMax=10000000
je.cleaner.minUtilization=75
je.cleaner.lookAheadCacheSize=262144
je.cleaner.readSize=1048576
je.maxMemory=104857600
Test Class
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
import com.sleepycat.bind.EntityBinding;
import com.sleepycat.bind.EntryBinding;
import com.sleepycat.bind.tuple.StringBinding;
import com.sleepycat.bind.tuple.TupleBinding;
import com.sleepycat.collections.CurrentTransaction;
import com.sleepycat.collections.StoredMap;
import com.sleepycat.je.Database;
import com.sleepycat.je.DatabaseConfig;
import com.sleepycat.je.DatabaseEntry;
import com.sleepycat.je.DatabaseException;
import com.sleepycat.je.Environment;
import com.sleepycat.je.EnvironmentConfig;
public class LogFileTest3 {
private long totalSize = 0;
private Environment env;
private Database myDb;
private StoredMap storedMap_ = null;
public LogFileTest3() throws DatabaseException, FileNotFoundException, IOException {
Properties props = new Properties();
props.load(new FileInputStream("test3.properties"));
EnvironmentConfig envConfig = new EnvironmentConfig(props);
envConfig.setAllowCreate(true);
File envDir = new File("test3");
if(envDir.exists()==false) {
envDir.mkdir();
env = new Environment(envDir, envConfig);
DatabaseConfig dbConfig = new DatabaseConfig();
dbConfig.setAllowCreate(true);
dbConfig.setTransactional(true);
dbConfig.setSortedDuplicates(false);
myDb = env.openDatabase(null, "testing", dbConfig);
EntryBinding keyBinding = TupleBinding.getPrimitiveBinding(String.class);
EntityBinding valueBinding = new TestValueBinding();
storedMap_ = new StoredMap(myDb, keyBinding, valueBinding, true);
public void cleanup() throws Exception {
myDb.close();
env.close();
private void insertValues(int count) throws DatabaseException {
CurrentTransaction ct = CurrentTransaction.getInstance(this.env);
try {
ct.beginTransaction(null);
int i = 0;
while(i < count) {
TestValue tv = createTestValue(i++);
storedMap_.put(tv.key, tv);
System.out.println("Written "+i+" values for a total of " totalSize" bytes");
ct.commitTransaction();
} catch(Throwable t) {
System.out.println("Exception " + t);
t.printStackTrace();
ct.abortTransaction();
private TestValue createTestValue(int i) {
TestValue t = new TestValue();
t.key = "key_"+i;
t.value = "value_"+i;
return t;
public static void main(String[] args) throws Exception {
LogFileTest3 test = new LogFileTest3();
if(args[0].equalsIgnoreCase("clean")) {
while(test.env.cleanLog() != 0);
} else {
test.insertValues(Integer.parseInt(args[0]));
test.cleanup();
static private class TestValue {
String key = null;
String value = null;
private class TestValueBinding implements EntityBinding {
public Object entryToObject(DatabaseEntry key, DatabaseEntry entry) {
TestValue t = new TestValue();
t.key = StringBinding.entryToString(key);
t.value = StringBinding.entryToString(key);
return t;
public void objectToData(Object o, DatabaseEntry entry) {
TestValue t = (TestValue)o;
StringBinding.stringToEntry(t.value, entry);
totalSize += entry.getSize();
public void objectToKey(Object o, DatabaseEntry entry) {
TestValue t = (TestValue)o;
StringBinding.stringToEntry(t.key, entry);
}

Answer 1

Yup, that solves the issue. By doubling the
je.maxMemory property, I've made the problem
disapear.Good!
How large is the lock on 64 bit architecture?Here's the complete picture for read and write locks. Read locks are taken on get() calls without LockMode.RMW, and write locks are taken on get() calls with RMW and all put() and delete() calls.
Arch  Read Lock  Write Lock
32b    96B       128B
64b   176B       216B
I'm setting the je.maxMemory property becauce I'm
dealing with many small JE environments in a single
VM. I don't want each opened environment to use 90%
of the JVM RAM...OK, I understand.
I've noticed that the je.maxMemory property is
mutable at runtime. Would setting a large value
before long transactions (and resetting it after) be
a feasable solution to my problem? Do you see any
potential issue by doing this?We made the cache size mutable for just this sort of use case. So this is probably worth trying. Of course, to avoid OutOfMemoryError you'll have to reduce the cache size of other environments if you don't have enough unused space in the heap.
Is there a way for me to have JE lock multiple
records at the same time? I mean have it create a
lock for a insert batch instead of every item in the
batch...Not currently. But speaking of possible future changes there are two things that may be of interest to you:
1) For large transaction support we have discussed the idea of providing a new API that locks an entire Database. While a Database is locked by a single transaction, no individual record locks would be needed. However, all other transactions would be blocked from using the Database. More specifically, a Database read lock would block other transactions from writing and a Database write lock would block all access by other transactions. This is the equivalent of "table locking" in relational DBs. This is not currently high on our priority list, but we are gathering input on this issue. We are interested in whether or not a whole Database lock would work for you -- would it?
2) We see more and more users like yourself that open multiple environments in a single JVM. Although the cache size is mutable, this puts the burden of efficient memory management onto the application. To solve this problem, we intend to add the option of a shared JE cache for all environments in a JVM process. The entire cache would be managed by an LRU algorithm, so if one environment needs more memory than another, the cache dynamically adjusts. This is high on our priority list, although per Oracle policy I can't say anything about when it will be available.
Besides increasing the je.maxMemory, do you see any
other solution to my problem?Use smaller transactions. ;-) Seriously, if you have not already ruled this out, you may want to consider whether you really need an atomic transaction. We also support non-transactional access and even a non-locking mode for off-line bulk loads.
Thanks a bunch for your help!You're welcome!
Mark