February 2018 - core-libs-dev

Fw: [PATCH] ObjectInputStream Reading Performance Optimisation
by Ben Walsh 20 Feb '18

20 Feb '18

Still looking for a sponsor for this please ... Thanks, Ben Walsh ----- Forwarded by Ben Walsh/UK/IBM on 20/02/2018 14:04 ----- From: Ben Walsh/UK/IBM To: core-libs-dev <core-libs-dev(a)openjdk.java.net> Date: 07/02/2018 14:18 Subject: [PATCH] ObjectInputStream Reading Performance Optimisation As per the guidance here - http://mail.openjdk.java.net/pipermail/valhalla-dev/2018-February/003772.ht… , I am resubmitting this patch to this mailing list ... The main advantage of this optimisation is that a suitably "aware" compiler can avoid stack walking by using a private method named redirectedReadObject that can be called from a call site that was calling readObject originally (in some cases). The conditions when this can be done are essentially when we know that the caller method's class is a "user defined class" because we have that caller method/class at compile time and can check if it was loaded by a user defined class loader. If so, the compiler emits code to call the private redirectedReadObject method (instead of readObject that was there in the byte codes) and it avoids doing a stack walk to discover the latest user class loader because it has an extra parameter that is a class loader that can be passed in, in cases when the compiler knows the answer at compile time. In such cases, the compiler generates code to pass in the latest user defined class loader known to redirectedReadObject. I would like to pair with a sponsor to contribute this patch ... ----------------------------------------------------------------------------------------------------------------------- diff -r 60c19c384333 src/java.base/share/classes/java/io/ClassCache.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/java.base/share/classes/java/io/ClassCache.java Fri Feb 02 11:52:41 2018 +0000 @@ -0,0 +1,403 @@ +/* + * Copyright (c) 2018, Oracle and/or its affiliates. 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. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the LICENSE file that accompanied this code. + * + * 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. + */ + +package java.io; + +import java.lang.ref.ReferenceQueue; +import java.lang.ref.WeakReference; +import java.security.AccessController; +import java.security.PrivilegedAction; +import java.util.Objects; +import java.util.concurrent.ConcurrentHashMap; +/* ClassCache is Primarily responsible for Caching the results of the className lookups and hence to avoid + * multiple Lookup for same Class Instance. + * ClassCache provides a ConcurrentHash based ClassCache which is looked up prior to calling the class.forName + * Method resolveClass() from ObjectInputStream uses this Cache. + * + * Caching is done only when the actually used loader for a Class is one of the Sytem loaders (ie) App Class Loader, + * System Extension loader and BootStrap loader + * + */ +final class ClassCache { +/* Main Cache for storing the Class.forName results Here Key used would be CacheKey */ + private final ConcurrentHashMap<Key,Object> cache = + new ConcurrentHashMap<Key,Object>(); +/* Initiating Loader to CacheKey mapping in the Cache used by Reaper thread for removal on stale Loaders */ + private final ConcurrentHashMap<LoaderRef,CacheKey> loaderKeys = + new ConcurrentHashMap<LoaderRef,CacheKey>(); + /* Keeps a link of Actual System Loader used to Initiating Loader mapping */ + private final ConcurrentHashMap<LoaderRef,LoaderRef> canonicalLoaderRefs = + new ConcurrentHashMap<LoaderRef,LoaderRef>(); + /* Reference Queue registered for notification on stale Loaders */ + private final ReferenceQueue<Object> staleLoaderRefs = + new ReferenceQueue<Object>(); +/* + * Constructor Populates Canonical Loader Refs with System Loader Entries and initializes the reaper thread which + * monitors the ReferenceQueue for stale loaders + */ + + public ClassCache() { + ClassLoader loader = ClassLoader.getSystemClassLoader(); + while (loader != null) { + setCanonicalSystemLoaderRef(loader); + loader = loader.getParent(); + } + setCanonicalSystemLoaderRef(null); + AccessController.doPrivileged( + new CreateReaperAction(this, staleLoaderRefs)).start(); + } + /* + * sets Canonical Loader reference for the loader + */ + + private void setCanonicalSystemLoaderRef(ClassLoader loader) { + LoaderRef newKey = new LoaderRef(loader, staleLoaderRefs, true); + assert (canonicalLoaderRefs.put(newKey, newKey) == null); + } + + /* + * get Canonical Loader reference for the loader + */ + + + LoaderRef getCanonicalLoaderRef(Object loaderObj) { + LoaderRef newKey = new LoaderRef(loaderObj, staleLoaderRefs); + + LoaderRef key = canonicalLoaderRefs.get(newKey); + if (key == null) { + key = canonicalLoaderRefs.putIfAbsent(newKey, newKey); + if (key == null) { + return newKey; + } + } + + newKey.clear(); + return key; + } +/* + * Remove unused LoaderKey, and initiates corresponding CacheKey entry the main Cache + */ + void removeStaleRef(LoaderRef loaderRef) { + canonicalLoaderRefs.remove(loaderRef); + CacheKey key = loaderKeys.remove(loaderRef); + while (key != null) { + cache.remove(key); + key = key.next; + } + } + +/* + * Identifies if the loader used to load is one of the system loaders, + * if so updates the cache and the LoaderKey, and also a StaleLoaderReference for the initiating LoaderObject + * via LoaderRef Constructor + */ + void update(CacheKey key, Class<?> result) { + Object resultLoaderObj = + LoaderRef.getLoaderObj(result.getClassLoader()); + if (getCanonicalLoaderRef(resultLoaderObj).isSystem == false) { + return; + } + + Object oldValue = cache.replace(key, result); + assert (oldValue instanceof FutureValue) : + ("Value replaced is of type '" + oldValue.getClass().getName() + + "', not of type '" + FutureValue.class.getName() + "'."); + + LoaderRef loaderRef = key.loaderRef; + if (loaderRef.isSystem == false) { + key.next = loaderKeys.get(loaderRef); + if (key.next == null) { + key.next = loaderKeys.putIfAbsent(loaderRef, key); + if (key.next == null) return; + } + while (!loaderKeys.replace(loaderRef, key.next, key)) { + key.next = loaderKeys.get(loaderRef); + } + } + } +/* + * Creates a New Entry in the Cache + */ + private Object createEntry(CacheKey key) { + FutureValue newValue = new FutureValue(key, this); //Does actual call to class.forName as required. + Object value = cache.putIfAbsent(key, newValue); + if (value == null) value = newValue; + return value; + } +/* + * This is the entry point in to the cache from ObjectInputStream. First Lookup is done based on the className and Loader + */ + public Class<?> get(String className, ClassLoader loader) + throws ClassNotFoundException { + LookupKey key = new LookupKey(className, loader, this); + Object value = cache.get(key); + if (value == null) { + value = createEntry(key.createCacheKey()); + } + + if (value instanceof FutureValue) { + + return ((FutureValue)value).get(); + } + + return (Class<?>)value; + } + + /* + * FutureValue implements Future Mechanics that is required for addressing contention issues in the HashMap + */ + + private static final class FutureValue { + private final CacheKey key; + private final LoaderRef loaderRef; + private final ClassCache cache; + private Class<?> value = null; + + FutureValue(CacheKey key, ClassCache cache) { + this.key = key; + this.loaderRef = key.loaderRef; + this.cache = cache; + } + + /* + * tries to get the value from Cache, if not available tries to do get class.forName with active loader + * and replace the entry in the cache as required + */ + Class<?> get() throws ClassNotFoundException { + synchronized (this) { + if (value != null) return value; + value = Class.forName(key.className, false, + loaderRef.getActiveLoader()); + } + if (value != null) { + cache.update(key, value); + } + + return value; + } + } + + private static final class CreateReaperAction + implements PrivilegedAction<Thread> { + private final ClassCache cache; + private final ReferenceQueue<Object> queue; + + CreateReaperAction(ClassCache cache, ReferenceQueue<Object> queue) { + this.cache = cache; + this.queue = queue; + } + + public Thread run() { + return new Reaper(cache, queue); + } + } + + private static final class Reaper extends Thread { + private final WeakReference<ClassCache> cacheRef; + private final ReferenceQueue<Object> queue; + + Reaper(ClassCache cache, ReferenceQueue<Object> queue) { + super("ClassCache Reaper"); + this.queue = queue; + cacheRef = new WeakReference<ClassCache>(cache, queue); + setDaemon(true); + setContextClassLoader(null); + } +/* + * Blocks on remove() on queur reference and calls processStaleRef() when any loader is removed.(non-Javadoc) + * @see java.lang.Thread#run() + */ + public void run() { + Object staleRef = null; + do { + try { + staleRef = queue.remove(); + if (staleRef == cacheRef) break; + + processStaleRef((LoaderRef)staleRef); + } catch (InterruptedException e) { } + } while (true); + } + + private void processStaleRef(LoaderRef staleRef) { + ClassCache cache = cacheRef.get(); + if (cache == null) return; + + cache.removeStaleRef(staleRef); + } + } + + /* + * The use of the loaderRefs map is to allow efficient processing + * of one Weak Reference for each stale ClassLoader, rather than one WR for each entry in the cache. + * + * CacheKey as well as Lookup Key will be refering to this LoaderRef. + * + * Initiating Class Loaders needs to be referred for both lookup and Caching,so for performance reasons + * a LoaderRef is maintained which would be used by both LookupKey and CachingKey + * (ie) LookupKey will actually store the LoaderObj, but it will be canonically refered via a loaderRed + * by the caching Key + * LoaderKey has LoaderRef Objects as well and is used to Link the Initiating Loader with the actual cache Entries + * which is used to remove Stale reference entries. + */ + + private static class LoaderRef extends WeakReference<Object> { + private static final String NULL_LOADER = new String(""); + private final int hashcode; + public final boolean isSystem; + + static Object getLoaderObj(ClassLoader loader) { + return ((loader == null) ? NULL_LOADER : loader); + } + + LoaderRef(Object loaderObj, ReferenceQueue<Object> queue) { + this(false, Objects.requireNonNull(loaderObj), queue); + } + + LoaderRef(ClassLoader loader, ReferenceQueue<Object> queue, + boolean isSystem) { + this(isSystem, getLoaderObj(loader), queue); + } + + /* + * Creates a new weak reference that refers to the given object and is registered with the given queue. + */ + + private LoaderRef(boolean isSystem, Object loaderObj, + ReferenceQueue<Object> queue) { + super(loaderObj, queue); + String loaderClassName = ((loaderObj == NULL_LOADER) ? + NULL_LOADER : loaderObj.getClass().getName()); + hashcode = (loaderClassName.hashCode() + + System.identityHashCode(loaderObj)); + this.isSystem = isSystem; + } + + public final boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof LoaderRef)) return false; + + Object loader = get(); + return ((loader != null) && (loader == ((LoaderRef)o).get())); + } + + public final int hashCode() { + return hashcode; + } + + ClassLoader getActiveLoader() { + Object loaderObj = Objects.requireNonNull(get()); + return ((loaderObj == NULL_LOADER) ? null : (ClassLoader)loaderObj); + } + } + /* + * For better clarity and to avoid multiple lookups to the cache. Key is implemented to have + * one abstract key to final sub classes which serve specific purpose + * LookupKey - This is a short lived key, not part of any hashmap and stores the strong reference to + * loaderobject + * CachingKey - uses the same hash as LookupKey and has a means to be generated from LookupKey and has reference + * to the Loaderobj via a weakreference. + */ + + private static abstract class Key { + public final String className; + protected final int hashcode; + + protected Key(String className, int hashcode) { + this.className = className; + this.hashcode = hashcode; + } + + abstract Object getLoaderObj(); + + public final boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof Key)) return false; + + Key k = (Key)o; + Object loaderObj = getLoaderObj(); + return (className.equals(k.className) && + (loaderObj != null) && (loaderObj == k.getLoaderObj())); + } + + public final int hashCode() { + return hashcode; + } + } + /* + * Lookup Key hash code is framed using loadername hash + loader's system identity hashcode. This + * is same as the hashcode maintained in CacheKey + */ + + private static final class LookupKey extends Key { + private final Object loaderObj; + private final ClassCache cache; + + private static int hashCode(String className, ClassLoader loader) { + int hashcode = className.hashCode(); + if (loader != null) { + hashcode += (loader.getClass().getName().hashCode() + + System.identityHashCode(loader)); + } + return hashcode; + } + + public LookupKey(String className, ClassLoader loader, + ClassCache cache) { + super(Objects.requireNonNull(className), + hashCode(className, loader)); + loaderObj = LoaderRef.getLoaderObj(loader); + this.cache = cache; + } + + Object getLoaderObj() { + return loaderObj; + } + + CacheKey createCacheKey() { + return new CacheKey(className, hashcode, + cache.getCanonicalLoaderRef(loaderObj)); + } + } + + /* + * CacheKey is the actual key that is stored in the cache, and it stores the weakreference + * of the Initiating loader object via loaderRef + * + */ + private static final class CacheKey extends Key { + public final LoaderRef loaderRef; + public CacheKey next = null; + + CacheKey(String className, int hashcode, LoaderRef loaderRef) { + super(className, hashcode); + this.loaderRef = loaderRef; + } + + Object getLoaderObj() { + return loaderRef.get(); + } + } +} diff -r 60c19c384333 src/java.base/share/classes/java/io/ObjectInputStream.java --- a/src/java.base/share/classes/java/io/ObjectInputStream.java Wed Jan 31 15:15:09 2018 -0800 +++ b/src/java.base/share/classes/java/io/ObjectInputStream.java Fri Feb 02 11:52:41 2018 +0000 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1996, 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1996, 2018, Oracle and/or its affiliates. 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 @@ -308,6 +308,32 @@ private ObjectInputFilter serialFilter; /** + * cache LUDCL (Latest User Defined Class Loader) till completion of + * read* requests + */ + + /* ClassCache Entry for caching class.forName results upon enableClassCaching */ + private static final ClassCache classCache; + private static final boolean isClassCachingEnabled; + static { + isClassCachingEnabled = + AccessController.doPrivileged(new GetClassCachingSettingAction()); + classCache = (isClassCachingEnabled ? new ClassCache() : null); + } + + + /** if true LUDCL/forName results would be cached, true by default */ + private static final class GetClassCachingSettingAction + implements PrivilegedAction<Boolean> { + public Boolean run() { + String property = + System.getProperty("openjdk.enableClassCaching", "true"); + return property.equalsIgnoreCase("true"); + } + } + private ClassLoader cachedLudcl; + + /** * Creates an ObjectInputStream that reads from the specified InputStream. * A serialization stream header is read from the stream and verified. * This constructor will block until the corresponding ObjectOutputStream @@ -412,10 +438,64 @@ public final Object readObject() throws IOException, ClassNotFoundException { + return readObjectImpl(null); + } + + /** + * Whenever jit compiler encounters processing readObject() method + * it will replace the call with redirectedReadObject() method to improve + * the performance for custom serialisation. JIT provide the class loader through + * the caller parameter to avoid the stack walk through while calling + * latestUserDefinedLoader(). + * + * @throws ClassNotFoundException if the class of a serialized object + * could not be found. + * @throws IOException if an I/O error occurs. + * + */ + + private static Object redirectedReadObject(ObjectInputStream iStream, Class<?> caller) + throws ClassNotFoundException, IOException + { + return iStream.readObjectImpl(caller); + } + + /** + * Actual implementation of readObject method which fetches classloader using + * latestUserDefinedLoader() method if caller is null. If caller is not null which means + * jit passes the class loader info and hence avoids calling latestUserDefinedLoader() + * method call to improve the performance for custom serialisation. + * + * @throws ClassNotFoundException if the class of a serialized object + * could not be found. + * @throws IOException if an I/O error occurs. + */ + private Object readObjectImpl(Class<?> caller) + throws ClassNotFoundException, IOException + { + if (enableOverride) { return readObjectOverride(); } + ClassLoader oldCachedLudcl = null; + boolean setCached = false; + + if ((curContext == null) && (isClassCachingEnabled)) { + oldCachedLudcl = cachedLudcl; + + // If caller is not provided, follow the standard path to get the cachedLudcl. + // Otherwise use the class loader provided by JIT as the cachedLudcl. + + if (caller == null) { + cachedLudcl = latestUserDefinedLoader(); + } else { + cachedLudcl = caller.getClassLoader(); + } + + setCached = true; + } + // if nested read, passHandle contains handle of enclosing object int outerHandle = passHandle; try { @@ -432,6 +512,9 @@ return obj; } finally { passHandle = outerHandle; + if (setCached) { + cachedLudcl = oldCachedLudcl; + } if (closed && depth == 0) { clear(); } @@ -511,6 +594,16 @@ * @since 1.4 */ public Object readUnshared() throws IOException, ClassNotFoundException { + + ClassLoader oldCachedLudcl = null; + boolean setCached = false; + + if ((curContext == null) && (isClassCachingEnabled)) { + oldCachedLudcl = cachedLudcl; + cachedLudcl = latestUserDefinedLoader(); + setCached = true; + } + // if nested read, passHandle contains handle of enclosing object int outerHandle = passHandle; try { @@ -527,6 +620,9 @@ return obj; } finally { passHandle = outerHandle; + if (setCached) { + cachedLudcl = oldCachedLudcl; + } if (closed && depth == 0) { clear(); } @@ -682,7 +778,10 @@ { String name = desc.getName(); try { - return Class.forName(name, false, latestUserDefinedLoader()); + return ((classCache == null) ? + Class.forName(name, false, latestUserDefinedLoader()) : + classCache.get(name, cachedLudcl)); + } catch (ClassNotFoundException ex) { Class<?> cl = primClasses.get(name); if (cl != null) { ----------------------------------------------------------------------------------------------------------------------- Regards, Ben Walsh Unless stated otherwise above: IBM United Kingdom Limited - Registered in England and Wales with number 741598. Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6 3AU Unless stated otherwise above: IBM United Kingdom Limited - Registered in England and Wales with number 741598. Registered office: PO Box 41, North Harbour, Portsmouth, Hampshire PO6 3AU

