You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@bval.apache.org by ta...@apache.org on 2026/07/24 23:32:22 UTC

(bval) 04/09: reduce allocations

This is an automated email from the ASF dual-hosted git repository.

asf-gitbox-commits pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/bval.git

commit ec653094b133d2008a03ff6730e2b1636a2eeaab
Author: tandraschko <ta...@apache.org>
AuthorDate: Fri Jul 24 18:24:26 2026 +0200

    reduce allocations
---
 .../org/apache/bval/jsr/job/ValidationJob.java     | 23 ++++++++---
 .../java/org/apache/bval/jsr/util/NodeImpl.java    | 48 ++++++++++++++++------
 2 files changed, 53 insertions(+), 18 deletions(-)

diff --git a/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java b/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java
index 670297f..12747bb 100644
--- a/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java
+++ b/bval-jsr/src/main/java/org/apache/bval/jsr/job/ValidationJob.java
@@ -559,12 +559,25 @@ public abstract class ValidationJob<T> {
     protected static final TypeVariable<?> ITERABLE_ELEMENT = Iterable.class.getTypeParameters()[0];
 
     private static Stream<ConstraintD<?>> constraintsFor(ElementD<?, ?> descriptor, GroupStrategy groups) {
+        // Resolve the target groups once per call rather than once per constraint: GroupStrategy.getGroups()
+        // may allocate (a singleton for a plain Group, a fully streamed-and-collected set for a Composite),
+        // and it is invariant across the constraints being filtered.
+        final Set<Group> targetGroups = groups.getGroups();
         return descriptor.getConstraintDescriptors().stream().<ConstraintD<?>> map(ConstraintD.class::cast)
-                .filter(c -> {
-                    final Set<Class<?>> constraintGroups = c.getGroups();
-                    return groups.getGroups().stream().map(Group::getGroup).anyMatch(g -> constraintGroups.contains(g)
-                            || constraintGroups.contains(Default.class) && c.getDeclaringClass().equals(g));
-                });
+                .filter(c -> matchesGroups(c, targetGroups));
+    }
+
+    private static boolean matchesGroups(ConstraintD<?> constraint, Set<Group> targetGroups) {
+        final Set<Class<?>> constraintGroups = constraint.getGroups();
+        final boolean impliesDefault = constraintGroups.contains(Default.class);
+        for (final Group target : targetGroups) {
+            final Class<?> g = target.getGroup();
+            if (constraintGroups.contains(g)
+                    || impliesDefault && constraint.getDeclaringClass().equals(g)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     protected final ApacheFactoryContext validatorContext;
diff --git a/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java b/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java
index f0b182b..7437d79 100644
--- a/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java
+++ b/bval-jsr/src/main/java/org/apache/bval/jsr/util/NodeImpl.java
@@ -78,6 +78,34 @@ public abstract class NodeImpl implements Path.Node, Serializable {
         return 0;
     }).thenComparing((Function<Object, String>) Objects::toString));
 
+    // Per-kind node comparators are stateless and constant; hoisted to static finals so they are not
+    // re-allocated on every compareSpecificNodeInfo/compareIterability call (both are hot during path
+    // comparison, e.g. violation de-duplication).
+    private static final Comparator<Node> KEY_NODE_COMPARATOR = comparing(Node::getKey, KEY_COMPARATOR);
+
+    private static final Comparator<Node> BEAN_NODE_COMPARATOR =
+        comparing(to(BeanNode.class), comparing(BeanNode::getContainerClass, CLASS_COMPARATOR)
+            .thenComparing(BeanNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+
+    private static final Comparator<Node> PROPERTY_NODE_COMPARATOR =
+        comparing(to(PropertyNode.class), comparing(PropertyNode::getContainerClass, CLASS_COMPARATOR)
+            .thenComparing(PropertyNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+
+    private static final Comparator<Node> CONTAINER_ELEMENT_NODE_COMPARATOR =
+        comparing(to(ContainerElementNode.class), comparing(ContainerElementNode::getContainerClass, CLASS_COMPARATOR)
+            .thenComparing(ContainerElementNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+
+    private static final Comparator<Node> CONSTRUCTOR_NODE_COMPARATOR =
+        comparing(to(ConstructorNode.class).andThen(ConstructorNode::getParameterTypes),
+            Comparators.comparingIterables(CLASS_COMPARATOR));
+
+    private static final Comparator<Node> METHOD_NODE_COMPARATOR =
+        comparing(to(MethodNode.class).andThen(MethodNode::getParameterTypes),
+            Comparators.comparingIterables(CLASS_COMPARATOR));
+
+    private static final Comparator<Node> PARAMETER_NODE_COMPARATOR =
+        comparing(to(ParameterNode.class).andThen(ParameterNode::getParameterIndex));
+
     private static final char INDEX_OPEN = '[';
     private static final char INDEX_CLOSE = ']';
 
@@ -144,7 +172,7 @@ public abstract class NodeImpl implements Path.Node, Serializable {
         if (quid.isInIterable()) {
             if (quo.isInIterable()) {
                 if (quid.getKey() != null) {
-                    return Comparator.comparing(Node::getKey, KEY_COMPARATOR).compare(quid, quo);
+                    return KEY_NODE_COMPARATOR.compare(quid, quo);
                 }
                 if (quo.getKey() != null) {
                     return -1;
@@ -173,28 +201,22 @@ public abstract class NodeImpl implements Path.Node, Serializable {
         final Comparator<Node> cmp;
         switch (kind) {
         case BEAN:
-            cmp = comparing(to(BeanNode.class), comparing(BeanNode::getContainerClass, CLASS_COMPARATOR)
-                .thenComparing(BeanNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+            cmp = BEAN_NODE_COMPARATOR;
             break;
         case PROPERTY:
-            cmp = comparing(to(PropertyNode.class), comparing(PropertyNode::getContainerClass, CLASS_COMPARATOR)
-                .thenComparing(PropertyNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+            cmp = PROPERTY_NODE_COMPARATOR;
             break;
         case CONTAINER_ELEMENT:
-            cmp = comparing(to(ContainerElementNode.class),
-                comparing(ContainerElementNode::getContainerClass, CLASS_COMPARATOR)
-                    .thenComparing(ContainerElementNode::getTypeArgumentIndex, nullsFirst(naturalOrder())));
+            cmp = CONTAINER_ELEMENT_NODE_COMPARATOR;
             break;
         case CONSTRUCTOR:
-            cmp = comparing(to(ConstructorNode.class).andThen(ConstructorNode::getParameterTypes),
-                Comparators.comparingIterables(CLASS_COMPARATOR));
+            cmp = CONSTRUCTOR_NODE_COMPARATOR;
             break;
         case METHOD:
-            cmp = comparing(to(MethodNode.class).andThen(MethodNode::getParameterTypes),
-                Comparators.comparingIterables(CLASS_COMPARATOR));
+            cmp = METHOD_NODE_COMPARATOR;
             break;
         case PARAMETER:
-            cmp = comparing(to(ParameterNode.class).andThen(ParameterNode::getParameterIndex));
+            cmp = PARAMETER_NODE_COMPARATOR;
             break;
         default:
             return 0;