Gradle

Clone Tools
  • last updated a few seconds ago
Constraints
Constraints: committers
 
Constraints: files
Constraints: dates
Fix early reset of cached filtered states

The cached filtered states should only be reset if we are

actually going to recompute them. Otherwise we do it too

early and it causes the test to check against `null` and

we would always say that it's a different dependency set.

Add more missing optimizations

Fix cached filtered states being reset too early

This was causing us to take the "short path" always, when we

shouldn't.

Add debug log processing script

Add ability to trace stack overflows only

Do not use heuristic to tell if we should revisit a node

The previous implementation assumed that if we visited a node once,

and then revisit later, and that the exclusion filter "excludes

the same things if we ignore artifacts", then we don't need to revisit.

The problem with this approach is that it's a heuristic, that in

practice compares the exclude specs. But, two exclude specs can

be _equivalent_ (they would exclude the same things) but not _equal_

(their structure is different, because for example they were reduced

differently because of ordering).

This commit removes this faulty `equalsIgnoreArtifact` method in

favor of a direct comparison of the result of excluding edges. If

both specs are equivalent, they will exclude the same edges.

Optimize A ∩ (B ∪ C)

-> (A ∩ B) ∪ (A ∩ C)

User data shows this can often be reduced to an empty set because

distribution will compute empty sets on both sides.

Add missing optimization of intersection

when module ids are different

Add missing optimization of intersection

Add a logging exclude factory

This factory is enabled if, and only if, the log level is set to debug (`-d`).

Then it will log all merge operations, and report if there's a stack overflow

in merging exclude specs.

Add test coverage for intersections of 3 elements

and add more test coverage for unions

Add more logging to exclusion of edges

Use constant mask instead of class hashcode

Add randomization of sets

Revert new exclude rule merging

This is a temporary revert to allow ironing out some issues with

the newer implementation.

  1. … 24 more files in changeset.
Rework test setup for exclude merging

Add mention to exclude merging in release notes

    • -0
    • +6
    /subprojects/docs/src/docs/release/notes.md
Use 5.5-rc1 wrapper as rc2 and rc3 are broken

    • -1
    • +1
    /gradle/wrapper/gradle-wrapper.properties
Fix incorrect reduction of intersections

Simplification of intersections in the normalizing exclude

factory is done by pairs. There was a bug in the reduction

algorithm, that would cause the reduction result to be

wrong because we used the wrong, non simplified, exclude spec

for merging whenever a merge occured, to reduce on the next

item in a list.

Optimize a couple more cases

Optimize intersect(group, module) -> moduleId(group, module)

Optimize intersect(group, module names) -> moduleIdSet(group + name...)

Fix incorrect simplification of intersection of unions

The result of simplification was only correct if there was one

item not in common on both hands of the intersection.

Fixes #9718

Update to latest RC

    • -1
    • +1
    /gradle/wrapper/gradle-wrapper.properties
Merge pull request #9701 from gradle/cc/dm/fix-exclude-perf

Fix exclude rule merging performance

Add exclude intersection normalization

This commit introduces exclude intersection normalization.

This is done to avoid the "exclusion explosion" in case:

- we have 2 incoming edges to the same node

- those edges have different excludes

- the different edge excludes cannot be merged (e.g having a `group` and `moduleId` exclude on each)

Add fast exit on fast iteration

This commit adds a fast exit path when the fast iterator

is exhausted: we don't have to iterate because we already

know there's no possible candidate.

Optimize `equalsIgnoreArtifact`

In some cases, calling `equalsIgnoreArtifact` may be extremely

costly. This optimizes the algorithm for different cases:

1. the specs we compare actually do not exclude artifacts, in

which case we can compare by equality

2. the specs we compare are in a different order, in which

case we can avoid deep `equals` calls

3. the specs we compare are different, but some of them are

equal and we should avoid considering them candidates again

Attach node selection failures to constraint edges

When a constraint edge cannot find target nodes, we check if a selection

failure needs to be attached.

Issue #9692

Revert performance ratcheting

Revert changes to TarFileTree and ZipFileTree that assume you always visit the entire archive

Reproduce #9673