2 1

[JDK-6341887] Patch: java.util.zip: Add ByteBuffer methods to Inflater/Deflater
by David Lloyd 19 Feb '18

19 Feb '18

It would be convenient to be able to inflate/deflate a direct or heap byte buffer without having to copy it through an array first. For my Friday mini-project this week, I've decided to take a crack at this. The attached patch is the result. Would anyone be interested in reviewing and maybe sponsoring this change? It would be really great to get it in to JDK 11. The patch includes a modification to FlaterTest to run through permutations of using direct and heap byte buffers. Though I couldn't get jtreg working, I did compile and run the test by hand and it seems to pass; the build also works fine with the new code. Extra thanks to Martin Balao for pointing me towards mapfile-vers when I couldn't figure out why I was getting UnsatisfiedLinkError. That one was not obvious. -- - DML

3 5

FileOutputStream.available() and pipe EOF
by Basin Ilya 19 Feb '18

19 Feb '18

Hi list. My question relates to streams returned by java.lang.Process.getInputStream() On Linux calling available() after the other side of the pipe was closed will throw: java.io.IOException: Stream Closed This is very handy, because you can distinguish EOF and a pause in transmission. On Windows same Oracle JDK version 1.8.0_161 behaves in a traditional manner and available() returns 0 in both cases. Will this ever change?

