/*
* Copyright (c) 2010, 2014, 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 jdk.nashorn.internal.runtime;
import static jdk.nashorn.internal.codegen.CompilerConstants.staticCall;
import static jdk.nashorn.internal.codegen.CompilerConstants.virtualCall;
import static jdk.nashorn.internal.lookup.Lookup.MH;
import static jdk.nashorn.internal.runtime.UnwarrantedOptimismException.INVALID_PROGRAM_POINT;
import static jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor.getProgramPoint;
import static jdk.nashorn.internal.runtime.logging.DebugLogger.quote;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.SwitchPoint;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import jdk.dynalink.CallSiteDescriptor;
import jdk.dynalink.DynamicLinker;
import jdk.dynalink.linker.GuardedInvocation;
import jdk.dynalink.linker.LinkRequest;
import jdk.nashorn.internal.lookup.Lookup;
import jdk.nashorn.internal.lookup.MethodHandleFactory;
import jdk.nashorn.internal.runtime.linker.NashornCallSiteDescriptor;
import jdk.nashorn.internal.runtime.logging.DebugLogger;
import jdk.nashorn.internal.runtime.logging.Loggable;
import jdk.nashorn.internal.runtime.logging.Logger;
/**
* Each context owns one of these. This is basically table of accessors
* for global properties. A global constant is evaluated to a MethodHandle.constant
* for faster access and to avoid walking to proto chain looking for it.
*
* We put a switchpoint on the global setter, which invalidates the
* method handle constant getters, and reverts to the standard access strategy
*
* However, there is a twist - while certain globals like "undefined" and "Math"
* are usually never reassigned, a global value can be reset once, and never again.
* This is a rather common pattern, like:
*
* x = function(something) { ...
*
* Thus everything registered as a global constant gets an extra chance. Set once,
* reregister the switchpoint. Set twice or more - don't try again forever, or we'd
* just end up relinking our way into megamorphism.
*
* Also it has to be noted that this kind of linking creates a coupling between a Global
* and the call sites in compiled code belonging to the Context. For this reason, the
* linkage becomes incorrect as soon as the Context has more than one Global. The
* {@link #invalidateForever()} is invoked by the Context to invalidate all linkages and
* turn off the functionality of this object as soon as the Context's {@link Context#newGlobal()} is invoked
* for second time.
*
* We can extend this to ScriptObjects in general (GLOBAL_ONLY=false), which requires
* a receiver guard on the constant getter, but it currently leaks memory and its benefits
* have not yet been investigated property.
*
* As long as all Globals in a Context share the same GlobalConstants instance, we need synchronization
* whenever we access it.
*/
@Logger(name="const")
public final class GlobalConstants implements Loggable {
/**
* Should we only try to link globals as constants, and not generic script objects.
* Script objects require a receiver guard, which is memory intensive, so this is currently
* disabled. We might implement a weak reference based approach to this later.
*/
public static final boolean GLOBAL_ONLY = true;
private static final MethodHandles.Lookup LOOKUP = MethodHandles.lookup();
private static final MethodHandle INVALIDATE_SP = virtualCall(LOOKUP, GlobalConstants.class, "invalidateSwitchPoint", Object.class, Object.class, Access.class).methodHandle();
private static final MethodHandle RECEIVER_GUARD = staticCall(LOOKUP, GlobalConstants.class, "receiverGuard", boolean.class, Access.class, Object.class, Object.class).methodHandle();
/** Logger for constant getters */
private final DebugLogger log;
/**
* Access map for this global - associates a symbol name with an Access object, with getter
* and invalidation information
*/
private final Map<Object, Access> map = new HashMap<>();
private final AtomicBoolean invalidatedForever = new AtomicBoolean(false);
/**
* Constructor - used only by global
* @param log logger, or null if none
*/
public GlobalConstants(final DebugLogger log) {
this.log = log == null ? DebugLogger.DISABLED_LOGGER : log;
}
@Override
public DebugLogger getLogger() {
return log;
}
@Override
public DebugLogger initLogger(final Context context) {
return DebugLogger.DISABLED_LOGGER;
}
/**
* Information about a constant access and its potential invalidations
*/
private static class Access {
/** name of symbol */
private final String name;
/** switchpoint that invalidates the getters and setters for this access */
private SwitchPoint sp;
/** invalidation count for this access, i.e. how many times has this property been reset */
private int invalidations;
/** has a guard guarding this property getter failed? */
private boolean guardFailed;
private static final int MAX_RETRIES = 2;
private Access(final String name, final SwitchPoint sp) {
this.name = name;
this.sp = sp;
}
private boolean hasBeenInvalidated() {
return sp.hasBeenInvalidated();
}
private boolean guardFailed() {
return guardFailed;
}
private void failGuard() {
invalidateOnce();
guardFailed = true;
}
private void newSwitchPoint() {
assert hasBeenInvalidated();
sp = new SwitchPoint();
}
private void invalidate(final int count) {
if (!sp.hasBeenInvalidated()) {
SwitchPoint.invalidateAll(new SwitchPoint[] { sp });
invalidations += count;
}
}
/**
* Invalidate the access, but do not contribute to the invalidation count
*/
private void invalidateUncounted() {
invalidate(0);
}
/**
* Invalidate the access, and contribute 1 to the invalidation count
*/
private void invalidateOnce() {
invalidate(1);
}
/**
* Invalidate the access and make sure that we never try to turn this into
* a MethodHandle.constant getter again
*/
private void invalidateForever() {
invalidate(MAX_RETRIES);
}
/**
* Are we allowed to relink this as constant getter, even though it
* it has been reset
* @return true if we can relink as constant, one retry is allowed
*/
private boolean mayRetry() {
return invalidations < MAX_RETRIES;
}
@Override
public String toString() {
return "[" + quote(name) + " <id=" + Debug.id(this) + "> inv#=" + invalidations + '/' + MAX_RETRIES + " sp_inv=" + sp.hasBeenInvalidated() + ']';
}
String getName() {
return name;
}
SwitchPoint getSwitchPoint() {
return sp;
}
}
/**
* To avoid an expensive global guard "is this the same global", similar to the
* receiver guard on the ScriptObject level, we invalidate all getters once
* when we switch globals. This is used from the class cache. We _can_ reuse
* the same class for a new global, but the builtins and global scoped variables
* will have changed.
*/
public void invalidateAll() {
if (!invalidatedForever.get()) {
log.info("New global created - invalidating all constant callsites without increasing invocation count.");
synchronized (this) {
for (final Access acc : map.values()) {
acc.invalidateUncounted();
}
}
}
}
/**
* To avoid an expensive global guard "is this the same global", similar to the
* receiver guard on the ScriptObject level, we invalidate all getters when the
* second Global is created by the Context owning this instance. After this
* method is invoked, this GlobalConstants instance will both invalidate all the
* switch points it produced, and it will stop handing out new method handles
* altogether.
*/
public void invalidateForever() {
if (invalidatedForever.compareAndSet(false, true)) {
log.info("New global created - invalidating all constant callsites.");
synchronized (this) {
for (final Access acc : map.values()) {
acc.invalidateForever();
}
map.clear();
}
}
}
/**
* Invalidate the switchpoint of an access - we have written to
* the property
*
* @param obj receiver
* @param acc access
*
* @return receiver, so this can be used as param filter
*/
@SuppressWarnings("unused")
private synchronized Object invalidateSwitchPoint(final Object obj, final Access acc) {
if (log.isEnabled()) {
log.info("*** Invalidating switchpoint " + acc.getSwitchPoint() + " for receiver=" + obj + " access=" + acc);
}
acc.invalidateOnce();
if (acc.mayRetry()) {
if (log.isEnabled()) {
log.info("Retry is allowed for " + acc + "... Creating a new switchpoint.");
}
acc.newSwitchPoint();
} else {
if (log.isEnabled()) {
log.info("This was the last time I allowed " + quote(acc.getName()) + " to relink as constant.");
}
}
return obj;
}
private Access getOrCreateSwitchPoint(final String name) {
Access acc = map.get(name);
if (acc != null) {
return acc;
}
final SwitchPoint sp = new SwitchPoint();
map.put(name, acc = new Access(name, sp));
return acc;
}
/**
* Called from script object on property deletion to erase a property
* that might be linked as MethodHandle.constant and force relink
* @param name name of property
*/
void delete(final Object name) {
if (!invalidatedForever.get()) {
synchronized (this) {
final Access acc = map.get(name);
if (acc != null) {
acc.invalidateForever();
}
}
}
}
/**
* Receiver guard is used if we extend the global constants to script objects in general.
* As the property can have different values in different script objects, while Global is
* by definition a singleton, we need this for ScriptObject constants (currently disabled)
*
* TODO: Note - this seems to cause memory leaks. Use weak references? But what is leaking seems
* to be the Access objects, which isn't the case for Globals. Weird.
*
* @param acc access
* @param boundReceiver the receiver bound to the callsite
* @param receiver the receiver to check against
*
* @return true if this receiver is still the one we bound to the callsite
*/
@SuppressWarnings("unused")
private static boolean receiverGuard(final Access acc, final Object boundReceiver, final Object receiver) {
final boolean id = receiver == boundReceiver;
if (!id) {
acc.failGuard();
}
return id;
}
private static boolean isGlobalSetter(final ScriptObject receiver, final FindProperty find) {
if (find == null) {
return receiver.isScope();
}
return find.getOwner().isGlobal();
}
/**
* Augment a setter with switchpoint for invalidating its getters, should the setter be called
*
* @param find property lookup
* @param inv normal guarded invocation for this setter, as computed by the ScriptObject linker
* @param desc callsite descriptor
* @param request link request
*
* @return null if failed to set up constant linkage
*/
GuardedInvocation findSetMethod(final FindProperty find, final ScriptObject receiver, final GuardedInvocation inv, final CallSiteDescriptor desc, final LinkRequest request) {
if (invalidatedForever.get() || (GLOBAL_ONLY && !isGlobalSetter(receiver, find))) {
return null;
}
final String name = NashornCallSiteDescriptor.getOperand(desc);
synchronized (this) {
final Access acc = getOrCreateSwitchPoint(name);
if (log.isEnabled()) {
log.fine("Trying to link constant SETTER ", acc);
}
if (!acc.mayRetry() || invalidatedForever.get()) {
if (log.isEnabled()) {
log.fine("*** SET: Giving up on " + quote(name) + " - retry count has exceeded " + DynamicLinker.getLinkedCallSiteLocation());
}
return null;
}
if (acc.hasBeenInvalidated()) {
log.info("New chance for " + acc);
acc.newSwitchPoint();
}
assert !acc.hasBeenInvalidated();
// if we haven't given up on this symbol, add a switchpoint invalidation filter to the receiver parameter
final MethodHandle target = inv.getInvocation();
final Class<?> receiverType = target.type().parameterType(0);
final MethodHandle boundInvalidator = MH.bindTo(INVALIDATE_SP, this);
final MethodHandle invalidator = MH.asType(boundInvalidator, boundInvalidator.type().changeParameterType(0, receiverType).changeReturnType(receiverType));
final MethodHandle mh = MH.filterArguments(inv.getInvocation(), 0, MH.insertArguments(invalidator, 1, acc));
assert inv.getSwitchPoints() == null : Arrays.asList(inv.getSwitchPoints());
log.info("Linked setter " + quote(name) + " " + acc.getSwitchPoint());
return new GuardedInvocation(mh, inv.getGuard(), acc.getSwitchPoint(), inv.getException());
}
}
/**
* Try to reuse constant method handles for getters
* @param c constant value
* @return method handle (with dummy receiver) that returns this constant
*/
public static MethodHandle staticConstantGetter(final Object c) {
return MH.dropArguments(JSType.unboxConstant(c), 0, Object.class);
}
private MethodHandle constantGetter(final Object c) {
final MethodHandle mh = staticConstantGetter(c);
if (log.isEnabled()) {
return MethodHandleFactory.addDebugPrintout(log, Level.FINEST, mh, "getting as constant");
}
return mh;
}
/**
* Try to turn a getter into a MethodHandle.constant, if possible
*
* @param find property lookup
* @param receiver receiver
* @param desc callsite descriptor
*
* @return resulting getter, or null if failed to create constant
*/
GuardedInvocation findGetMethod(final FindProperty find, final ScriptObject receiver, final CallSiteDescriptor desc) {
// Only use constant getter for fast scope access, because the receiver may change between invocations
// for slow-scope and non-scope callsites.
// Also return null for user accessor properties as they may have side effects.
if (invalidatedForever.get() || !NashornCallSiteDescriptor.isFastScope(desc)
|| (GLOBAL_ONLY && !find.getOwner().isGlobal())
|| find.getProperty() instanceof UserAccessorProperty) {
return null;
}
final boolean isOptimistic = NashornCallSiteDescriptor.isOptimistic(desc);
final int programPoint = isOptimistic ? getProgramPoint(desc) : INVALID_PROGRAM_POINT;
final Class<?> retType = desc.getMethodType().returnType();
final String name = NashornCallSiteDescriptor.getOperand(desc);
synchronized (this) {
final Access acc = getOrCreateSwitchPoint(name);
log.fine("Starting to look up object value " + name);
final Object c = find.getObjectValue();
if (log.isEnabled()) {
log.fine("Trying to link constant GETTER " + acc + " value = " + c);
}
if (acc.hasBeenInvalidated() || acc.guardFailed() || invalidatedForever.get()) {
if (log.isEnabled()) {
log.info("*** GET: Giving up on " + quote(name) + " - retry count has exceeded " + DynamicLinker.getLinkedCallSiteLocation());
}
return null;
}
final MethodHandle cmh = constantGetter(c);
MethodHandle mh;
MethodHandle guard;
if (isOptimistic) {
if (JSType.getAccessorTypeIndex(cmh.type().returnType()) <= JSType.getAccessorTypeIndex(retType)) {
//widen return type - this is pessimistic, so it will always work
mh = MH.asType(cmh, cmh.type().changeReturnType(retType));
} else {
//immediately invalidate - we asked for a too wide constant as a narrower one
mh = MH.dropArguments(MH.insertArguments(JSType.THROW_UNWARRANTED.methodHandle(), 0, c, programPoint), 0, Object.class);
}
} else {
//pessimistic return type filter
mh = Lookup.filterReturnType(cmh, retType);
}
if (find.getOwner().isGlobal()) {
guard = null;
} else {
guard = MH.insertArguments(RECEIVER_GUARD, 0, acc, receiver);
}
if (log.isEnabled()) {
log.info("Linked getter " + quote(name) + " as MethodHandle.constant() -> " + c + " " + acc.getSwitchPoint());
mh = MethodHandleFactory.addDebugPrintout(log, Level.FINE, mh, "get const " + acc);
}
return new GuardedInvocation(mh, guard, acc.getSwitchPoint(), null);
}
}
}