Java tutorial
/* * * 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.flex.compiler.internal.scopes; import org.apache.flex.compiler.common.DependencyType; import org.apache.flex.compiler.constants.IASLanguageConstants; import org.apache.flex.compiler.definitions.IDefinition; import org.apache.flex.compiler.definitions.IInterfaceDefinition; import org.apache.flex.compiler.definitions.INamespaceDefinition; import org.apache.flex.compiler.definitions.references.IResolvedQualifiersReference; import org.apache.flex.compiler.internal.definitions.AmbiguousDefinition; import org.apache.flex.compiler.internal.definitions.ClassDefinitionBase; import org.apache.flex.compiler.internal.definitions.ConstantDefinition; import org.apache.flex.compiler.internal.definitions.TypeDefinitionBase; import org.apache.flex.compiler.internal.projects.CompilerProject; import org.apache.flex.compiler.projects.ICompilerProject; import com.google.common.collect.MapMaker; import com.google.common.collect.Sets; import java.lang.ref.SoftReference; import java.util.Collections; import java.util.List; import java.util.Set; import java.util.concurrent.ConcurrentMap; /** * Class to manage cached lookups in a given project. Each scope object will * have one of these per project the scope object is used in. This class is * intended to provide thread safe access to the various caches it maintains. * The caches will be maintained via SoftReferences - this is meant to make the * caches stick around unless the VM really needs the memory back. The caches * can be rebuilt on the fly, so in a worst case scenario where the VM is * constantly low on memory, the results should be correct, but performance will * be slower. */ public class ASScopeCache { /** * The concurrency level to use for the various ConcurrentMaps in use by * this cache. If the concurrency level is too high, you waste time and * space, if it is too low, then you have contention on updates of the map. * 4 seems to be a good tradeoff performance wise, and it is unlikely that * any individual scope cache is being updated from more than 4 threads * simultaneously. If our threading strategy changes (like if we make the CG * multithreaded within one file), we may want to revisit this setting. */ private static final int CONCURRENCY_LEVEL = 4; private static final MapMaker mapMaker = new MapMaker().concurrencyLevel(CONCURRENCY_LEVEL); public ASScopeCache(CompilerProject project, ASScope scope) { this.scope = scope; this.project = project; } private final ASScope scope; private final CompilerProject project; /** * Cache results of unqualified lookups over the scope chain * (ASScopeBase.findProperty). This is for caching the results of * ASScope.findProperty(). */ private SoftReference<ConcurrentMap<String, IDefinition>> findPropCache; /** * Cache results of lookups of qualified names over the scope chain * (ASScopeBase.findPropertyQualified). */ private SoftReference<ConcurrentMap<QName, IDefinition>> findPropQualifiedCache; /** * Cache the set of open namespaces */ private SoftReference<Set<INamespaceDefinition>> openNamespaceCache = null; /** * Cache the open namespace set per name */ private SoftReference<ConcurrentMap<String, Set<INamespaceDefinition>>> namespacesForNameCache; private SoftReference<ConcurrentMap<IResolvedQualifiersReference, IDefinition>> multinameLookupCache; /** * Cache the compile time values of constants */ private SoftReference<ConcurrentMap<IDefinition, Object>> constValueLookupCache; /** * Cache the needs Event dispatch flag */ private Boolean needsEventDispatcherCache; /** * Cache the extended or implemented interfaces of an interface or class. */ private SoftReference<IInterfaceDefinition[]> interfacesCache; /** * Cache the builtin types we've already added dependencies on */ private SoftReference<Set<IASLanguageConstants.BuiltinType>> builtinTypeDependencyCache; /** * Version of findProperty that uses a cache. Checks the cache first, and * only queries the scope if the we don't have a cached result. * * @param scope The scope to perform the lookup in * @param name Name of the property to find * @param cache ASDefinitionCache to use for the lookup - this is only used * to get at the ICompilerProject * @param dt Which type of dependency to introduce when we do the lookup * @return The IDefinition for the property, or null if it wasn't found */ IDefinition findProperty(String name, DependencyType dt) { ConcurrentMap<String, IDefinition> map = getScopeChainMap(); IDefinition result = map.get(name); if (result != null) { assert result.isInProject(project); // We found a cached result - we're done return result; } // It is possible for 2+ threads to get in here for the same name. // This is intentional - the worst that happens is that we duplicate the resolution work // the benefit is that we avoid any sort of locking, which was proving expensive (time wise, // and memory wise). IDefinition def = null; Set<INamespaceDefinition> namespaceSet = scope.getNamespaceSetForName(project, name); // Look for the definition in the scope List<IDefinition> defs = scope.findProperty(project, name, namespaceSet, dt); switch (defs.size()) { case 0: // No definition found! def = null; break; case 1: // found single definition! def = defs.get(0); assert def.isInProject(project); break; default: IDefinition d = AmbiguousDefinition.resolveAmbiguities(project, defs); if (d != null) def = d; else def = AmbiguousDefinition.get(); } if (def != null) { assert def.isInProject(project); assert result == null; // If we have a non-null dependency type // then we can cache the result of the name resolution. // If the dependency type is null we can't cache the name // resolution result, because the name resolution cache will not // be properly invalidated when the file containing the definition changes. if (dt != null) { result = map.putIfAbsent(name, def); if (result == null) result = def; } else { result = def; } } return result; } private ConcurrentMap<String, IDefinition> getScopeChainMap() { ConcurrentMap<String, IDefinition> map = findPropCache != null ? findPropCache.get() : null; if (map == null) { synchronized (this) { // Check again, in case another thread updated the map first map = findPropCache != null ? findPropCache.get() : null; if (map == null) { map = mapMaker.<String, IDefinition>makeMap(); findPropCache = new SoftReference<ConcurrentMap<String, IDefinition>>(map); } } } return map; } private ConcurrentMap<QName, IDefinition> getQualifiedScopeChainMap() { ConcurrentMap<QName, IDefinition> map = findPropQualifiedCache != null ? findPropQualifiedCache.get() : null; if (map == null) { synchronized (this) { // Check again, in case another thread updated the map first map = findPropQualifiedCache != null ? findPropQualifiedCache.get() : null; if (map == null) { map = mapMaker.<QName, IDefinition>makeMap(); findPropQualifiedCache = new SoftReference<ConcurrentMap<QName, IDefinition>>(map); } } } return map; } /** * Version of findPropertyQualified that uses a cache. Checks the cache * first, and only queries the scope if the we don't have a cached result. * * @param scope The scope to perform the lookup in * @param name Name of the property to find * @param cache ASDefinitionCache to use for the lookup - this is only used * to get at the ICompilerProject * @param dt Which type of dependency to introduce when we do the lookup * @return The IDefinition for the property, or null if it wasn't found */ IDefinition findPropertyQualified(INamespaceDefinition qualifier, String name, DependencyType dt) { QName qname = new QName(name, qualifier); ConcurrentMap<QName, IDefinition> map = getQualifiedScopeChainMap(); IDefinition result = map.get(qname); if (result != null) { assert result.isInProject(project); // We found a cached result - we're done return result; } // If we get this far, then we did not find a cached entry // It is possible for 2+ threads to get in here for the same name. // This is intentional - the worst that happens is that we duplicate the resolution work // the benefit is that we avoid any sort of locking, which was proving expensive (time wise, // and memory wise). IDefinition def; // Look for the definition in the scope Set<INamespaceDefinition> namespaceSet = Collections.singleton(qualifier); List<IDefinition> defs = scope.findProperty(project, name, namespaceSet, dt); switch (defs.size()) { case 0: def = null; break; case 1: def = defs.get(0); assert def.isInProject(project); break; default: IDefinition d = AmbiguousDefinition.resolveAmbiguities(project, defs); if (d != null) def = d; else def = AmbiguousDefinition.get(); break; } if (def != null) { assert def.isInProject(project); assert result == null; // If we have a non-null dependency type // then we can cache the result of the name resolution. // If the dependency type is null we can't cache the name // resolution result, because the name resolution cache will not // be properly invalidated when the file containing the definition changes. if (dt != null) { result = map.putIfAbsent(qname, def); if (result == null) result = def; } else { result = def; } } return result; } /** * Resolves the specified reference to a definition and adds a dependency to * the dependency graph if needed. * <p> * This method is only public so that the implementation of * IResolveQualifiersReference.resolve can call it. This method should only * be called from the implementation of {@link IResolvedQualifiersReference}. * * @param ref The reference to resolve. * @param dt The type of dependency to add if a new edge needs to be added * to the dependency graph. * @return The definition the reference resolves to, null, or the ambiguous * definition. */ public IDefinition findPropertyMultiname(IResolvedQualifiersReference ref, DependencyType dt) { ConcurrentMap<IResolvedQualifiersReference, IDefinition> cache = getMultinameLookupMap(); IDefinition result = cache.get(ref); if (result != null) return result; IDefinition def; // Look for the definition in the scope List<IDefinition> defs = scope.findProperty(project, ref.getName(), ref.getQualifiers(), dt); switch (defs.size()) { case 0: // No definition found! def = null; break; case 1: // found single definition! def = defs.get(0); assert def.isInProject(project); break; default: IDefinition d = AmbiguousDefinition.resolveAmbiguities(project, defs); if (d != null) def = d; else def = AmbiguousDefinition.get(); } if (def != null) { assert def.isInProject(project); assert result == null; // If we have a non-null dependency type // then we can cache the result of the name resolution. // If the dependency type is null we can't cache the name // resolution result, because the name resolution cache will not // be properly invalidated when the file containing the definition changes. if (dt != null) { result = cache.putIfAbsent(ref, def); if (result == null) result = def; } else { result = def; } } return result; } /** * Version of getNamespaceSet that caches the results. * * @return the namespace set to use for unqualified lookups in this scope */ Set<INamespaceDefinition> getNamespaceSet() { Set<INamespaceDefinition> nsSet = openNamespaceCache != null ? openNamespaceCache.get() : null; if (nsSet != null) return nsSet; nsSet = scope.getNamespaceSetImpl(project); openNamespaceCache = new SoftReference<Set<INamespaceDefinition>>(nsSet); return nsSet; } private ConcurrentMap<String, Set<INamespaceDefinition>> getNamespacesForNameMap() { ConcurrentMap<String, Set<INamespaceDefinition>> map = namespacesForNameCache != null ? namespacesForNameCache.get() : null; if (map == null) { synchronized (this) { // Check again, in case another thread updated the map first map = namespacesForNameCache != null ? namespacesForNameCache.get() : null; if (map == null) { map = mapMaker.<String, Set<INamespaceDefinition>>makeMap(); namespacesForNameCache = new SoftReference<ConcurrentMap<String, Set<INamespaceDefinition>>>( map); } } } return map; } private ConcurrentMap<IResolvedQualifiersReference, IDefinition> getMultinameLookupMap() { ConcurrentMap<IResolvedQualifiersReference, IDefinition> map = multinameLookupCache != null ? multinameLookupCache.get() : null; if (map == null) { synchronized (this) { // Check again, in case another thread updated the map first map = multinameLookupCache != null ? multinameLookupCache.get() : null; if (map == null) { map = mapMaker.<IResolvedQualifiersReference, IDefinition>makeMap(); multinameLookupCache = new SoftReference<ConcurrentMap<IResolvedQualifiersReference, IDefinition>>( map); } } } return map; } private ConcurrentMap<IDefinition, Object> getConstantValueLookupMap() { ConcurrentMap<IDefinition, Object> map = constValueLookupCache != null ? constValueLookupCache.get() : null; if (map == null) { synchronized (this) { // Check again, in case another thread updated the map first map = constValueLookupCache != null ? constValueLookupCache.get() : null; if (map == null) { map = mapMaker.<IDefinition, Object>makeMap(); constValueLookupCache = new SoftReference<ConcurrentMap<IDefinition, Object>>(map); } } } return map; } private Set<IASLanguageConstants.BuiltinType> getBuiltinTypeMap() { Set<IASLanguageConstants.BuiltinType> set = builtinTypeDependencyCache != null ? builtinTypeDependencyCache.get() : null; if (set == null) { synchronized (this) { // Check again, in case another thread updated the set first set = builtinTypeDependencyCache != null ? builtinTypeDependencyCache.get() : null; if (set == null) { set = Sets.newSetFromMap(mapMaker.<IASLanguageConstants.BuiltinType, Boolean>makeMap()); builtinTypeDependencyCache = new SoftReference<Set<IASLanguageConstants.BuiltinType>>(set); } } } return set; } /** * Determines if the {@link TypeScope} this cache is associtiated with needs * an implicit 'implements flash.events.IEventDispatcher' due to the class, * or some of its members being marked bindable. The result of this method * is cached. * <p> * Only * {@link ClassDefinitionBase#needsEventDispatcher(ICompilerProject)} * should call this method. All other code should call * {@link ClassDefinitionBase#needsEventDispatcher(ICompilerProject)}. * * @return true if this class needs to add IEventDispatcher to its interface * list, and should implement the IEventDispatcher methods. */ public boolean needsEventDispatcher() { assert scope instanceof TypeScope : "needsEventDispatcher should only be called on scope cache's for TypeScopes!"; assert scope .getDefinition() instanceof ClassDefinitionBase : "needsEventDispatcher should only be called on scope cache's for the scopes contained by classes!"; Boolean valueObject = needsEventDispatcherCache; if (valueObject != null) return valueObject.booleanValue(); synchronized (this) { // Check again, in case another thread updated the value first valueObject = needsEventDispatcherCache; if (valueObject != null) return valueObject.booleanValue(); boolean computedValue = ((ClassDefinitionBase) scope.getDefinition()) .computeNeedsEventDispatcher(project); needsEventDispatcherCache = computedValue; return computedValue; } } public IInterfaceDefinition[] resolveInterfaces() { assert scope instanceof TypeScope : "resolveInterfacesImpl should only be called on scope cache's for TypeScopes!"; assert scope .getDefinition() instanceof TypeDefinitionBase : "resolveInterfacesImpl should only be called on scope cache's for the scopes contained by types!"; IInterfaceDefinition[] interfs = interfacesCache != null ? interfacesCache.get() : null; if (interfs != null) return interfs; synchronized (this) { // check again in case another thread updated the value first interfs = interfacesCache != null ? interfacesCache.get() : null; if (interfs != null) return interfs; interfs = ((TypeDefinitionBase) scope.getDefinition()).resolveInterfacesImpl(project); interfacesCache = new SoftReference<IInterfaceDefinition[]>(interfs); return interfs; } } /** * Version of getNamespaceSetForName that caches the results - this is used * to get the namespace set to use to lookup a name - If name is an * explicitly imported definition, then the namespace set will consist of * the package name from the import(s) plus the open namespace set. If name * was not explitly imported then the open namespace set will be returned * * @param name the name to lookup * @return the namespace set to use to lookup name */ Set<INamespaceDefinition> getNamespaceSetForName(String name) { ConcurrentMap<String, Set<INamespaceDefinition>> map = getNamespacesForNameMap(); Set<INamespaceDefinition> result = map.get(name); if (result != null) { // We found a cached result - we're done return result; } // It is possible for 2+ threads to get in here for the same name. // This is intentional - the worst that happens is that we duplicate the resolution work // the benefit is that we avoid any sort of locking, which was proving expensive (time wise, // and memory wise). Set<INamespaceDefinition> newResult = scope.getNamespaceSetForNameImpl(project, name); result = map.putIfAbsent(name, newResult); if (result == null) result = newResult; return result; } /** * Version of addDependencyOnBuiltinType that uses a cache to determine if the dependency actually * needs to be added. The act of adding a dependency is somewhat expensive, so using a cache * is much faster * * @param builtinType the type to depend on * @param dt the type of Dependency to add */ void addDependencyOnBuiltinType(IASLanguageConstants.BuiltinType builtinType, DependencyType dt) { Set<IASLanguageConstants.BuiltinType> set = getBuiltinTypeMap(); if (set.contains(builtinType)) { // We found a cached result - we're done return; } // It is possible for 2+ threads to get in here for the same name. // This is intentional - the worst that happens is that we duplicate the dependency work // the benefit is that we avoid any sort of locking, which was proving expensive (time wise, // and memory wise). scope.addDependencyOnBuiltinTypeImpl(project, builtinType, dt); set.add(builtinType); return; } /** * Used to cache no constant value results for the const value cache. * Computing the value is expensive whether there is a value or not, and * many constants will not have compile time constant values, so we want to * cache those as well. */ private static final Object NO_CONST_VALUE = new Object(); /** * get the constant value for the given const definition. If a compile time * constant can not be computed for the definition, this will return null. * * @param constDef The constant definition you want the constant value of * @return The constant value, or null if a compie time constant could not * be computed */ public Object getConstantValue(ConstantDefinition constDef) { ConcurrentMap<IDefinition, Object> map = getConstantValueLookupMap(); Object result = map.get(constDef); if (result != null) { // We found a cached result - we're done if (result == NO_CONST_VALUE) return null; return result; } // It is possible for 2+ threads to get in here for the same name. // This is intentional - the worst that happens is that we duplicate the resolution work // the benefit is that we avoid any sort of locking, which was proving expensive (time wise, // and memory wise). Object newResult = constDef.resolveValueImpl(project); if (newResult == null) newResult = NO_CONST_VALUE; result = map.putIfAbsent(constDef, newResult); if (result == null) result = newResult; if (result == NO_CONST_VALUE) return null; else return result; } /** * Helper class - to be used as a key for caching qualified name lookups. */ private static class QName { String name; INamespaceDefinition ns; QName(String name, INamespaceDefinition ns) { assert ns != null; this.name = name; this.ns = ns; } @Override public int hashCode() { return name.hashCode() ^ ns.hashCode(); } @Override public boolean equals(Object o) { if (o == this) return true; if (o instanceof QName) { QName other = (QName) o; return name.equals(other.name) && ns.equals(other.ns); } return false; } } }