| /* |
| * Copyright 2009 Goldman Sachs International. All Rights Reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| |
| /* |
| * @test |
| * @bug 6865031 |
| * @summary Application gives bad result (throws bad exception) with compressed oops |
| * |
| * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:+UseCompressedOops |
| * -XX:HeapBaseMinAddress=32g -XX:-LoopUnswitching |
| * -XX:CompileCommand=inline,compiler.c2.cr6865031.AbstractMemoryEfficientList::equals |
| * compiler.c2.cr6865031.Test hello goodbye |
| */ |
| |
| package compiler.c2.cr6865031; |
| |
| import java.lang.ref.ReferenceQueue; |
| import java.lang.ref.WeakReference; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| interface MyList { |
| public int size(); |
| public Object set(final int index, final Object element); |
| public Object get(final int index); |
| } |
| |
| abstract class AbstractMemoryEfficientList implements MyList { |
| abstract public int size(); |
| abstract public Object get(final int index); |
| abstract public Object set(final int index, final Object element); |
| |
| public boolean equals(Object o) { |
| if (o == this) { |
| return true; |
| } |
| |
| if (!(o instanceof MyList)) { |
| return false; |
| } |
| |
| final MyList that = (MyList) o; |
| if (this.size() != that.size()) { |
| return false; |
| } |
| |
| for (int i = 0; i < this.size(); i++) { |
| try { |
| if (!((this.get(i)).equals(that.get(i)))) { |
| return false; |
| } |
| } catch (IndexOutOfBoundsException e) { |
| System.out.println("THROWING RT EXC"); |
| System.out.println("concurrent modification of this:" + this.getClass() + ":" + System.identityHashCode(this) + "; that:" + that.getClass() + ":" + System.identityHashCode(that) + "; i:" + i); |
| e.printStackTrace(); |
| System.exit(97); |
| throw new RuntimeException("concurrent modification of this:" + this.getClass() + ":" + System.identityHashCode(this) + "; that:" + that.getClass() + ":" + System.identityHashCode(that) + "; i:" + i, e); |
| } |
| } |
| return true; |
| } |
| |
| public int hashCode() { |
| int hashCode = 1; |
| for (int i = 0; i < this.size(); i++) { |
| Object obj = this.get(i); |
| hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode()); |
| } |
| return hashCode; |
| } |
| } |
| |
| final class SingletonList extends AbstractMemoryEfficientList { |
| private Object element1; |
| |
| SingletonList(final Object obj1) { |
| super(); |
| this.element1 = obj1; |
| } |
| |
| public int size() { |
| return 1; |
| } |
| |
| public Object get(final int index) { |
| if (index == 0) { |
| return this.element1; |
| } else { |
| throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + this.size()); |
| } |
| } |
| |
| public Object set(final int index, final Object element) { |
| if (index == 0) { |
| final Object previousElement = this.element1; |
| this.element1 = element; |
| return previousElement; |
| } else { |
| throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + this.size()); |
| } |
| } |
| } |
| |
| final class DoubletonList extends AbstractMemoryEfficientList { |
| private Object element1; |
| private Object element2; |
| |
| DoubletonList(final Object obj1, final Object obj2) { |
| this.element1 = obj1; |
| this.element2 = obj2; |
| } |
| |
| public int size() { |
| return 2; |
| } |
| |
| public Object get(final int index) { |
| switch (index) { |
| case 0 : return this.element1; |
| case 1 : return this.element2; |
| default: throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + this.size()); |
| } |
| } |
| |
| public Object set(final int index, final Object element) { |
| switch (index) { |
| case 0 : |
| { |
| final Object previousElement = this.element1; |
| this.element1 = element; |
| return previousElement; |
| } |
| case 1 : |
| { |
| final Object previousElement = this.element2; |
| this.element2 = element; |
| return previousElement; |
| } |
| default : throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + this.size()); |
| } |
| } |
| } |
| |
| class WeakPool<V> { |
| protected static final int DEFAULT_INITIAL_CAPACITY = 16; |
| private static final int MAXIMUM_CAPACITY = 1 << 30; |
| private static final float DEFAULT_LOAD_FACTOR = 0.75f; |
| |
| protected Entry<V>[] table; |
| |
| private int size; |
| protected int threshold; |
| private final float loadFactor; |
| private final ReferenceQueue<V> queue = new ReferenceQueue<V>(); |
| |
| public WeakPool() |
| { |
| this.loadFactor = DEFAULT_LOAD_FACTOR; |
| threshold = DEFAULT_INITIAL_CAPACITY; |
| table = new Entry[DEFAULT_INITIAL_CAPACITY]; |
| } |
| |
| /** |
| * Check for equality of non-null reference x and possibly-null y. By |
| * default uses Object.equals. |
| */ |
| private boolean eq(Object x, Object y) |
| { |
| return x == y || x.equals(y); |
| } |
| |
| /** |
| * Return index for hash code h. |
| */ |
| private int indexFor(int h, int length) |
| { |
| return h & length - 1; |
| } |
| |
| /** |
| * Expunge stale entries from the table. |
| */ |
| private void expungeStaleEntries() |
| { |
| Object r; |
| while ((r = queue.poll()) != null) |
| { |
| Entry e = (Entry) r; |
| int h = e.hash; |
| int i = indexFor(h, table.length); |
| |
| // System.out.println("EXPUNGING " + h); |
| Entry<V> prev = table[i]; |
| Entry<V> p = prev; |
| while (p != null) |
| { |
| Entry<V> next = p.next; |
| if (p == e) |
| { |
| if (prev == e) |
| { |
| table[i] = next; |
| } |
| else |
| { |
| prev.next = next; |
| } |
| e.next = null; // Help GC |
| size--; |
| break; |
| } |
| prev = p; |
| p = next; |
| } |
| } |
| } |
| |
| /** |
| * Return the table after first expunging stale entries |
| */ |
| private Entry<V>[] getTable() |
| { |
| expungeStaleEntries(); |
| return table; |
| } |
| |
| /** |
| * Returns the number of key-value mappings in this map. |
| * This result is a snapshot, and may not reflect unprocessed |
| * entries that will be removed before next attempted access |
| * because they are no longer referenced. |
| */ |
| public int size() |
| { |
| if (size == 0) |
| { |
| return 0; |
| } |
| expungeStaleEntries(); |
| return size; |
| } |
| |
| /** |
| * Returns <tt>true</tt> if this map contains no key-value mappings. |
| * This result is a snapshot, and may not reflect unprocessed |
| * entries that will be removed before next attempted access |
| * because they are no longer referenced. |
| */ |
| public boolean isEmpty() |
| { |
| return size() == 0; |
| } |
| |
| /** |
| * Returns the value stored in the pool that equals the requested key |
| * or <tt>null</tt> if the map contains no mapping for |
| * this key (or the key is null) |
| * |
| * @param key the key whose equals value is to be returned. |
| * @return the object that is equal the specified key, or |
| * <tt>null</tt> if key is null or no object in the pool equals the key. |
| */ |
| public V get(V key) |
| { |
| if (key == null) |
| { |
| return null; |
| } |
| int h = key.hashCode(); |
| Entry<V>[] tab = getTable(); |
| int index = indexFor(h, tab.length); |
| Entry<V> e = tab[index]; |
| while (e != null) |
| { |
| V candidate = e.get(); |
| if (e.hash == h && eq(key, candidate)) |
| { |
| return candidate; |
| } |
| e = e.next; |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the entry associated with the specified key in the HashMap. |
| * Returns null if the HashMap contains no mapping for this key. |
| */ |
| Entry getEntry(Object key) |
| { |
| int h = key.hashCode(); |
| Entry[] tab = getTable(); |
| int index = indexFor(h, tab.length); |
| Entry e = tab[index]; |
| while (e != null && !(e.hash == h && eq(key, e.get()))) |
| { |
| e = e.next; |
| } |
| return e; |
| } |
| |
| /** |
| * Places the object into the pool. If the object is null, nothing happens. |
| * If an equal object already exists, it is not replaced. |
| * |
| * @param key the object to put into the pool. key may be null. |
| * @return the object in the pool that is equal to the key, or the newly placed key if no such object existed when put was called |
| */ |
| public V put(V key) |
| { |
| if (key == null) |
| { |
| return null; |
| } |
| int h = key.hashCode(); |
| Entry<V>[] tab = getTable(); |
| int i = indexFor(h, tab.length); |
| |
| for (Entry<V> e = tab[i]; e != null; e = e.next) |
| { |
| V candidate = e.get(); |
| if (h == e.hash && eq(key, candidate)) |
| { |
| return candidate; |
| } |
| } |
| |
| tab[i] = new Entry<V>(key, queue, h, tab[i]); |
| |
| if (++size >= threshold) |
| { |
| resize(tab.length * 2); |
| } |
| |
| // System.out.println("Added " + key + " to pool"); |
| return key; |
| } |
| |
| /** |
| * Rehashes the contents of this map into a new array with a |
| * larger capacity. This method is called automatically when the |
| * number of keys in this map reaches its threshold. |
| * <p/> |
| * If current capacity is MAXIMUM_CAPACITY, this method does not |
| * resize the map, but but sets threshold to Integer.MAX_VALUE. |
| * This has the effect of preventing future calls. |
| * |
| * @param newCapacity the new capacity, MUST be a power of two; |
| * must be greater than current capacity unless current |
| * capacity is MAXIMUM_CAPACITY (in which case value |
| * is irrelevant). |
| */ |
| void resize(int newCapacity) |
| { |
| Entry<V>[] oldTable = getTable(); |
| int oldCapacity = oldTable.length; |
| if (oldCapacity == MAXIMUM_CAPACITY) |
| { |
| threshold = Integer.MAX_VALUE; |
| return; |
| } |
| |
| Entry<V>[] newTable = new Entry[newCapacity]; |
| transfer(oldTable, newTable); |
| table = newTable; |
| |
| /* |
| * If ignoring null elements and processing ref queue caused massive |
| * shrinkage, then restore old table. This should be rare, but avoids |
| * unbounded expansion of garbage-filled tables. |
| */ |
| if (size >= threshold / 2) |
| { |
| threshold = (int) (newCapacity * loadFactor); |
| } |
| else |
| { |
| expungeStaleEntries(); |
| transfer(newTable, oldTable); |
| table = oldTable; |
| } |
| } |
| |
| /** |
| * Transfer all entries from src to dest tables |
| */ |
| private void transfer(Entry[] src, Entry[] dest) |
| { |
| for (int j = 0; j < src.length; ++j) |
| { |
| Entry e = src[j]; |
| src[j] = null; |
| while (e != null) |
| { |
| Entry next = e.next; |
| Object key = e.get(); |
| if (key == null) |
| { |
| e.next = null; // Help GC |
| size--; |
| } |
| else |
| { |
| int i = indexFor(e.hash, dest.length); |
| e.next = dest[i]; |
| dest[i] = e; |
| } |
| e = next; |
| } |
| } |
| } |
| |
| /** |
| * Removes the object in the pool that equals the key. |
| * |
| * @param key |
| * @return previous value associated with specified key, or <tt>null</tt> |
| * if there was no mapping for key or the key is null. |
| */ |
| public V removeFromPool(V key) |
| { |
| if (key == null) |
| { |
| return null; |
| } |
| int h = key.hashCode(); |
| Entry<V>[] tab = getTable(); |
| int i = indexFor(h, tab.length); |
| Entry<V> prev = tab[i]; |
| Entry<V> e = prev; |
| |
| while (e != null) |
| { |
| Entry<V> next = e.next; |
| V candidate = e.get(); |
| if (h == e.hash && eq(key, candidate)) |
| { |
| size--; |
| if (prev == e) |
| { |
| tab[i] = next; |
| } |
| else |
| { |
| prev.next = next; |
| } |
| return candidate; |
| } |
| prev = e; |
| e = next; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Removes all mappings from this map. |
| */ |
| public void clear() |
| { |
| // clear out ref queue. We don't need to expunge entries |
| // since table is getting cleared. |
| while (queue.poll() != null) |
| { |
| // nop |
| } |
| |
| table = new Entry[DEFAULT_INITIAL_CAPACITY]; |
| threshold = DEFAULT_INITIAL_CAPACITY; |
| size = 0; |
| |
| // Allocation of array may have caused GC, which may have caused |
| // additional entries to go stale. Removing these entries from the |
| // reference queue will make them eligible for reclamation. |
| while (queue.poll() != null) |
| { |
| // nop |
| } |
| } |
| |
| /** |
| * The entries in this hash table extend WeakReference, using its main ref |
| * field as the key. |
| */ |
| protected static class Entry<V> |
| extends WeakReference<V> |
| { |
| private final int hash; |
| private Entry<V> next; |
| |
| /** |
| * Create new entry. |
| */ |
| Entry(final V key, final ReferenceQueue<V> queue, final int hash, final Entry<V> next) |
| { |
| super(key, queue); |
| this.hash = hash; |
| this.next = next; |
| } |
| |
| public V getKey() |
| { |
| return super.get(); |
| } |
| |
| public boolean equals(Object o) |
| { |
| if (!(o instanceof WeakPool.Entry)) |
| { |
| return false; |
| } |
| WeakPool.Entry<V> that = (WeakPool.Entry<V>) o; |
| V k1 = this.getKey(); |
| V k2 = that.getKey(); |
| return (k1==k2 || k1.equals(k2)); |
| } |
| |
| public int hashCode() |
| { |
| return this.hash; |
| } |
| |
| public String toString() |
| { |
| return String.valueOf(this.getKey()); |
| } |
| } |
| } |
| |
| final class MultiSynonymKey { |
| private List<MyList> keys; |
| |
| public MultiSynonymKey() { |
| keys = new ArrayList<MyList>(); |
| } |
| |
| public MultiSynonymKey(MyList... arg) { |
| keys = Arrays.asList(arg); |
| } |
| |
| public List<MyList> getKeys() { |
| return keys; |
| } |
| |
| public int hashCode() { |
| return this.getKeys().hashCode(); |
| } |
| |
| public boolean equals(Object obj) { |
| if (this == obj) { |
| return true; |
| } |
| |
| if (!(obj instanceof MultiSynonymKey)) { |
| return false; |
| } |
| |
| MultiSynonymKey that = (MultiSynonymKey) obj; |
| return this.getKeys().equals(that.getKeys()); |
| } |
| |
| public String toString() { |
| return this.getClass().getName() + this.getKeys().toString(); |
| } |
| } |
| |
| public class Test extends Thread { |
| static public Test test; |
| static private byte[] arg1; |
| static private byte[] arg2; |
| static public WeakPool<MultiSynonymKey> wp; |
| public volatile MultiSynonymKey ml1; |
| public volatile MultiSynonymKey ml2; |
| private volatile MultiSynonymKey ml3; |
| |
| public void run() { |
| int count=0; |
| while (true) { |
| try { |
| Thread.sleep(10); |
| } catch (Exception e) {} |
| synchronized (wp) { |
| ml2 = new MultiSynonymKey(new DoubletonList(new String(arg1), new String(arg2))); |
| wp.put(ml2); |
| ml3 = new MultiSynonymKey(new DoubletonList(new String(arg1), new String(arg2))); |
| } |
| try { |
| Thread.sleep(10); |
| } catch (Exception e) {} |
| synchronized (wp) { |
| ml1 = new MultiSynonymKey(new SingletonList(new String(arg1))); |
| wp.put(ml1); |
| ml3 = new MultiSynonymKey(new SingletonList(new String(arg1))); |
| } |
| if (count++==100) |
| System.exit(95); |
| } |
| } |
| |
| public static void main(String[] args) throws Exception { |
| wp = new WeakPool<MultiSynonymKey>(); |
| test = new Test(); |
| |
| test.arg1 = args[0].getBytes(); |
| test.arg2 = args[1].getBytes(); |
| |
| test.ml1 = new MultiSynonymKey(new SingletonList(new String(test.arg1))); |
| test.ml2 = new MultiSynonymKey(new DoubletonList(new String(test.arg1), new String(test.arg2))); |
| test.ml3 = new MultiSynonymKey(new DoubletonList(new String(test.arg1), new String(test.arg2))); |
| |
| wp.put(test.ml1); |
| wp.put(test.ml2); |
| |
| test.setDaemon(true); |
| test.start(); |
| |
| int counter = 0; |
| while (true) { |
| synchronized (wp) { |
| MultiSynonymKey foo = test.ml3; |
| |
| if (wp.put(foo) == foo) { |
| // System.out.println("foo " + counter); |
| // System.out.println(foo); |
| } |
| } |
| counter++; |
| } |
| } |
| |
| private boolean eq(Object x, Object y) { |
| return x == y || x.equals(y); |
| } |
| } |