2 3

[1] RFR(XXS): 8197927: Can't set mandatory 'java.vendor.version' property to empty string
by Volker Simonis 19 Feb '18

19 Feb '18

Hi, can I please get a review for the following tiny fix: http://cr.openjdk.java.net/~simonis/webrevs/2018/8197927/ https://bugs.openjdk.java.net/browse/JDK-8197927 The new Java 10 specification makes the 'java.vendor.version' property mandatory [1] but the current implementations doesn't allow to set it to an empty string. Currently, if we don't configure the build with --with-vendor-version=XXX the 'java.vendor.version' property won't be set at all, which violates the spec. Setting it to an empty string will be ignored and has the same behavior like not setting it at all. This also makes default OpenJDK builds (which haven't been configured with --with-vendor-version non-compliant). The fix is trivial: unconditionally set the 'java.vendor.version' property to the value of VENDOR_VERSION_STRING in VersionProps.java.template, even if VENDOR_VERSION_STRING is the empty string (which is the default if --with-vendor-version wasn't given at config time). Thank you and best regards, Volker [1] http://cr.openjdk.java.net/~iris/se/10/pfd/java-se-10-pfd-spec/apidiffs/jav…

3 8

Thread.interrupted() spec is confusing
by Tagir Valeev 18 Feb '18

