LOG4J2-1447 LOG4J2-1349 (log4j-perf) renamed OpenHashMapContextData to 
OpenHashStringMap


Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo
Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/895d8697
Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/895d8697
Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/895d8697

Branch: refs/heads/master
Commit: 895d86975731c17af7e9adc16f530c40d92c3738
Parents: 2aa1a80
Author: rpopma <rpo...@apache.org>
Authored: Fri Sep 23 02:04:43 2016 +0900
Committer: rpopma <rpo...@apache.org>
Committed: Fri Sep 23 02:04:43 2016 +0900

----------------------------------------------------------------------
 .../perf/jmh/SortedArrayVsHashMapBenchmark.java |  16 +-
 .../log4j/perf/jmh/ThreadContextBenchmark.java  |   4 +-
 .../log4j/perf/nogc/OpenHashMapContextData.java | 938 -------------------
 .../log4j/perf/nogc/OpenHashStringMap.java      | 938 +++++++++++++++++++
 .../CopyOnWriteOpenHashMapThreadContextMap.java |   8 +-
 .../GarbageFreeOpenHashMapThreadContextMap.java |   8 +-
 6 files changed, 956 insertions(+), 956 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/895d8697/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/SortedArrayVsHashMapBenchmark.java
----------------------------------------------------------------------
diff --git 
a/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/SortedArrayVsHashMapBenchmark.java
 
b/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/SortedArrayVsHashMapBenchmark.java
index df63b5f..d951617 100644
--- 
a/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/SortedArrayVsHashMapBenchmark.java
+++ 
b/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/SortedArrayVsHashMapBenchmark.java
@@ -22,7 +22,7 @@ import java.util.Map;
 import java.util.Random;
 import java.util.concurrent.TimeUnit;
 
-import org.apache.logging.log4j.perf.nogc.OpenHashMapContextData;
+import org.apache.logging.log4j.perf.nogc.OpenHashStringMap;
 import org.apache.logging.log4j.util.SortedArrayStringMap;
 import org.apache.logging.log4j.util.BiConsumer;
 import org.apache.logging.log4j.util.TriConsumer;
