[ 
https://issues.apache.org/jira/browse/GROOVY-12725?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18143992#comment-18143992
 ] 

ASF GitHub Bot commented on GROOVY-12725:
-----------------------------------------

blackdrag commented on PR #3260:
URL: https://github.com/apache/groovy/pull/3260#issuecomment-6834554092

   There are two aspects I would like to see addressed before merging:
   
   **1. Verify cache behavior across different classloaders**
   
   `DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE` is static and shared across 
compiler instances, whereas class visibility is determined by the classloader 
used for each compilation.
   
   The new partial-cache algorithm appears to account for this by checking 
higher-precedence packages before accepting a previously discovered 
lower-precedence package. However, the regression tests currently do not 
establish that resolution remains independent of compilation history across 
different classloaders.
   
   I suggest adding a test along these lines:
   
   - Classloader A can resolve `groovy.util.X`, but not `groovy.lang.X`.
   - Compile a reference to `X` using A.
   - Classloader B can resolve `groovy.lang.X`, but not `groovy.util.X`.
   - Compile a reference to `X` using B.
   - Compile another reference using A.
   
   The expected resolutions are respectively `groovy.util.X`, `groovy.lang.X` 
and `groovy.util.X`.
   
   This would verify that the globally shared cache does not cause one 
compilation's classloader visibility to influence another compilation's 
resolution.
   
   **2. Make the cache-state invariant explicit**
   
   The distinction between complete and partial cache entries currently relies 
on object identity:
   
   ```java
   known == indexed
   ```
   
   This works with the current implementation because startup index entries are 
shared with the cache, while subsequent updates replace cache values rather 
than modifying them.
   
   However, object identity now carries semantic meaning: it determines which 
resolution algorithm is used. This is an important invariant for anyone 
modifying this code in the future.
   
   I suggest documenting explicitly that startup entries represent the complete 
index, dynamically discovered entries are only partial information, and cache 
updates must preserve this distinction.
   
   I would also consider a concurrency regression test for simultaneous 
resolutions of the same name. The replacement-based update strategy using 
`ConcurrentHashMap.compute` looks appropriate, but the current tests do not 
exercise concurrent readers and writers.
   
   Overall, I agree with the implementation direction. These suggestions are 
primarily about establishing and preserving the correctness properties on which 
the optimization depends.




> Preserve default-import package precedence and thread-safety in ResolveVisitor
> ------------------------------------------------------------------------------
>
>                 Key: GROOVY-12725
>                 URL: https://issues.apache.org/jira/browse/GROOVY-12725
>             Project: Groovy
>          Issue Type: Bug
>            Reporter: Daniel Sun
>            Assignee: Daniel Sun
>            Priority: Major
>
> h2. Overview
> {{ResolveVisitor}} maintains a process-wide cache 
> ({{DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE}}) mapping simple class names to 
> the set of default-imported package prefixes ({{java.lang.}}, {{java.io.}}, 
> {{java.net.}}, {{java.util.}}, {{groovy.lang.}}, {{groovy.util.}}) that 
> contain a class with that simple name. Three issues in how this cache is 
> initialized and updated can cause package precedence inversion, lost package 
> mappings for colliding class names, or data races during concurrent 
> compilation.
> h2. Problem Description
> h3. 1. Overwritten package mappings in {{Java9.getDefaultImportClasses}}
> {{Java9.getDefaultImportClasses(String[] packageNames)}} previously populated 
> its result map via {{result.putAll(doFindClasses(...))}} across 
> {{groovy-core}} locations and {{jrt:/modules/java.base/}}. When the same 
> simple class name exists in both a Groovy default-imported package and a Java 
> default-imported package (for example, {{Proxy}} in both {{java.net.Proxy}} 
> and {{groovy.util.Proxy}}), the later {{putAll}} call overwrote the earlier 
> entry instead of merging both package prefixes. In addition, the stored value 
> sets were mutable, unordered {{HashSet}} instances rather than unmodifiable 
> sets ordered by {{ResolveVisitor.DEFAULT_IMPORTS}}.
> {code:java}
> URI gcjLocation = 
> DefaultGroovyMethods.getLocation(gcl.loadClass("groovy.lang.GroovySystem")).toURI();
> result.putAll(doFindClasses(gcjLocation, "groovy", groovyPackages));
> ...
> result.putAll(doFindClasses(URI.create("jrt:/modules/java.base/"), "java", 
> javaPackages));
> {code}
> h3. 2. Non-atomic {{Map}} default methods in {{UnlimitedConcurrentCache}}
> {{UnlimitedConcurrentCache}} wraps a {{ConcurrentHashMap}} and implements 
> {{EvictableCache}} (which extends {{java.util.Map}}), but did not override 
> the atomic {{Map}} methods introduced in Java 8 ({{compute}}, 
> {{computeIfAbsent}}, {{computeIfPresent}}, {{merge}}, {{putIfAbsent}}, 
> {{remove(Object, Object)}}, and {{replace}}). Consequently, calling 
> {{DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE.computeIfAbsent(...)}} invoked the 
> non-atomic {{Map}} default method rather than 
> {{ConcurrentHashMap.computeIfAbsent}}.
> h3. 3. In-place {{HashSet}} mutation and lost {{DEFAULT_IMPORTS}} ordering in 
> {{ResolveVisitor.resolveFromDefaultImports}}
> On a cache miss during {{resolveFromDefaultImports}}, {{ResolveVisitor}} 
> obtained a mutable {{HashSet}} from 
> {{DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE}} and mutated it in place:
> {code:java}
> Set<String> packagePrefixSet = 
> DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE.computeIfAbsent(typeName, key -> new 
> HashSet<>(2));
> packagePrefixSet.add(packagePrefix);
> {code}
> * Concurrent compiler threads iterating over the cached {{Set<String>}} could 
> race with in-place {{HashSet.add}} mutations.
> * Because {{HashSet}} iteration order is arbitrary and does not follow 
> {{ResolveVisitor.DEFAULT_IMPORTS}}, discovering a class in a lower-precedence 
> package (e.g. {{groovy.util.}}) before a higher-precedence package (e.g. 
> {{groovy.lang.}}) could cause subsequent lookups to resolve the 
> lower-precedence class even when both are available on the classpath.
> h2. Solution
> * Merge package sets across all scanned locations in 
> {{Java9.getDefaultImportClasses}} instead of overwriting entries with 
> {{Map.putAll}}, and store unmodifiable sets ordered according to 
> {{packageNames}} ({{ResolveVisitor.DEFAULT_IMPORTS}}).
> * Delegate atomic {{Map}} operations ({{compute}}, {{computeIfAbsent}}, 
> {{computeIfPresent}}, {{merge}}, {{putIfAbsent}}, {{remove(Object, Object)}}, 
> {{replace}}, {{replaceAll}}, {{getOrDefault}}, and {{forEach}}) in 
> {{UnlimitedConcurrentCache}} directly to the underlying {{ConcurrentHashMap}}.
> * Update {{ResolveVisitor.DEFAULT_IMPORT_CLASS_AND_PACKAGES_CACHE}} 
> atomically via {{compute(...)}} using unmodifiable sets ordered according to 
> {{DEFAULT_IMPORTS}}, preventing concurrent mutation races and preserving 
> default-import package precedence.



--
This message was sent by Atlassian Jira
(v10.3.26#10030026)

Reply via email to