18 Feb '18

Hello! A Thread.interrupted() static method (not to be confused with Thread.isInterrupted() instance method) spec states: * <http://hg.openjdk.java.net/jdk/jdk/file/67cdc215ed70/src/java.base/share/cl…> * <p>A thread interruption ignored because a thread was not alive <http://hg.openjdk.java.net/jdk/jdk/file/67cdc215ed70/src/java.base/share/cl…> * at the time of the interrupt will be reflected by this method <http://hg.openjdk.java.net/jdk/jdk/file/67cdc215ed70/src/java.base/share/cl…> * returning false. The Thread.interrupted() always applies to the current thread. I don't understand how it's possible that a current thread is not alive. To me this note is redundant and should be removed. Am I missing something? With best regards, Tagir Valeev.

3 2

RFR: JDK-8021560,(str) String constructors that take ByteBuffer
by Xueming Shen 17 Feb '18

17 Feb '18

Hi, Please help review the proposal to add following constructors and methods in String class to take ByteBuffer as the input and output data buffer. public String(ByteBuffer bytes, Charset cs); public String(ByteBuffer bytes, String csname); public int getBytes(byte[] dst, int offset, Charset cs); public int getBytes(byte[] dst, int offset, String csname); public int getBytes(ByteBuffer bytes, Charset cs); public int getBytes(ByteBuffer bytes, Charset csn); This is based on the change proposed by Richard in jdk9 time frame [1]. But since we were fully occupied by compact string support work back then, this one did not make into the top jdk9 priority list. issue: https://bugs.openjdk.java.net/browse/JDK-8021560 webrev: http://cr.openjdk.java.net/~sherman/8021560/webrev The implementation in StringCoding class is a little "duplicated" for various types of encoding/decoding variants. There is definitely room to further consolidate. But I would assume it might be better to keep the new code path separated from the existing "fully tuned" methods, for now, to avoid possible performance regression for existing String methods. Thanks, Sherman [1] http://mail.openjdk.java.net/pipermail/core-libs-dev/2014-November/029672.h…

