perf: faster cloning (#1650)

- Uses method/field handles instead of reflection.
- Special handling for EnumMap and EnumSet.
- Reduction of map access.
- Better sizing of internal collections for repeated operations.

Overall, these changes bring ~30 % throughput improvement in a cloning
benchmark.

Author: triceo

core/src/main/java/ai/timefold/solver/core/impl/domain/common/accessor/FieldHandle.java

@@ -0,0 +1,47 @@
+package ai.timefold.solver.core.impl.domain.common.accessor;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.reflect.Field;
+
+public record FieldHandle(Field field, MethodHandle getter, MethodHandle setter) {
+
+    public static FieldHandle of(Field field) {
+        try {
+            field.setAccessible(true);
+            var getter = MethodHandles.lookup().unreflectGetter(field);
+            var setter = MethodHandles.lookup().unreflectSetter(field);
+            return new FieldHandle(field, getter, setter);
+        } catch (IllegalAccessException e) {
+            throw new IllegalStateException(
+                    "The field (%s) cannot be accessed to create a planning clone."
+                            .formatted(field),
+                    e);
+        }
+    }
+
+    public Object get(Object bean) {
+        try { // Don't null-check the bean; if null, it fails anyway.
+            return getter.invoke(bean);
+        } catch (Throwable e) {
+            var beanClass = bean == null ? "null" : bean.getClass();
+            throw new IllegalStateException(
+                    "Cannot get the field (%s) on bean of class (%s)."
+                            .formatted(field.getName(), beanClass),
+                    e);
+        }
+    }
+
+    public void set(Object bean, Object value) {
+        try { // Don't null-check the bean; if null, it fails anyway.
+            setter.invoke(bean, value);
+        } catch (Throwable e) {
+            var beanClass = bean == null ? "null" : bean.getClass();
+            throw new IllegalStateException(
+                    "Cannot set the field (%s) on bean of class (%s)."
+                            .formatted(field.getName(), beanClass),
+                    e);
+        }
+    }
+
+}

core/src/main/java/ai/timefold/solver/core/impl/domain/common/accessor/ReflectionFieldMemberAccessor.java

@@ -9,49 +9,40 @@
  */
 public final class ReflectionFieldMemberAccessor extends AbstractMemberAccessor {
 
-    private final Field field;
+    private final FieldHandle fieldHandle;
 
     public ReflectionFieldMemberAccessor(Field field) {
-        this.field = field;
-        // Performance hack by avoiding security checks
-        field.setAccessible(true);
+        this.fieldHandle = FieldHandle.of(field); // Use MethodHandles to access the field.
     }
 
     @Override
     public Class<?> getDeclaringClass() {
-        return field.getDeclaringClass();
+        return fieldHandle.field().getDeclaringClass();
     }
 
     @Override
     public String getName() {
-        return field.getName();
+        return fieldHandle.field().getName();
     }
 
     @Override
     public Class<?> getType() {
-        return field.getType();
+        return fieldHandle.field().getType();
     }
 
     @Override
     public Type getGenericType() {
-        return field.getGenericType();
+        return fieldHandle.field().getGenericType();
     }
 
     @Override
     public Object executeGetter(Object bean) {
+        var field = fieldHandle.field();
         if (bean == null) {
             throw new IllegalArgumentException("Requested field (%s) on a null bean."
                     .formatted(field));
         }
-        try {
-            return field.get(bean);
-        } catch (IllegalAccessException e) {
-            throw new IllegalStateException("""
-                    Cannot get the field (%s) on bean of class (%s).
-                    %s"""
-                    .formatted(field.getName(), bean.getClass(), MemberAccessorFactory.CLASSLOADER_NUDGE_MESSAGE),
-                    e);
-        }
+        return fieldHandle.get(bean);
     }
 
     @Override
@@ -61,19 +52,12 @@ public boolean supportSetter() {
 
     @Override
     public void executeSetter(Object bean, Object value) {
+        var field = fieldHandle.field();
         if (bean == null) {
             throw new IllegalArgumentException("Requested field (%s) on a null bean."
                     .formatted(field));
         }
-        try {
-            field.set(bean, value);
-        } catch (IllegalAccessException e) {
-            throw new IllegalStateException("""
-                    Cannot set the field (%s) on bean of class (%s).
-                    %s"""
-                    .formatted(field.getName(), bean.getClass(), MemberAccessorFactory.CLASSLOADER_NUDGE_MESSAGE),
-                    e);
-        }
+        fieldHandle.set(bean, value);
     }
 
     @Override
@@ -83,17 +67,17 @@ public String getSpeedNote() {
 
     @Override
     public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
-        return field.getAnnotation(annotationClass);
+        return fieldHandle.field().getAnnotation(annotationClass);
     }
 
     @Override
     public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
-        return field.getDeclaredAnnotationsByType(annotationClass);
+        return fieldHandle.field().getDeclaredAnnotationsByType(annotationClass);
     }
 
     @Override
     public String toString() {
-        return "field " + field;
+        return "field " + fieldHandle.field();
     }
 
 }

core/src/main/java/ai/timefold/solver/core/impl/domain/solution/cloner/DeepCloningFieldCloner.java

@@ -5,6 +5,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
+import ai.timefold.solver.core.impl.domain.common.accessor.FieldHandle;
 import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
 
 /**
@@ -14,14 +15,14 @@ final class DeepCloningFieldCloner {
 
     private final AtomicReference<Metadata> valueDeepCloneDecision = new AtomicReference<>();
     private final AtomicInteger fieldDeepCloneDecision = new AtomicInteger(-1);
-    private final Field field;
+    private final FieldHandle fieldHandle;
 
     public DeepCloningFieldCloner(Field field) {
-        this.field = Objects.requireNonNull(field);
+        this.fieldHandle = FieldHandle.of(Objects.requireNonNull(field));
     }
 
-    public Field getField() {
-        return field;
+    public FieldHandle getFieldHandles() {
+        return fieldHandle;
     }
 
     /**
@@ -33,11 +34,11 @@ public Field getField() {
      * @param <C>
      */
     public <C> Object clone(SolutionDescriptor<?> solutionDescriptor, C original, C clone) {
-        Object originalValue = FieldCloningUtils.getObjectFieldValue(original, field);
+        Object originalValue = FieldCloningUtils.getObjectFieldValue(original, fieldHandle);
         if (deepClone(solutionDescriptor, original.getClass(), originalValue)) { // Defer filling in the field.
             return originalValue;
         } else { // Shallow copy.
-            FieldCloningUtils.setObjectFieldValue(clone, field, originalValue);
+            FieldCloningUtils.setObjectFieldValue(clone, fieldHandle, originalValue);
             return null;
         }
     }
@@ -77,7 +78,8 @@ private boolean deepClone(SolutionDescriptor<?> solutionDescriptor, Class<?> fie
          * The fieldTypeClass is guaranteed to not change for the particular field.
          */
         if (fieldDeepCloneDecision.get() < 0) {
-            fieldDeepCloneDecision.set(DeepCloningUtils.isFieldDeepCloned(solutionDescriptor, field, fieldTypeClass) ? 1 : 0);
+            fieldDeepCloneDecision.set(
+                    DeepCloningUtils.isFieldDeepCloned(solutionDescriptor, getFieldHandles().field(), fieldTypeClass) ? 1 : 0);
         }
         return fieldDeepCloneDecision.get() == 1;
     }