@@ -73,15 +73,15 @@ public class SortedArrayVsHashMapBenchmark {
     private static Object value = new Object();
     private HashMap<String, Object> map;
     private SortedArrayStringMap sortedStringArrayMap;
-    private OpenHashMapContextData<String, Object> openHashMapContextData;
+    private OpenHashStringMap<String, Object> openHashMapContextData;
 
     private HashMap<String, Object> populatedMap;
     private SortedArrayStringMap populatedSortedStringArrayMap;
-    private OpenHashMapContextData<String, Object> 
populatedOpenHashContextData;
+    private OpenHashStringMap<String, Object> populatedOpenHashContextData;
 
     @Setup
     public void setup() {
-        openHashMapContextData = new OpenHashMapContextData<>();
+        openHashMapContextData = new OpenHashStringMap<>();
         sortedStringArrayMap = new SortedArrayStringMap();
         map = new HashMap<>();
 
@@ -103,7 +103,7 @@ public class SortedArrayVsHashMapBenchmark {
         for (int i = 0; i < count; i++) {
             populatedSortedStringArrayMap.putValue(keys[i], value);
         }
-        populatedOpenHashContextData = new OpenHashMapContextData<>();
+        populatedOpenHashContextData = new OpenHashStringMap<>();
         for (int i = 0; i < count; i++) {
             populatedOpenHashContextData.putValue(keys[i], value);
         }
@@ -117,7 +117,7 @@ public class SortedArrayVsHashMapBenchmark {
     }
 
     @Benchmark
-    public OpenHashMapContextData<String, Object> putAllHashContextData() {
+    public OpenHashStringMap<String, Object> putAllHashContextData() {
         openHashMapContextData.clear();
         openHashMapContextData.putAll(populatedOpenHashContextData);
         return openHashMapContextData;
@@ -136,8 +136,8 @@ public class SortedArrayVsHashMapBenchmark {
     }
 
     @Benchmark
-    public OpenHashMapContextData<String, Object> cloneHashContextData() {
-        return new OpenHashMapContextData<>(populatedOpenHashContextData);
+    public OpenHashStringMap<String, Object> cloneHashContextData() {
+        return new OpenHashStringMap<>(populatedOpenHashContextData);
     }
 
     @Benchmark

http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/895d8697/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/ThreadContextBenchmark.java
----------------------------------------------------------------------
diff --git 
a/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/ThreadContextBenchmark.java
 
b/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/ThreadContextBenchmark.java
index 7ca0855..2f61369 100644
--- 
a/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/ThreadContextBenchmark.java
+++ 
b/log4j-perf/src/main/java/org/apache/logging/log4j/perf/jmh/ThreadContextBenchmark.java
@@ -30,7 +30,7 @@ import org.apache.logging.log4j.ThreadContextBenchmarkAccess;
 import org.apache.logging.log4j.core.config.Property;
 import org.apache.logging.log4j.core.ContextDataInjector;
 import org.apache.logging.log4j.core.impl.ContextDataInjectorFactory;
-import org.apache.logging.log4j.perf.nogc.OpenHashMapContextData;
+import org.apache.logging.log4j.perf.nogc.OpenHashStringMap;
 import org.apache.logging.log4j.spi.CopyOnWriteOpenHashMapThreadContextMap;
 import org.apache.logging.log4j.spi.DefaultThreadContextMap;
 import org.apache.logging.log4j.spi.GarbageFreeOpenHashMapThreadContextMap;
@@ -111,7 +111,7 @@ public class ThreadContextBenchmark {
 
         reusableContextData = threadContextMapAlias.contains("Array")
                 ? new SortedArrayStringMap()
-                : new OpenHashMapContextData<>();
+                : new OpenHashStringMap<>();
 
         keys = new String[count];
         values = new String[count];

http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/895d8697/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashMapContextData.java
----------------------------------------------------------------------
diff --git 
a/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashMapContextData.java
 
b/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashMapContextData.java
deleted file mode 100644
index 1d7c647..0000000
--- 
a/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashMapContextData.java
+++ /dev/null
@@ -1,938 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache license, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the license for the specific language governing permissions and
- * limitations under the license.
- */
-package org.apache.logging.log4j.perf.nogc;
-
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.ConcurrentModificationException;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-
-import org.apache.logging.log4j.util.ReadOnlyStringMap;
-import org.apache.logging.log4j.util.StringMap;
-import org.apache.logging.log4j.spi.ThreadContextMap;
-import org.apache.logging.log4j.util.BiConsumer;
-import org.apache.logging.log4j.util.TriConsumer;
-
-/**
- * Open hash map-based implementation of the {@code ReadOnlyStringMap} 
interface.
- * Implementation based on <a 
href="http://fastutil.di.unimi.it/";>fastutil</a>'s
- * <a 
href="http://fastutil.di.unimi.it/docs/it/unimi/dsi/fastutil/objects/Object2ObjectOpenHashMap.html";>Object2ObjectOpenHashMap</a>.
- * <p>
- * A type-specific hash map with a fast, small-footprint implementation.
- *
- * <P>
- * Instances of this class use a hash table to represent a map. The table is
- * filled up to a specified <em>load factor</em>, and then doubled in size to
- * accommodate new entries. If the table is emptied below <em>one fourth</em> 
of
- * the load factor, it is halved in size. However, halving is not performed 
when
- * deleting entries from an iterator, as it would interfere with the iteration
- * process.
- *
- * <p>
- * Note that {@link #clear()} does not modify the hash table size. Rather, the
- * {@link #trim(int)} method lets you control the size of
- * the table; this is particularly useful if you reuse instances of this class.
- * <p>
- * <ul>
- *   <li>Garbage-free iteration over key-value pairs with {@code BiConsumer} 
and {@code TriConsumer}.</li>
- *   <li>Fast copy. If the ThreadContextMap is also an instance of {@code 
OpenHashMapContextData},
- *     the full thread context data can be transferred with two array copies 
and five field updates.</li>
- * </ul>
- *
- * @since 2.7
- */
-public class OpenHashMapContextData<K, V> implements StringMap, 
ThreadContextMap {
-    /** The initial default size of a hash table. */
-    public static final int DEFAULT_INITIAL_SIZE = 16;
-
-    /** The default load factor of a hash table. */
-    public static final float DEFAULT_LOAD_FACTOR = .75f;
-
-    private static final String FROZEN = "Frozen collection cannot be 
modified";
-    private static final long serialVersionUID = -1486744623338827187L;
-
-    /** The array of keys. */
-    protected transient K[] keys;
-    /** The array of values. */
-    protected transient V[] values;
-    /** The mask for wrapping a position counter. */
-    protected transient int mask;
-    /** Whether this set contains the key zero. */
-    protected transient boolean containsNullKey;
-    /** The current table size. */
-    protected transient int arraySize;
-    /**
-     * Threshold after which we rehash. It must be the table size times {@link 
#loadFactor}.
-     */
-    protected transient int maxFill;
-    /** Number of entries in the set (including the key zero, if present). */
-    protected int size;
-    /** The acceptable load factor. */
-    protected final float loadFactor;
-
-    private final V defRetValue = null;
-    private boolean immutable;
-    private transient boolean iterating;
-
-    /**
-     * Creates a new hash map with initial expected
-     * {@link #DEFAULT_INITIAL_SIZE} entries and
-     * {@link #DEFAULT_LOAD_FACTOR} as load factor.
-     */
-    public OpenHashMapContextData() {
-        this(DEFAULT_INITIAL_SIZE, DEFAULT_LOAD_FACTOR);
-    }
-    /**
-     * Creates a new hash map with {@link #DEFAULT_LOAD_FACTOR} as load factor.
-     *
-     * @param expected
-     *            the expected number of elements in the hash map.
-     */
-    public OpenHashMapContextData(final int expected) {
-        this(expected, DEFAULT_LOAD_FACTOR);
-    }
-    /**
-     * Creates a new hash map.
-     *
-     * <p>
-     * The actual table size will be the least power of two greater than
-     * <code>expected</code>/<code>f</code>.
-     *
-     * @param expected
-     *            the expected number of elements in the hash set.
-     * @param f
-     *            the load factor.
-     */
-    @SuppressWarnings("unchecked")
-    public OpenHashMapContextData(final int expected, final float f) {
-        if (f <= 0 || f > 1) {
-            throw new IllegalArgumentException(
-                    "Load factor must be greater than 0 and smaller than or 
equal to 1");
-        }
-        if (expected < 0){
-            throw new IllegalArgumentException(
-                    "The expected number of elements must be nonnegative");
-        }
-        this.loadFactor = f;
-        arraySize = HashCommon.arraySize(expected, f);
-        mask = arraySize - 1;
-        maxFill = HashCommon.maxFill(arraySize, f);
-        keys = (K[]) new Object[arraySize + 1];
-        values = (V[]) new Object[arraySize + 1];
-    }
-    /**
-     * Creates a new hash map with {@link #DEFAULT_LOAD_FACTOR} as load
-     * factor copying a given one.
-     *
-     * @param map
-     *            a {@link Map} to be copied into the new hash map.
-     */
-    public OpenHashMapContextData(final Map<? extends K, ? extends V> map) {
-        this(map, DEFAULT_LOAD_FACTOR);
-    }
-    /**
-     * Creates a new hash map copying a given one.
-     *
-     * @param map
-     *            a {@link Map} to be copied into the new hash map.
-     * @param f
-     *            the load factor.
-     */
-    public OpenHashMapContextData(final Map<? extends K, ? extends V> map, 
final float f) {
-        this(map.size(), f);
-        putAll(map);
-    }
-
-    /**
-     * Creates a new hash map with {@link #DEFAULT_LOAD_FACTOR} as load
-     * factor copying a given type-specific one.
-     *
-     * @param contextData
-     *            a type-specific map to be copied into the new hash map.
-     */
-    public OpenHashMapContextData(final ReadOnlyStringMap contextData) {
-        this(contextData, DEFAULT_LOAD_FACTOR);
-    }
-    /**
-     * Creates a new hash map copying a given type-specific one.
-     *
-     * @param contextData
-     *            a type-specific map to be copied into the new hash map.
-     * @param f
-     *            the load factor.
-     */
-    public OpenHashMapContextData(final ReadOnlyStringMap contextData, final 
float f) {
-        this(contextData.size(), f);
-        if (contextData instanceof OpenHashMapContextData) {
-            initFrom0((OpenHashMapContextData) contextData);
-        } else {
-            contextData.forEach(PUT_ALL, this);
-        }
-    }
-    private static final TriConsumer<String, Object, StringMap> PUT_ALL =
-            new TriConsumer<String, Object, StringMap>() {
-        @Override
-        public void accept(final String key, final Object value, final 
StringMap contextData) {
-            contextData.putValue(key, value);
-        }
-    };
-
-    private void assertNotFrozen() {
-        if (immutable) {
-            throw new UnsupportedOperationException(FROZEN);
-        }
-    }
-
-    private void assertNoConcurrentModification() {
-        if (iterating) {
-            throw new ConcurrentModificationException();
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private void initFrom0(final OpenHashMapContextData other) {
-        // this.loadFactor = other.loadFactor; // final field
-        this.arraySize = other.arraySize;
-        this.size = other.size;
-        this.containsNullKey = other.containsNullKey;
-        this.mask = other.mask;
-        this.maxFill = other.maxFill;
-        keys = (K[]) Arrays.copyOf(other.keys, arraySize + 1);
-        values = (V[]) Arrays.copyOf(other.values, arraySize + 1);
-    }
-
-    private int realSize() {
-        return containsNullKey ? size - 1 : size;
-    }
-
-    private void ensureCapacity(final int capacity) {
-        final int needed = HashCommon.arraySize(capacity, loadFactor);
-        if (needed > arraySize) {
-            rehash(needed);
-        }
-    }
-
-    private void tryCapacity(final long capacity) {
-        final int needed = Math.min(
-                1 << 30, Math.max(2, HashCommon.nextPowerOfTwo((int) 
Math.ceil(capacity / loadFactor))));
-        if (needed > arraySize) {
-            rehash(needed);
-        }
-    }
-
-    @Override
-    public Map<String, String> toMap() {
-        final Map<String, String> result = new HashMap<>(size);
-        forEach(COPY_INTO_MAP, result);
-        return result;
-    }
-
-    private static final TriConsumer<String, Object, Map<String, String>> 
COPY_INTO_MAP =
-            new TriConsumer<String, Object, Map<String, String>>() {
-        @Override
-        public void accept(final String k, final Object v, final Map<String, 
String> map) {
-            map.put(k, v == null ? null : v.toString());
-        }
-    };
-
-    /*
-     * Removes all elements from this map.
-     *
-     * <P>To increase object reuse, this method does not change the table size.
-     * If you want to reduce the table size, you must use {@link #trim()}.
-     */
-    @Override
-    public void clear() {
-        if (size == 0) {
-            return;
-        }
-        assertNotFrozen();
-        assertNoConcurrentModification();
-
-        size = 0;
-        containsNullKey = false;
-        Arrays.fill(keys, (null));
-        Arrays.fill(values, null);
-    }
-
-    @Override
-    public boolean containsKey(final String key) {
-        return containsObjectKey(key);
-    }
-
-    @SuppressWarnings("unchecked")
-    private boolean containsObjectKey(final Object k) {
-        if (k == null) {
-            return containsNullKey;
-        }
-        K curr;
-        final K[] key = this.keys;
-        int pos;
-        // The starting point.
-        if ((curr = key[pos = HashCommon.mix(k.hashCode()) & mask]) == null) {
-            return false;
-        }
-        if (k.equals(curr)) {
-            return true;
-        }
-        // There's always an unused entry.
-        while (true) {
-            if ((curr = key[pos = (pos + 1) & mask]) == null) {
-                return false;
-            }
-            if (k.equals(curr)) {
-                return true;
-            }
-        }
-    }
-
-    @Override
-       public boolean equals(final Object obj) {
-        if (obj == this) {
-            return true;
-        }
-        if (!(obj instanceof ReadOnlyStringMap)) {
-            return false;
-        }
-        final ReadOnlyStringMap other = (ReadOnlyStringMap) obj;
-        if (other.size() != size()) {
-            return false;
-        }
-        int pos = arraySize;
-        if (containsNullKey) {
-            if (!Objects.equals(getObjectValue(null), other.getValue(null))) {
-                return false;
-            }
-        }
-        --pos;
-        final K myKeys[] = this.keys;
-        for (; pos >= 0; pos--) {
-            K k;
-            if ((k = myKeys[pos]) != null) {
-                if (!Objects.equals(values[pos], other.getValue((String) k))) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public <VAL> void forEach(final BiConsumer<String, ? super VAL> action) {
-        final int startSize = size;
-        final K myKeys[] = this.keys;
-        int pos = arraySize;
-
-        iterating = true;
-        try {
-            if (containsNullKey) {
-                action.accept((String) myKeys[pos], (VAL) values[pos]);
-                if (size != startSize) {
-                    throw new ConcurrentModificationException();
-                }
-            }
-            --pos;
-            for (; pos >= 0; pos--) {
-                if (myKeys[pos] != null) {
-                    action.accept((String) myKeys[pos], (VAL) values[pos]);
-                    if (size != startSize) {
-                        throw new ConcurrentModificationException();
-                    }
-                }
-            }
-        } finally {
-            iterating = false;
-        }
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public <VAL, STATE> void forEach(final TriConsumer<String, ? super VAL, 
STATE> action, final STATE state) {
-        final int startSize = size;
-        final K myKeys[] = this.keys;
-        int pos = arraySize;
-
-        iterating = true;
-        try {
-            if (containsNullKey) {
-                action.accept((String) myKeys[pos], (VAL) values[pos], state);
-                if (size != startSize) {
-                    throw new ConcurrentModificationException();
-                }
-            }
-            --pos;
-            for (; pos >= 0; pos--) {
-                if (myKeys[pos] != null) {
-                    action.accept((String) myKeys[pos], (VAL) values[pos], 
state);
-                    if (size != startSize) {
-                        throw new ConcurrentModificationException();
-                    }
-                }
-            }
-        } finally {
-            iterating = false;
-        }
-    }
-
-    @Override
-    public String get(final String key) {
-        return (String) getObjectValue(key);
-    }
-
-    @SuppressWarnings("unchecked")
-    private V getObjectValue(final Object k) {
-        if (k == null) {
-            return containsNullKey ? values[arraySize] : defRetValue;
-        }
-        K curr;
-        final K[] key = this.keys;
-        int pos;
-        // The starting point.
-        if ((curr = key[pos = HashCommon.mix(k.hashCode()) & mask]) == null) {
-            return defRetValue;
-        }
-        if (k.equals(curr)) {
-            return values[pos];
-        }
-        // There's always an unused entry.
-        while (true) {
-            if (((curr = key[pos = (pos + 1) & mask]) == null)) {
-                return defRetValue;
-            }
-            if (k.equals(curr)) {
-                return values[pos];
-            }
-        }
-    }
-
-    @Override
-    public Map<String, String> getCopy() {
-        return toMap();
-    }
-
-    @Override
-    public Map<String, String> getImmutableMapOrNull() {
-        return isEmpty() ? null : Collections.unmodifiableMap(toMap());
-    }
-
-    @Override
-    public <VAL> VAL getValue(final String key) {
-        return (VAL) getObjectValue(key);
-    }
-
-    @Override
-    public boolean isEmpty() {
-        return size == 0;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void put(final String key, final String value) {
-        putObjectValue((K) key, (V) value);
-    }
-
-    private int insert(final K k, final V v) {
-        int pos;
-        if (k == null) {
-            if (containsNullKey) {
-                return arraySize;
-            }
-            containsNullKey = true;
-            pos = arraySize;
-        } else {
-            K curr;
-            final K[] key = this.keys;
-            // The starting point.
-            if (!((curr = key[pos = HashCommon.mix(k.hashCode()) & mask]) == 
null)) {
-                if (curr.equals(k)) {
-                    return pos;
-                }
-                while (!((curr = key[pos = (pos + 1) & mask]) == null)) {
-                    if (curr.equals(k)) {
-                        return pos;
-                    }
-                }
-            }
-        }
-        keys[pos] = k;
-        values[pos] = v;
-        if (size++ >= maxFill) {
-            rehash(HashCommon.arraySize(size + 1, loadFactor));
-        }
-        return -1;
-    }
-
-    @Override
-    public void putAll(final ReadOnlyStringMap source) {
-        assertNotFrozen();
-        assertNoConcurrentModification();
-
-        if (size() == 0 && source instanceof OpenHashMapContextData) {
-            initFrom0((OpenHashMapContextData) source);
-        } else if (source != null) {
-            source.forEach(PUT_ALL, this);
-        }
-    }
-
-    /** {@inheritDoc} */
-    public void putAll(final Map<? extends K, ? extends V> map) {
-        if (loadFactor <= .5) {
-            // The resulting map will be sized for m.size() elements
-            ensureCapacity(map.size());
-        } else {
-            // The resulting map will be tentatively sized for size() +  
m.size() elements
-            tryCapacity(size() + map.size());
-        }
-        for (final Map.Entry<? extends K, ? extends V> entry : map.entrySet()) 
{
-            putObjectValue(entry.getKey(), entry.getValue());
-        }
-    }
-
-    private V putObjectValue(final K k, final V v) {
-        assertNotFrozen();
-        assertNoConcurrentModification();
-
-        final int pos = insert(k, v);
-        if (pos < 0) {
-            return defRetValue;
-        }
-        final V oldValue = values[pos];
-        values[pos] = v;
-        return oldValue;
-    }
-
-    @Override
-    @SuppressWarnings("unchecked")
-    public void putValue(final String key, final Object value) {
-        putObjectValue((K) key, (V) value);
-    }
-
-    @Override
-    public void remove(final String key) {
-        removeObjectKey(key);
-    }
-
-    @Override
-    public void freeze() {
-        immutable = true;
-    }
-
-    @Override
-    public boolean isFrozen() {
-        return immutable;
-    }
-
-    @SuppressWarnings("unchecked")
-    private V removeObjectKey(final Object k) {
-        assertNotFrozen();
-        assertNoConcurrentModification();
-
-        if (k == null) {
-            if (containsNullKey) {
-                return removeNullEntry();
-            }
-            return defRetValue;
-        }
-        final K[] key = this.keys;
-        int pos = HashCommon.mix(k.hashCode()) & mask;
-        K curr = key[pos & mask];
-        // The starting point.
-        if (curr == null) {
-            return defRetValue;
-        }
-        if (k.equals(curr)) {
-            return removeEntry(pos);
-        }
-        while (true) {
-            if ((curr = key[pos = (pos + 1) & mask]) == null) {
-                return defRetValue;
-            }
-            if (k.equals(curr)) {
-                return removeEntry(pos);
-            }
-        }
-    }
-    private V removeEntry(final int pos) {
-        final V oldValue = values[pos];
-        values[pos] = null;
-        size--;
-        shiftKeys(pos);
-        if (size < maxFill / 4 && arraySize > DEFAULT_INITIAL_SIZE) {
-            rehash(arraySize / 2);
-        }
-        return oldValue;
-    }
-    private V removeNullEntry() {
-        containsNullKey = false;
-        keys[arraySize] = null;
-        final V oldValue = values[arraySize];
-        values[arraySize] = null;
-        size--;
-        if (size < maxFill / 4 && arraySize > DEFAULT_INITIAL_SIZE) {
-            rehash(arraySize / 2);
-        }
-        return oldValue;
-    }
-    /**
-     * Shifts left entries with the specified hash code, starting at the
-     * specified position, and empties the resulting free entry.
-     *
-     * @param pos
-     *            a starting position.
-     */
-    private void shiftKeys(int pos) {
-        // Shift entries with the same hash.
-        int last, slot;
-        K curr;
-        final K[] myKeys = this.keys;
-        for (;;) {
-            pos = ((last = pos) + 1) & mask;
-            for (;;) {
-                if (((curr = myKeys[pos]) == null)) {
-                    myKeys[last] = (null);
-                    values[last] = null;
-                    return;
-                }
-                slot = HashCommon.mix(curr.hashCode()) & mask;
-                if (last <= pos ? (last >= slot || slot > pos) : (last >= slot 
&& slot > pos)) {
-                    break;
-                }
-                pos = (pos + 1) & mask;
-            }
-            myKeys[last] = curr;
-            values[last] = values[pos];
-        }
-    }
-
-    @Override
-    public int size() {
-        return size;
-    }
-
-    /**
-     * Rehashes this map if the table is too large.
-     *
-     * <P>
-     * Let <var>N</var> be the smallest table size that can hold
-     * <code>max(n,{@link #size()})</code> entries, still satisfying the load
-     * factor. If the current table size is smaller than or equal to
-     * <var>N</var>, this method does nothing. Otherwise, it rehashes this map
-     * in a table of size <var>N</var>.
-     *
-     * <P>
-     * This method is useful when reusing maps. {@linkplain #clear() Clearing a
-     * map} leaves the table size untouched. If you are reusing a map many 
times,
-     * you can call this method with a typical size to avoid keeping around a
-     * very large table just because of a few large transient maps.
-     *
-     * @param n
-     *            the threshold for the trimming.
-     * @return true if there was enough memory to trim the map.
-     */
-    public boolean trim(final int n) {
-        final int l = HashCommon.nextPowerOfTwo((int) Math.ceil(n / 
loadFactor));
-        if (l >= n || size > HashCommon.maxFill(l, loadFactor)) {
-                       return true;
-               }
-        try {
-            rehash(l);
-        } catch (final OutOfMemoryError cantDoIt) { // unusual to catch OOME 
but in this case appropriate
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Rehashes the map.
-     *
-     * <P>
-     * This method implements the basic rehashing strategy, and may be 
overriden
-     * by subclasses implementing different rehashing strategies (e.g.,
-     * disk-based rehashing). However, you should not override this method
-     * unless you understand the internal workings of this class.
-     *
-     * @param newN
-     *            the new size
-     */
-    @SuppressWarnings("unchecked")
-    protected void rehash(final int newN) {
-        final K myKeys[] = this.keys;
-        final V myValues[] = this.values;
-        final int mask = newN - 1; // Note that this is used by the hashing
-        // macro
-        final K newKey[] = (K[]) new Object[newN + 1];
-        final V newValue[] = (V[]) new Object[newN + 1];
-        int i = arraySize, pos;
-        for (int j = realSize(); j-- != 0;) {
-            while (myKeys[--i] == null) {
-                // advance i until we find an existing key
-            }
-            if (newKey[pos = HashCommon.mix(myKeys[i].hashCode()) & mask] != 
null) { // rehash & check slot availability
-                while (newKey[pos = (pos + 1) & mask] != null) {
-                    // find available slot at (or immediately following) pos
-                }
-            }
-            newKey[pos] = myKeys[i];
-            newValue[pos] = myValues[i];
-        }
-        newValue[newN] = myValues[arraySize];
-        arraySize = newN;
-        this.mask = mask;
-        maxFill = HashCommon.maxFill(arraySize, loadFactor);
-        this.keys = newKey;
-        this.values = newValue;
-    }
-
-    /**
-     * Returns a hash code for this map.
-     *
-     * @return a hash code for this map.
-     */
-    @Override
-       public int hashCode() {
-        int result = 0;
-        for (int j = realSize(), i = 0, t = 0; j-- != 0;) {
-            while (keys[i] == null) {
-                i++;
-            }
-            if (this != keys[i]) {
-                t = keys[i].hashCode();
-            }
-            if (this != values[i]) {
-                t ^= (values[i] == null ? 0 : values[i].hashCode());
-            }
-            result += t;
-            i++;
-        }
-        // Zero / null keys have hash zero.
-        if (containsNullKey) {
-            result += (values[arraySize] == null ? 0 : 
values[arraySize].hashCode());
-        }
-        return result;
-    }
-
-    @SuppressWarnings("unchecked")
-    private void readObject(final ObjectInputStream s) throws IOException, 
ClassNotFoundException {
-        s.defaultReadObject();
-        arraySize = HashCommon.arraySize(size, loadFactor);
-        maxFill = HashCommon.maxFill(arraySize, loadFactor);
-        mask = arraySize - 1;
-        final K key[] = this.keys = (K[]) new Object[arraySize + 1];
-        final V value[] = this.values = (V[]) new Object[arraySize + 1];
-        K k;
-        V v;
-        for (int i = size, pos; i-- != 0;) {
-            k = (K) s.readObject();
-            v = (V) s.readObject();
-            if (k == null) {
-                pos = arraySize;
-                containsNullKey = true;
-            } else {
-                pos = HashCommon.mix(k.hashCode()) & mask;
-                while (key[pos] != null) {
-                    pos = (pos + 1) & mask;
-                }
-            }
-            key[pos] = k;
-            value[pos] = v;
-        }
-    }
-
-    private void writeObject(final ObjectOutputStream s) throws IOException {
-        s.defaultWriteObject();
-        try {
-            forEach(SERIALIZER, s);
-        } catch (final RuntimeException runex) {
-            if (runex.getCause() instanceof IOException) {
-                throw (IOException) runex.getCause();
-            }
-            throw runex;
-        }
-    }
-
-    private static final TriConsumer<String, Object, ObjectOutputStream> 
SERIALIZER =
-            new TriConsumer<String, Object, ObjectOutputStream>() {
-                @Override
-                public void accept(final String k, final Object v, final 
ObjectOutputStream objectOutputStream) {
-                    try {
-                        objectOutputStream.writeObject(k);
-                        objectOutputStream.writeObject(v);
-                    } catch (final IOException ioex) {
-                        throw new IllegalStateException(ioex);
-                    }
-                }
-            };
-
-    @Override
-    public String toString() {
-        final StringBuilder sb = new StringBuilder(256);
-        sb.append('{');
-        final K myKeys[] = this.keys;
-        int pos = arraySize;
-        boolean first = true;
-        if (containsNullKey) {
-            sb.append(myKeys[pos] == this ? "(this map)" : myKeys[pos]);
-            sb.append('=');
-            sb.append(values[pos] == this ? "(this map)" : values[pos]);
-            first = false;
-        }
-        --pos;
-        for (; pos >= 0; pos--) {
-            if (myKeys[pos] != null) {
-                if (first) {
-                    first = false;
-                } else {
-                    sb.append(", ");
-                }
-                sb.append(myKeys[pos] == this ? "(this map)" : myKeys[pos]);
-                sb.append('=');
-                sb.append(values[pos] == this ? "(this map)" : values[pos]);
-            }
-        }
-        sb.append('}');
-        return sb.toString();
-    }
-
-    private static class HashCommon {
-        private HashCommon() {}
-
-        /** 2<sup>32</sup> &middot; &phi;, &phi; = (&#x221A;5 &minus; 1)/2. */
-        private static final int INT_PHI = 0x9E3779B9;
-
-        /** The reciprocal of {@link #INT_PHI} modulo 2<sup>32</sup>. */
-        private static final int INV_INT_PHI = 0x144cbc89;
-
-        /** Avalanches the bits of an integer by applying the finalisation 
step of MurmurHash3.
-         *
-         * <p>This method implements the finalisation step of Austin Appleby's
-         * <a href="http://code.google.com/p/smhasher/";>MurmurHash3</a>.
-         * Its purpose is to avalanche the bits of the argument to within 
0.25% bias.
-         *
-         * @param x an integer.
-         * @return a hash value with good avalanching properties.
-         */
-        public static int murmurHash3(int x) {
-            x ^= x >>> 16;
-            x *= 0x85ebca6b;
-            x ^= x >>> 13;
-            x *= 0xc2b2ae35;
-            x ^= x >>> 16;
-            return x;
-        }
-
-        /**
-         * Quickly mixes the bits of an integer.
-         *
-         * <p>This method mixes the bits of the argument by multiplying by the 
golden ratio and
-         * xorshifting the result. It is borrowed from <a 
href="https://github.com/OpenHFT/Koloboke";>Koloboke</a>, and
-         * it has slightly worse behaviour than {@link #murmurHash3(int)} (in 
open-addressing hash tables the average
-         * number of probes is slightly larger), but it's much faster.
-         *
-         * @param x an integer.
-         * @return a hash value obtained by mixing the bits of {@code x}.
-         * @see #invMix(int)
-         */
-        public static int mix(final int x) {
-            final int h = x * INT_PHI;
-            return h ^ (h >>> 16);
-        }
-
-        /** The inverse of {@link #mix(int)}. This method is mainly useful to 
create unit tests.
-         *
-         * @param x an integer.
-         * @return a value that passed through {@link #mix(int)} would give 
{@code x}.
-         */
-        public static int invMix(final int x) {
-            return (x ^ x >>> 16) * INV_INT_PHI;
-        }
-
-        /** Return the least power of two greater than or equal to the 
specified value.
-         *
-         * <p>Note that this function will return 1 when the argument is 0.
-         *
-         * @param x an integer smaller than or equal to 2<sup>30</sup>.
-         * @return the least power of two greater than or equal to the 
specified value.
-         */
-        public static int nextPowerOfTwo(int x) {
-            if (x == 0) {
-                return 1;
-            }
-            x--;
-            x |= x >> 1;
-            x |= x >> 2;
-            x |= x >> 4;
-            x |= x >> 8;
-            return (x | x >> 16) + 1;
-        }
-
-        /** Return the least power of two greater than or equal to the 
specified value.
-         *
-         * <p>Note that this function will return 1 when the argument is 0.
-         *
-         * @param x a long integer smaller than or equal to 2<sup>62</sup>.
-         * @return the least power of two greater than or equal to the 
specified value.
-         */
-        public static long nextPowerOfTwo(long x) {
-            if (x == 0) {
-                return 1;
-            }
-            x--;
-            x |= x >> 1;
-            x |= x >> 2;
-            x |= x >> 4;
-            x |= x >> 8;
-            x |= x >> 16;
-            return (x | x >> 32) + 1;
-        }
-
-
-        /** Returns the maximum number of entries that can be filled before 
rehashing.
-         *
-         * @param n the size of the backing array.
-         * @param f the load factor.
-         * @return the maximum number of entries before rehashing.
-         */
-        public static int maxFill(final int n, final float f) {
-               /* We must guarantee that there is always at least
-                * one free entry (even with pathological load factors). */
-            return Math.min((int) Math.ceil(n * f), n - 1);
-        }
-
-        /**
-         * Returns the least power of two smaller than or equal to 
2<sup>30</sup> and larger than or equal to
-         * <code>Math.ceil( expected / f )</code>.
-         *
-         * @param expected the expected number of elements in a hash table.
-         * @param f the load factor.
-         * @return the minimum possible size for a backing array.
-         * @throws IllegalArgumentException if the necessary size is larger 
than 2<sup>30</sup>.
-         */
-        public static int arraySize(final int expected, final float f) {
-            final long result = Math.max(2, nextPowerOfTwo((long) 
Math.ceil(expected / f)));
-            if (result > (1 << 30)) {
-                throw new IllegalArgumentException("Too large (" + expected +
-                        " expected elements with load factor " + f + ")");
-            }
-            return (int) result;
-        }
-    }
-}

http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/895d8697/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashStringMap.java
----------------------------------------------------------------------
diff --git 
a/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashStringMap.java
 
b/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashStringMap.java
new file mode 100644
index 0000000..c4ac559
--- /dev/null
+++ 
b/log4j-perf/src/main/java/org/apache/logging/log4j/perf/nogc/OpenHashStringMap.java
@@ -0,0 +1,938 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache license, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the license for the specific language governing permissions and
+ * limitations under the license.
+ */
+package org.apache.logging.log4j.perf.nogc;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.ConcurrentModificationException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import org.apache.logging.log4j.util.ReadOnlyStringMap;
+import org.apache.logging.log4j.util.StringMap;
+import org.apache.logging.log4j.spi.ThreadContextMap;
+import org.apache.logging.log4j.util.BiConsumer;
+import org.apache.logging.log4j.util.TriConsumer;
+
+/**
+ * Open hash map-based implementation of the {@code ReadOnlyStringMap} 
interface.
+ * Implementation based on <a 
href="http://fastutil.di.unimi.it/";>fastutil</a>'s
+ * <a 
href="http://fastutil.di.unimi.it/docs/it/unimi/dsi/fastutil/objects/Object2ObjectOpenHashMap.html";>Object2ObjectOpenHashMap</a>.
+ * <p>
+ * A type-specific hash map with a fast, small-footprint implementation.
+ *
+ * <P>
+ * Instances of this class use a hash table to represent a map. The table is
+ * filled up to a specified <em>load factor</em>, and then doubled in size to
+ * accommodate new entries. If the table is emptied below <em>one fourth</em> 
of
+ * the load factor, it is halved in size. However, halving is not performed 
when
+ * deleting entries from an iterator, as it would interfere with the iteration
+ * process.
+ *
+ * <p>
+ * Note that {@link #clear()} does not modify the hash table size. Rather, the
+ * {@link #trim(int)} method lets you control the size of
+ * the table; this is particularly useful if you reuse instances of this class.
+ * <p>
+ * <ul>
+ *   <li>Garbage-free iteration over key-value pairs with {@code BiConsumer} 
and {@code TriConsumer}.</li>
+ *   <li>Fast copy. If the ThreadContextMap is also an instance of {@code 
OpenHashStringMap},
+ *     the full thread context data can be transferred with two array copies 
and five field updates.</li>
+ * </ul>
+ *
+ * @since 2.7
+ */
+public class OpenHashStringMap<K, V> implements StringMap, ThreadContextMap {
+    /** The initial default size of a hash table. */
+    public static final int DEFAULT_INITIAL_SIZE = 16;
+
+    /** The default load factor of a hash table. */
+    public static final float DEFAULT_LOAD_FACTOR = .75f;
+
+    private static final String FROZEN = "Frozen collection cannot be 
modified";
+    private static final long serialVersionUID = -1486744623338827187L;
+
+    /** The array of keys. */
+    protected transient K[] keys;
+    /** The array of values. */
+    protected transient V[] values;
+    /** The mask for wrapping a position counter. */
+    protected transient int mask;
+    /** Whether this set contains the key zero. */
+    protected transient boolean containsNullKey;
+    /** The current table size. */
+    protected transient int arraySize;
+    /**
+     * Threshold after which we rehash. It must be the table size times {@link 
#loadFactor}.
+     */
+    protected transient int maxFill;
+    /** Number of entries in the set (including the key zero, if present). */
+    protected int size;
+    /** The acceptable load factor. */
+    protected final float loadFactor;
+
+    private final V defRetValue = null;
+    private boolean immutable;
+    private transient boolean iterating;
+
+    /**
+     * Creates a new hash map with initial expected
+     * {@link #DEFAULT_INITIAL_SIZE} entries and
+     * {@link #DEFAULT_LOAD_FACTOR} as load factor.
+     */
+    public OpenHashStringMap() {
+        this(DEFAULT_INITIAL_SIZE, DEFAULT_LOAD_FACTOR);
+    }
+    /**
+     * Creates a new hash map with {@link #DEFAULT_LOAD_FACTOR} as load factor.
+     *
+     * @param expected
+     *            the expected number of elements in the hash map.
+     */
+    public OpenHashStringMap(final int expected) {
+        this(expected, DEFAULT_LOAD_FACTOR);
+    }
+    /**
+     * Creates a new hash map.
+     *
+     * <p>
+     * The actual table size will be the least power of two greater than
+     * <code>expected</code>/<code>f</code>.
+     *
+     * @param expected
+     *            the expected number of elements in the hash set.
+     * @param f
+     *            the load factor.
+     */
+    @SuppressWarnings("unchecked")
+    public OpenHashStringMap(final int expected, final float f) {
+        if (f <= 0 || f > 1) {
+            throw new IllegalArgumentException(
+                    "Load factor must be greater than 0 and smaller than or 
equal to 1");
+        }
+        if (expected < 0){
+            throw new IllegalArgumentException(
+                    "The expected number of elements must be nonnegative");
+        }
+        this.loadFactor = f;
+        arraySize = HashCommon.arraySize(expected, f);
+        mask = arraySize - 1;
+        maxFill = HashCommon.maxFill(arraySize, f);
+        keys = (K[]) new Object[arraySize + 1];
+        values = (V[]) new Object[arraySize + 1];
+    }
+    /**
+     * Creates a new hash map with {@link #DEFAULT_LOAD_FACTOR} as load
+     * factor copying a given one.
+     *
+     * @param map
+     *            a {@link Map} to be copied into the new hash map.
+     */
+    public OpenHashStringMap(final Map<? extends K, ? extends V> map) {
+        this(map, DEFAULT_LOAD_FACTOR);
+    }
+    /**
+     * Creates a new hash map copying a given one.
+     *
+     * @param map
+     *            a {@link Map} to be copied into the new hash map.
+     * @param f
+     *            the load factor.
+     */
+    public OpenHashStringMap(final Map<? extends K, ? extends V> map, final 
float f) {
+        this(map.size(), f);
+        putAll(map);
+    }
+
+    /**
+     * Creates a new hash map with {@link #DEFAULT_LOAD_FACTOR} as load
+     * factor copying a given type-specific one.
+     *
+     * @param contextData
+     *            a type-specific map to be copied into the new hash map.
+     */
+    public OpenHashStringMap(final ReadOnlyStringMap contextData) {
+        this(contextData, DEFAULT_LOAD_FACTOR);
+    }
+    /**
+     * Creates a new hash map copying a given type-specific one.
+     *
+     * @param contextData
+     *            a type-specific map to be copied into the new hash map.
+     * @param f
+     *            the load factor.
+     */
+    public OpenHashStringMap(final ReadOnlyStringMap contextData, final float 
f) {
+        this(contextData.size(), f);
+        if (contextData instanceof OpenHashStringMap) {
+            initFrom0((OpenHashStringMap) contextData);
+        } else {
+            contextData.forEach(PUT_ALL, this);
+        }
+    }
+    private static final TriConsumer<String, Object, StringMap> PUT_ALL =
+            new TriConsumer<String, Object, StringMap>() {
+        @Override
+        public void accept(final String key, final Object value, final 
StringMap contextData) {
+            contextData.putValue(key, value);
+        }
+    };
+
+    private void assertNotFrozen() {
+        if (immutable) {
+            throw new UnsupportedOperationException(FROZEN);
+        }
+    }
+
+    private void assertNoConcurrentModification() {
+        if (iterating) {
+            throw new ConcurrentModificationException();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void initFrom0(final OpenHashStringMap other) {
+        // this.loadFactor = other.loadFactor; // final field
+        this.arraySize = other.arraySize;
+        this.size = other.size;
+        this.containsNullKey = other.containsNullKey;
+        this.mask = other.mask;
+        this.maxFill = other.maxFill;
+        keys = (K[]) Arrays.copyOf(other.keys, arraySize + 1);
+        values = (V[]) Arrays.copyOf(other.values, arraySize + 1);
+    }
+
+    private int realSize() {
+        return containsNullKey ? size - 1 : size;
+    }
+
+    private void ensureCapacity(final int capacity) {
+        final int needed = HashCommon.arraySize(capacity, loadFactor);
+        if (needed > arraySize) {
+            rehash(needed);
+        }
+    }
+
+    private void tryCapacity(final long capacity) {
+        final int needed = Math.min(
+                1 << 30, Math.max(2, HashCommon.nextPowerOfTwo((int) 
Math.ceil(capacity / loadFactor))));
+        if (needed > arraySize) {
+            rehash(needed);
+        }
+    }
+
+    @Override
+    public Map<String, String> toMap() {
+        final Map<String, String> result = new HashMap<>(size);
+        forEach(COPY_INTO_MAP, result);
+        return result;
+    }
+
+    private static final TriConsumer<String, Object, Map<String, String>> 
COPY_INTO_MAP =
+            new TriConsumer<String, Object, Map<String, String>>() {
+        @Override
+        public void accept(final String k, final Object v, final Map<String, 
String> map) {
+            map.put(k, v == null ? null : v.toString());
+        }
+    };
+
+    /*
+     * Removes all elements from this map.
+     *
+     * <P>To increase object reuse, this method does not change the table size.
+     * If you want to reduce the table size, you must use {@link #trim()}.
+     */
+    @Override
+    public void clear() {
+        if (size == 0) {
+            return;
+        }
+        assertNotFrozen();
+        assertNoConcurrentModification();
+
+        size = 0;
+        containsNullKey = false;
+        Arrays.fill(keys, (null));
+        Arrays.fill(values, null);
+    }
+
+    @Override
+    public boolean containsKey(final String key) {
+        return containsObjectKey(key);
+    }
+
+    @SuppressWarnings("unchecked")
+    private boolean containsObjectKey(final Object k) {
+        if (k == null) {
+            return containsNullKey;
+        }
+        K curr;
+        final K[] key = this.keys;
+        int pos;
+        // The starting point.
+        if ((curr = key[pos = HashCommon.mix(k.hashCode()) & mask]) == null) {
+            return false;
+        }
+        if (k.equals(curr)) {
+            return true;
+        }
+        // There's always an unused entry.
+        while (true) {
+            if ((curr = key[pos = (pos + 1) & mask]) == null) {
+                return false;
+            }
+            if (k.equals(curr)) {
+                return true;
+            }
+        }
+    }
+
+    @Override
+       public boolean equals(final Object obj) {
+        if (obj == this) {
+            return true;
+        }
+        if (!(obj instanceof ReadOnlyStringMap)) {
+            return false;
+        }
+        final ReadOnlyStringMap other = (ReadOnlyStringMap) obj;
+        if (other.size() != size()) {
+            return false;
+        }
+        int pos = arraySize;
+        if (containsNullKey) {
+            if (!Objects.equals(getObjectValue(null), other.getValue(null))) {
+                return false;
+            }
+        }
+        --pos;
+        final K myKeys[] = this.keys;
+        for (; pos >= 0; pos--) {
+            K k;
+            if ((k = myKeys[pos]) != null) {
+                if (!Objects.equals(values[pos], other.getValue((String) k))) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <VAL> void forEach(final BiConsumer<String, ? super VAL> action) {
+        final int startSize = size;
+        final K myKeys[] = this.keys;
+        int pos = arraySize;
+
+        iterating = true;
+        try {
+            if (containsNullKey) {
+                action.accept((String) myKeys[pos], (VAL) values[pos]);
+                if (size != startSize) {
+                    throw new ConcurrentModificationException();
+                }
+            }
+            --pos;
+            for (; pos >= 0; pos--) {
+                if (myKeys[pos] != null) {
+                    action.accept((String) myKeys[pos], (VAL) values[pos]);
+                    if (size != startSize) {
+                        throw new ConcurrentModificationException();
+                    }
+                }
+            }
+        } finally {
+            iterating = false;
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <VAL, STATE> void forEach(final TriConsumer<String, ? super VAL, 
STATE> action, final STATE state) {
+        final int startSize = size;
+        final K myKeys[] = this.keys;
+        int pos = arraySize;
+
+        iterating = true;
+        try {
+            if (containsNullKey) {
+                action.accept((String) myKeys[pos], (VAL) values[pos], state);
+                if (size != startSize) {
+                    throw new ConcurrentModificationException();
+                }
+            }
+            --pos;
+            for (; pos >= 0; pos--) {
+                if (myKeys[pos] != null) {
+                    action.accept((String) myKeys[pos], (VAL) values[pos], 
state);
+                    if (size != startSize) {
+                        throw new ConcurrentModificationException();
+                    }
+                }
+            }
+        } finally {
+            iterating = false;
+        }
+    }
+
+    @Override
+    public String get(final String key) {
+        return (String) getObjectValue(key);
+    }
+
+    @SuppressWarnings("unchecked")
+    private V getObjectValue(final Object k) {
+        if (k == null) {
+            return containsNullKey ? values[arraySize] : defRetValue;
+        }
+        K curr;
+        final K[] key = this.keys;
+        int pos;
+        // The starting point.
+        if ((curr = key[pos = HashCommon.mix(k.hashCode()) & mask]) == null) {
+            return defRetValue;
+        }
+        if (k.equals(curr)) {
+            return values[pos];
+        }
+        // There's always an unused entry.
+        while (true) {
+            if (((curr = key[pos = (pos + 1) & mask]) == null)) {
+                return defRetValue;
+            }
+            if (k.equals(curr)) {
+                return values[pos];
+            }
+        }
+    }
+
+    @Override
+    public Map<String, String> getCopy() {
+        return toMap();
+    }
+
+    @Override
+    public Map<String, String> getImmutableMapOrNull() {
+        return isEmpty() ? null : Collections.unmodifiableMap(toMap());
+    }
+
+    @Override
+    public <VAL> VAL getValue(final String key) {
+        return (VAL) getObjectValue(key);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void put(final String key, final String value) {
+        putObjectValue((K) key, (V) value);
+    }
+
+    private int insert(final K k, final V v) {
+        int pos;
+        if (k == null) {
+            if (containsNullKey) {
+                return arraySize;
+            }
+            containsNullKey = true;
+            pos = arraySize;
+        } else {
+            K curr;
+            final K[] key = this.keys;
+            // The starting point.
+            if (!((curr = key[pos = HashCommon.mix(k.hashCode()) & mask]) == 
null)) {
+                if (curr.equals(k)) {
+                    return pos;
+                }
+                while (!((curr = key[pos = (pos + 1) & mask]) == null)) {
+                    if (curr.equals(k)) {
+                        return pos;
+                    }
+                }
+            }
+        }
+        keys[pos] = k;
+        values[pos] = v;
+        if (size++ >= maxFill) {
+            rehash(HashCommon.arraySize(size + 1, loadFactor));
+        }
+        return -1;
+    }
+
+    @Override
+    public void putAll(final ReadOnlyStringMap source) {
+        assertNotFrozen();
+        assertNoConcurrentModification();
+
+        if (size() == 0 && source instanceof OpenHashStringMap) {
+            initFrom0((OpenHashStringMap) source);
+        } else if (source != null) {
+            source.forEach(PUT_ALL, this);
+        }
+    }
+
+    /** {@inheritDoc} */
+    public void putAll(final Map<? extends K, ? extends V> map) {
+        if (loadFactor <= .5) {
+            // The resulting map will be sized for m.size() elements
+            ensureCapacity(map.size());
+        } else {
+            // The resulting map will be tentatively sized for size() +  
m.size() elements
+            tryCapacity(size() + map.size());
+        }
+        for (final Map.Entry<? extends K, ? extends V> entry : map.entrySet()) 
{
+            putObjectValue(entry.getKey(), entry.getValue());
+        }
+    }
+
+    private V putObjectValue(final K k, final V v) {
+        assertNotFrozen();
+        assertNoConcurrentModification();
+
+        final int pos = insert(k, v);
+        if (pos < 0) {
+            return defRetValue;
+        }
+        final V oldValue = values[pos];
+        values[pos] = v;
+        return oldValue;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void putValue(final String key, final Object value) {
+        putObjectValue((K) key, (V) value);
+    }
+
+    @Override
+    public void remove(final String key) {
+        removeObjectKey(key);
+    }
+
+    @Override
+    public void freeze() {
+        immutable = true;
+    }
+
+    @Override
+    public boolean isFrozen() {
+        return immutable;
+    }
+
+    @SuppressWarnings("unchecked")
+    private V removeObjectKey(final Object k) {
+        assertNotFrozen();
+        assertNoConcurrentModification();
+
+        if (k == null) {
+            if (containsNullKey) {
+                return removeNullEntry();
+            }
+            return defRetValue;
+        }
+        final K[] key = this.keys;
+        int pos = HashCommon.mix(k.hashCode()) & mask;
+        K curr = key[pos & mask];
+        // The starting point.
+        if (curr == null) {
+            return defRetValue;
+        }
+        if (k.equals(curr)) {
+            return removeEntry(pos);
+        }
+        while (true) {
+            if ((curr = key[pos = (pos + 1) & mask]) == null) {
+                return defRetValue;
+            }
+            if (k.equals(curr)) {
+                return removeEntry(pos);
+            }
+        }
+    }
+    private V removeEntry(final int pos) {
+        final V oldValue = values[pos];
+        values[pos] = null;
+        size--;
+        shiftKeys(pos);
+        if (size < maxFill / 4 && arraySize > DEFAULT_INITIAL_SIZE) {
+            rehash(arraySize / 2);
+        }
+        return oldValue;
+    }
+    private V removeNullEntry() {
+        containsNullKey = false;
+        keys[arraySize] = null;
+        final V oldValue = values[arraySize];
+        values[arraySize] = null;
+        size--;
+        if (size < maxFill / 4 && arraySize > DEFAULT_INITIAL_SIZE) {
+            rehash(arraySize / 2);
+        }
+        return oldValue;
+    }
+    /**
+     * Shifts left entries with the specified hash code, starting at the
+     * specified position, and empties the resulting free entry.
+     *
+     * @param pos
+     *            a starting position.
+     */
+    private void shiftKeys(int pos) {
+        // Shift entries with the same hash.
+        int last, slot;
+        K curr;
+        final K[] myKeys = this.keys;
+        for (;;) {
+            pos = ((last = pos) + 1) & mask;
+            for (;;) {
+                if (((curr = myKeys[pos]) == null)) {
+                    myKeys[last] = (null);
+                    values[last] = null;
+                    return;
+                }
+                slot = HashCommon.mix(curr.hashCode()) & mask;
+                if (last <= pos ? (last >= slot || slot > pos) : (last >= slot 
&& slot > pos)) {
+                    break;
+                }
+                pos = (pos + 1) & mask;
+            }
+            myKeys[last] = curr;
+            values[last] = values[pos];
+        }
+    }
+
+    @Override
+    public int size() {
+        return size;
+    }
+
+    /**
+     * Rehashes this map if the table is too large.
+     *
+     * <P>
+     * Let <var>N</var> be the smallest table size that can hold
+     * <code>max(n,{@link #size()})</code> entries, still satisfying the load
+     * factor. If the current table size is smaller than or equal to
+     * <var>N</var>, this method does nothing. Otherwise, it rehashes this map
+     * in a table of size <var>N</var>.
+     *
+     * <P>
+     * This method is useful when reusing maps. {@linkplain #clear() Clearing a
+     * map} leaves the table size untouched. If you are reusing a map many 
times,
+     * you can call this method with a typical size to avoid keeping around a
+     * very large table just because of a few large transient maps.
+     *
+     * @param n
+     *            the threshold for the trimming.
+     * @return true if there was enough memory to trim the map.
+     */
+    public boolean trim(final int n) {
+        final int l = HashCommon.nextPowerOfTwo((int) Math.ceil(n / 
loadFactor));
+        if (l >= n || size > HashCommon.maxFill(l, loadFactor)) {
+                       return true;
+               }
+        try {
+            rehash(l);
+        } catch (final OutOfMemoryError cantDoIt) { // unusual to catch OOME 
but in this case appropriate
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Rehashes the map.
+     *
+     * <P>
+     * This method implements the basic rehashing strategy, and may be 
overriden
+     * by subclasses implementing different rehashing strategies (e.g.,
+     * disk-based rehashing). However, you should not override this method
+     * unless you understand the internal workings of this class.
+     *
+     * @param newN
+     *            the new size
+     */
+    @SuppressWarnings("unchecked")
+    protected void rehash(final int newN) {
+        final K myKeys[] = this.keys;
+        final V myValues[] = this.values;
+        final int mask = newN - 1; // Note that this is used by the hashing
+        // macro
+        final K newKey[] = (K[]) new Object[newN + 1];
+        final V newValue[] = (V[]) new Object[newN + 1];
+        int i = arraySize, pos;
+        for (int j = realSize(); j-- != 0;) {
+            while (myKeys[--i] == null) {
+                // advance i until we find an existing key
+            }
+            if (newKey[pos = HashCommon.mix(myKeys[i].hashCode()) & mask] != 
null) { // rehash & check slot availability
+                while (newKey[pos = (pos + 1) & mask] != null) {
+                    // find available slot at (or immediately following) pos
+                }
+            }
+            newKey[pos] = myKeys[i];
+            newValue[pos] = myValues[i];
+        }
+        newValue[newN] = myValues[arraySize];
+        arraySize = newN;
+        this.mask = mask;
+        maxFill = HashCommon.maxFill(arraySize, loadFactor);
+        this.keys = newKey;
+        this.values = newValue;
+    }
+
+    /**
+     * Returns a hash code for this map.
+     *
+     * @return a hash code for this map.
+     */
+    @Override
+       public int hashCode() {
+        int result = 0;
+        for (int j = realSize(), i = 0, t = 0; j-- != 0;) {
+            while (keys[i] == null) {
+                i++;
+            }
+            if (this != keys[i]) {
+                t = keys[i].hashCode();
+            }
+            if (this != values[i]) {
+                t ^= (values[i] == null ? 0 : values[i].hashCode());
+            }
+            result += t;
+            i++;
+        }
+        // Zero / null keys have hash zero.
+        if (containsNullKey) {
+            result += (values[arraySize] == null ? 0 : 
values[arraySize].hashCode());
+        }
+        return result;
+    }
+
+    @SuppressWarnings("unchecked")
+    private void readObject(final ObjectInputStream s) throws IOException, 
ClassNotFoundException {
+        s.defaultReadObject();
+        arraySize = HashCommon.arraySize(size, loadFactor);
+        maxFill = HashCommon.maxFill(arraySize, loadFactor);
+        mask = arraySize - 1;
+        final K key[] = this.keys = (K[]) new Object[arraySize + 1];
+        final V value[] = this.values = (V[]) new Object[arraySize + 1];
+        K k;
+        V v;
+        for (int i = size, pos; i-- != 0;) {
+            k = (K) s.readObject();
+            v = (V) s.readObject();
+            if (k == null) {
+                pos = arraySize;
+                containsNullKey = true;
+            } else {
+                pos = HashCommon.mix(k.hashCode()) & mask;
+                while (key[pos] != null) {
+                    pos = (pos + 1) & mask;
+                }
+            }
+            key[pos] = k;
+            value[pos] = v;
+        }
+    }
+
+    private void writeObject(final ObjectOutputStream s) throws IOException {
+        s.defaultWriteObject();
+        try {
+            forEach(SERIALIZER, s);
+        } catch (final RuntimeException runex) {
+            if (runex.getCause() instanceof IOException) {
+                throw (IOException) runex.getCause();
+            }
+            throw runex;
+        }
+    }
+
+    private static final TriConsumer<String, Object, ObjectOutputStream> 
SERIALIZER =
+            new TriConsumer<String, Object, ObjectOutputStream>() {
+                @Override
+                public void accept(final String k, final Object v, final 
ObjectOutputStream objectOutputStream) {
+                    try {
+                        objectOutputStream.writeObject(k);
+                        objectOutputStream.writeObject(v);
+                    } catch (final IOException ioex) {
+                        throw new IllegalStateException(ioex);
+                    }
+                }
+            };
+
+    @Override
+    public String toString() {
+        final StringBuilder sb = new StringBuilder(256);
+        sb.append('{');
+        final K myKeys[] = this.keys;
+        int pos = arraySize;
+        boolean first = true;
+        if (containsNullKey) {
+            sb.append(myKeys[pos] == this ? "(this map)" : myKeys[pos]);
+            sb.append('=');
+            sb.append(values[pos] == this ? "(this map)" : values[pos]);
+            first = false;
+        }
+        --pos;
+        for (; pos >= 0; pos--) {
+            if (myKeys[pos] != null) {
+                if (first) {
+                    first = false;
+                } else {
+                    sb.append(", ");
+                }
+                sb.append(myKeys[pos] == this ? "(this map)" : myKeys[pos]);
+                sb.append('=');
+                sb.append(values[pos] == this ? "(this map)" : values[pos]);
+            }
+        }
+        sb.append('}');
+        return sb.toString();
+    }
+
+    private static class HashCommon {
+        private HashCommon() {}
+
+        /** 2<sup>32</sup> &middot; &phi;, &phi; = (&#x221A;5 &minus; 1)/2. */
+        private static final int INT_PHI = 0x9E3779B9;
+
+        /** The reciprocal of {@link #INT_PHI} modulo 2<sup>32</sup>. */
+        private static final int INV_INT_PHI = 0x144cbc89;
+
+        /** Avalanches the bits of an integer by applying the finalisation 
step of MurmurHash3.
+         *
+         * <p>This method implements the finalisation step of Austin Appleby's
+         * <a href="http://code.google.com/p/smhasher/";>MurmurHash3</a>.
+         * Its purpose is to avalanche the bits of the argument to within 
0.25% bias.
+         *
+         * @param x an integer.
+         * @return a hash value with good avalanching properties.
+         */
+        public static int murmurHash3(int x) {
+            x ^= x >>> 16;
+            x *= 0x85ebca6b;
+            x ^= x >>> 13;
+            x *= 0xc2b2ae35;
+            x ^= x >>> 16;
+            return x;
+        }
+
+        /**
+         * Quickly mixes the bits of an integer.
+         *
+         * <p>This method mixes the bits of the argument by multiplying by the 
golden ratio and
+         * xorshifting the result. It is borrowed from <a 
href="https://github.com/OpenHFT/Koloboke";>Koloboke</a>, and
+         * it has slightly worse behaviour than {@link #murmurHash3(int)} (in 
open-addressing hash tables the average
+         * number of probes is slightly larger), but it's much faster.
+         *
+         * @param x an integer.
+         * @return a hash value obtained by mixing the bits of {@code x}.
+         * @see #invMix(int)
+         */
+        public static int mix(final int x) {
+            final int h = x * INT_PHI;
+            return h ^ (h >>> 16);
+        }
+
+        /** The inverse of {@link #mix(int)}. This method is mainly useful to 
create unit tests.
+         *
+         * @param x an integer.
+         * @return a value that passed through {@link #mix(int)} would give 
{@code x}.
+         */
+        public static int invMix(final int x) {
+            return (x ^ x >>> 16) * INV_INT_PHI;
+        }
+
+        /** Return the least power of two greater than or equal to the 
specified value.
+         *
+         * <p>Note that this function will return 1 when the argument is 0.
+         *
+         * @param x an integer smaller than or equal to 2<sup>30</sup>.
+         * @return the least power of two greater than or equal to the 
specified value.
+         */
+        public static int nextPowerOfTwo(int x) {
+            if (x == 0) {
+                return 1;
+            }
+            x--;
+            x |= x >> 1;
+            x |= x >> 2;
+            x |= x >> 4;
+            x |= x >> 8;
+            return (x | x >> 16) + 1;
+        }
+
+        /** Return the least power of two greater than or equal to the 
specified value.
+         *
+         * <p>Note that this function will return 1 when the argument is 0.
+         *
+         * @param x a long integer smaller than or equal to 2<sup>62</sup>.
+         * @return the least power of two greater than or equal to the 
specified value.
+         */
+        public static long nextPowerOfTwo(long x) {
+            if (x == 0) {
+                return 1;
+            }
+            x--;
+            x |= x >> 1;
+            x |= x >> 2;
+            x |= x >> 4;
+            x |= x >> 8;
+            x |= x >> 16;
+            return (x | x >> 32) + 1;
+        }
+
+
+        /** Returns the maximum number of entries that can be filled before 
rehashing.
+         *
+         * @param n the size of the backing array.
+         * @param f the load factor.
+         * @return the maximum number of entries before rehashing.
+         */
+        public static int maxFill(final int n, final float f) {
+               /* We must guarantee that there is always at least
+                * one free entry (even with pathological load factors). */
+            return Math.min((int) Math.ceil(n * f), n - 1);
+        }
+
+        /**
+         * Returns the least power of two smaller than or equal to 
2<sup>30</sup> and larger than or equal to
+         * <code>Math.ceil( expected / f )</code>.
+         *
+         * @param expected the expected number of elements in a hash table.
+         * @param f the load factor.
+         * @return the minimum possible size for a backing array.
+         * @throws IllegalArgumentException if the necessary size is larger 
than 2<sup>30</sup>.
+         */
+        public static int arraySize(final int expected, final float f) {
+            final long result = Math.max(2, nextPowerOfTwo((long) 
Math.ceil(expected / f)));
+            if (result > (1 << 30)) {
+                throw new IllegalArgumentException("Too large (" + expected +
+                        " expected elements with load factor " + f + ")");
+            }
+            return (int) result;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/895d8697/log4j-perf/src/main/java/org/apache/logging/log4j/spi/CopyOnWriteOpenHashMapThreadContextMap.java
----------------------------------------------------------------------
diff --git 
a/log4j-perf/src/main/java/org/apache/logging/log4j/spi/CopyOnWriteOpenHashMapThreadContextMap.java
 
b/log4j-perf/src/main/java/org/apache/logging/log4j/spi/CopyOnWriteOpenHashMapThreadContextMap.java
index a0c6975..c1ace7a 100644
--- 
a/log4j-perf/src/main/java/org/apache/logging/log4j/spi/CopyOnWriteOpenHashMapThreadContextMap.java
+++ 
b/log4j-perf/src/main/java/org/apache/logging/log4j/spi/CopyOnWriteOpenHashMapThreadContextMap.java
@@ -16,13 +16,13 @@
  */
 package org.apache.logging.log4j.spi;
 
-import org.apache.logging.log4j.perf.nogc.OpenHashMapContextData;
+import org.apache.logging.log4j.perf.nogc.OpenHashStringMap;
 import org.apache.logging.log4j.util.ReadOnlyStringMap;
 import org.apache.logging.log4j.util.StringMap;
 import org.apache.logging.log4j.util.PropertiesUtil;
 
 /**
- * {@code OpenHashMapContextData}-based implementation of the {@code 
ThreadContextMap} interface that creates a copy of
+ * {@code OpenHashStringMap}-based implementation of the {@code 
ThreadContextMap} interface that creates a copy of
  * the data structure on every modification. Any particular instance of the 
data structure is a snapshot of the
  * ThreadContext at some point in time and can safely be passed off to other 
threads
  *
@@ -35,12 +35,12 @@ public class CopyOnWriteOpenHashMapThreadContextMap extends 
CopyOnWriteSortedArr
 
     @Override
     protected StringMap createStringMap() {
-        return new 
OpenHashMapContextData<>(PropertiesUtil.getProperties().getIntegerProperty(
+        return new 
OpenHashStringMap<>(PropertiesUtil.getProperties().getIntegerProperty(
                 PROPERTY_NAME_INITIAL_CAPACITY, DEFAULT_INITIAL_CAPACITY));
     }
 
     @Override
     protected StringMap createStringMap(final ReadOnlyStringMap original) {
-        return new OpenHashMapContextData<>(original);
+        return new OpenHashStringMap<>(original);
     }
 }

http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/895d8697/log4j-perf/src/main/java/org/apache/logging/log4j/spi/GarbageFreeOpenHashMapThreadContextMap.java
----------------------------------------------------------------------
diff --git 
a/log4j-perf/src/main/java/org/apache/logging/log4j/spi/GarbageFreeOpenHashMapThreadContextMap.java
 
b/log4j-perf/src/main/java/org/apache/logging/log4j/spi/GarbageFreeOpenHashMapThreadContextMap.java
index b3ccf64..80b658f 100644
--- 
a/log4j-perf/src/main/java/org/apache/logging/log4j/spi/GarbageFreeOpenHashMapThreadContextMap.java
+++ 
b/log4j-perf/src/main/java/org/apache/logging/log4j/spi/GarbageFreeOpenHashMapThreadContextMap.java
@@ -16,13 +16,13 @@
  */
 package org.apache.logging.log4j.spi;
 
-import org.apache.logging.log4j.perf.nogc.OpenHashMapContextData;
+import org.apache.logging.log4j.perf.nogc.OpenHashStringMap;
 import org.apache.logging.log4j.util.ReadOnlyStringMap;
 import org.apache.logging.log4j.util.StringMap;
 import org.apache.logging.log4j.util.PropertiesUtil;
 
 /**
- * {@code OpenHashMapContextData}-based implementation of the {@code 
ThreadContextMap} interface that attempts not to
+ * {@code OpenHashStringMap}-based implementation of the {@code 
ThreadContextMap} interface that attempts not to
  * create temporary objects. Adding and removing key-value pairs will not 
create temporary objects.
  * <p>
  * Since the underlying data structure is modified directly it is not suitable 
for passing by reference to other
@@ -38,12 +38,12 @@ public class GarbageFreeOpenHashMapThreadContextMap extends 
GarbageFreeSortedArr
 
     @Override
     protected StringMap createStringMap() {
-        return new 
OpenHashMapContextData<>(PropertiesUtil.getProperties().getIntegerProperty(
+        return new 
OpenHashStringMap<>(PropertiesUtil.getProperties().getIntegerProperty(
                 PROPERTY_NAME_INITIAL_CAPACITY, DEFAULT_INITIAL_CAPACITY));
     }
 
     @Override
     protected StringMap createStringMap(final ReadOnlyStringMap original) {
-        return new OpenHashMapContextData<>(original);
+        return new OpenHashStringMap<>(original);
     }
 }

Reply via email to