8 16

[11] RFR: JDK-8198228: Spec clarification: j.u.Locale.getDisplayName()
by naoto.sato＠oracle.com 16 Feb '18

16 Feb '18

Hello, Please review this small doc-only fix for this issue: https://bugs.openjdk.java.net/browse/JDK-8198228 The proposed changeset is located at: http://cr.openjdk.java.net/~naoto/8198228/webrev.00/ It is just to clarify the field separator in locale display names. Corresponding CSR (8198236) is already approved. Naoto

2 1

[11] RFR JDK-8190904: Incorrect currency instance returned by java.util.Currency.getInstance()
by Nishit Jain 16 Feb '18

16 Feb '18

Hi, Please review the fix for JDK-8190904. Bug: https://bugs.openjdk.java.net/browse/JDK-8190904 Webrev: http://cr.openjdk.java.net/~nishjain/8190904/webrev.07/ CSR: https://bugs.openjdk.java.net/browse/JDK-8196835 Issue: The currency superseding feature gives the possibility of allowing two similar Currency instances for a currency code, which is against the principle that "There can never more than one Currency instance for any given currency". Fix: Modify the superseding feature to not allow multiple entries with same currency code but different numeric and/or minor unit. These are ignored as inconsistent entries. Also, If there is any ISO 4217 currency data with same currency code as the currency entry given in the properties file, then the existing Currency data should be updated with the given currency values. Regards, Nishit Jain

2 1

Re: RFR: 8041626: [Event Request] Shutdown reason
by Robin Westberg 16 Feb '18

16 Feb '18

Hi again, Here’s the (hopefully) final version: Full: http://cr.openjdk.java.net/~rwestberg/8041626/webrev.02/ <http://cr.openjdk.java.net/~rwestberg/8041626/webrev.02/> Incremental: http://cr.openjdk.java.net/~rwestberg/8041626/webrev.01-02/ <http://cr.openjdk.java.net/~rwestberg/8041626/webrev.01-02/> Best regards, Robin > On 14 Feb 2018, at 16:15, Robin Westberg <robin.westberg(a)oracle.com> wrote: > > Hi Roger, > >> On 13 Feb 2018, at 16:17, Roger Riggs <Roger.Riggs(a)Oracle.com> wrote: >> >> Hi Robin, >> >> It looks like the status argument to BeforeHalt is discarded in JVM_BeforeHalt >> and is not inserted into the event. >> That suggests it should be removed all the way back to Shutdown.beforeHalt. > > You are right, my thinking was that the interface wouldn’t need to be changed if we decided to revisit the event in the future and add the status code. But that is perhaps unlikely, so can certainly remove the argument for now. > > Best regards, > Robin > >> >> Roger >> >> >> >> On 2/13/2018 9:59 AM, Robin Westberg wrote: >>> Hi Alan, >>> >>>> On 12 Feb 2018, at 09:02, Alan Bateman <Alan.Bateman(a)oracle.com> wrote: >>>> >>>> >>>> >>>> On 12/02/2018 07:07, David Holmes wrote: >>>>>> Okay, I’ve removed the code related to the status field, certainly makes the change a bit less intrusive. >>>>>> >>>>>> Updated webrev: http://cr.openjdk.java.net/~rwestberg/8041626/webrev.01/ >>>>>> Incremental: http://cr.openjdk.java.net/~rwestberg/8041626/webrev.00-01/ >>>>> This looks much cleaner/neater to me - thanks. >>>>> >>>> The updates to Runtime/Shutdown seems okay. >>> Thanks for reviewing! >>> >>> Best regards, >>> Robin >>> >>>> -Alan >> >

4 5

RFR: 8197812: (ref) Data race in Finalizer
by Martin Buchholz 16 Feb '18

16 Feb '18

Unlike most fixes to data races, this one should benefit performance. http://cr.openjdk.java.net/~martin/webrevs/jdk/Finalizer-data-race/ https://bugs.openjdk.java.net/browse/JDK-8197812

3 18