Optimize LeafListEffectiveStatement layout

We can save a field in case the declared statement's argument matches
the effective argument.

JIRA: YANGTOOLS-1316
Change-Id: I980730aa3272f9c8280f16eaf5f77201d3870f30
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java
index dbc2e2701e99e5cb91f0dd8cf9d46c82ea6e7ba4..aec44da1e449a96878765d08f494a0f7a3ae5b6c 100644 (file)
--- a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java
+++ b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/EffectiveStatements.java
@@ -588,8 +588,8 @@ public final class EffectiveStatements {
             final ImmutableSet<String> defaultValues, final @Nullable ElementCountConstraint elementCountConstraint)
                 throws SubstatementIndexingException {
         if (defaultValues.isEmpty()) {
-            return elementCountConstraint == null
-                ? new EmptyLeafListEffectiveStatement(declared, argument, flags, substatements)
+            return elementCountConstraint == null && argument.equals(declared.argument())
+                ? new EmptyLeafListEffectiveStatement(declared, flags, substatements)
                     : new SlimLeafListEffectiveStatement(declared, argument, flags, substatements,
                         elementCountConstraint);
         }

diff --git a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractLeafListEffectiveStatement.java b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractLeafListEffectiveStatement.java
index 881d98b6ad267f649f96522624ea4ffcbe1229d5..cad099ca913360c6b5b88f93b3d8e78b3ed1dd41 100644 (file)
--- a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractLeafListEffectiveStatement.java
+++ b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractLeafListEffectiveStatement.java
@@ -7,9 +7,9 @@
  */
 package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
 
-import static java.util.Objects.requireNonNull;
-
 import com.google.common.collect.ImmutableList;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.VarHandle;
 import org.eclipse.jdt.annotation.NonNull;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.LeafListSchemaNode;
@@ -33,29 +33,34 @@ abstract class AbstractLeafListEffectiveStatement
         extends AbstractDeclaredEffectiveStatement.Default<QName, LeafListStatement>
         implements LeafListEffectiveStatement, LeafListSchemaNode, UserOrderedMixin<QName, LeafListStatement>,
             DataSchemaNodeMixin<LeafListStatement>, MustConstraintMixin<QName, LeafListStatement> {
+    private static final VarHandle TYPE;
+
+    static {
+        try {
+            TYPE = MethodHandles.lookup().findVarHandle(AbstractLeafListEffectiveStatement.class, "type",
+                TypeDefinition.class);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new ExceptionInInitializerError(e);
+        }
+    }
+
     private final @NonNull Object substatements;
-    private final @NonNull QName argument;
-    private final @NonNull TypeDefinition<?> type;
     private final int flags;
 
-    AbstractLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
+    @SuppressWarnings("unused")
+    private volatile TypeDefinition<?> type;
+
+    AbstractLeafListEffectiveStatement(final LeafListStatement declared, final int flags,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
         super(declared);
-        this.argument = requireNonNull(argument);
         this.substatements = maskList(substatements);
         this.flags = flags;
-        // TODO: lazy instantiation?
-        this.type = buildType();
     }
 
-    AbstractLeafListEffectiveStatement(final AbstractLeafListEffectiveStatement original, final QName argument,
-            final int flags) {
+    AbstractLeafListEffectiveStatement(final AbstractLeafListEffectiveStatement original, final int flags) {
         super(original);
-        this.argument = requireNonNull(argument);
-        this.substatements = original.substatements;
+        substatements = original.substatements;
         this.flags = flags;
-        // TODO: lazy instantiation?
-        this.type = buildType();
     }
 
     @Override
@@ -68,16 +73,6 @@ abstract class AbstractLeafListEffectiveStatement
         return flags;
     }
 
-    @Override
-    public final QName argument() {
-        return argument;
-    }
-
-    @Override
-    public final TypeDefinition<?> getType() {
-        return type;
-    }
-
     @Override
     public final boolean isUserOrdered() {
         return userOrdered();
@@ -90,10 +85,16 @@ abstract class AbstractLeafListEffectiveStatement
 
     @Override
     public final String toString() {
-        return getClass().getSimpleName() + "[" + argument + "]";
+        return getClass().getSimpleName() + "[" + argument() + "]";
     }
 
-    private TypeDefinition<?> buildType() {
+    @Override
+    public final TypeDefinition<?> getType() {
+        final var local = (TypeDefinition<?>) TYPE.getAcquire(this);
+        return local != null ? local : loadType();
+    }
+
+    private TypeDefinition<?> loadType() {
         final TypeEffectiveStatement<?> typeStmt = findFirstEffectiveSubstatement(TypeEffectiveStatement.class).get();
         final ConcreteTypeBuilder<?> builder = ConcreteTypes.concreteTypeBuilder(typeStmt.getTypeDefinition(),
             getQName());
@@ -109,6 +110,9 @@ abstract class AbstractLeafListEffectiveStatement
                 builder.setUnits(((UnitsEffectiveStatement)stmt).argument());
             }
         }
-        return builder.build();
+
+        final var ret = builder.build();
+        final var witness = (TypeDefinition<?>) TYPE.compareAndExchangeRelease(this, null, ret);
+        return witness != null ? witness : ret;
     }
 }

diff --git a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractNonEmptyLeafListEffectiveStatement.java b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractNonEmptyLeafListEffectiveStatement.java
index 16201215ede78dbb920ba23b9300ae83363ca065..439a9d0e54b8f03bc36335129819fc01f706d4ed 100644 (file)
--- a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractNonEmptyLeafListEffectiveStatement.java
+++ b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/AbstractNonEmptyLeafListEffectiveStatement.java
@@ -7,8 +7,11 @@
  */
 package org.opendaylight.yangtools.yang.model.ri.stmt.impl.eff;
 
+import static java.util.Objects.requireNonNull;
+
 import com.google.common.collect.ImmutableList;
 import java.util.Optional;
+import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.Nullable;
 import org.opendaylight.yangtools.yang.common.QName;
 import org.opendaylight.yangtools.yang.model.api.ElementCountConstraint;
@@ -17,26 +20,35 @@ import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
 
 abstract class AbstractNonEmptyLeafListEffectiveStatement extends AbstractLeafListEffectiveStatement {
     private final @Nullable ElementCountConstraint elementCountConstraint;
+    private final @NonNull QName argument;
 
     AbstractNonEmptyLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements,
             final ElementCountConstraint elementCountConstraint) {
-        super(declared, argument, flags, substatements);
+        super(declared, flags, substatements);
+        this.argument = requireNonNull(argument);
         this.elementCountConstraint = elementCountConstraint;
     }
 
     AbstractNonEmptyLeafListEffectiveStatement(final AbstractNonEmptyLeafListEffectiveStatement originalEffecive,
             final QName argument, final int flags) {
-        super(originalEffecive, argument, flags);
+        super(originalEffecive, flags);
+        this.argument = requireNonNull(argument);
         elementCountConstraint = originalEffecive.elementCountConstraint;
     }
 
     AbstractNonEmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement originalEffective,
             final QName argument, final int flags) {
-        super(originalEffective, argument, flags);
+        super(originalEffective, flags);
+        this.argument = requireNonNull(argument);
         elementCountConstraint = null;
     }
 
+    @Override
+    public final QName argument() {
+        return argument;
+    }
+
     @Override
     public final Optional<ElementCountConstraint> getElementCountConstraint() {
         return Optional.ofNullable(elementCountConstraint);

diff --git a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/EmptyLeafListEffectiveStatement.java b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/EmptyLeafListEffectiveStatement.java
index 03735a5d6f51d9bb504601b0cf1fe9793cab689c..c2166a3e844f37b6992b0dcbce97f773cd3b7959 100644 (file)
--- a/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/EmptyLeafListEffectiveStatement.java
+++ b/model/yang-model-ri/src/main/java/org/opendaylight/yangtools/yang/model/ri/stmt/impl/eff/EmptyLeafListEffectiveStatement.java
@@ -17,14 +17,18 @@ import org.opendaylight.yangtools.yang.model.api.meta.EffectiveStatement;
 import org.opendaylight.yangtools.yang.model.api.stmt.LeafListStatement;
 
 public final class EmptyLeafListEffectiveStatement extends AbstractLeafListEffectiveStatement {
-    public EmptyLeafListEffectiveStatement(final LeafListStatement declared, final QName argument, final int flags,
+    public EmptyLeafListEffectiveStatement(final LeafListStatement declared, final int flags,
             final ImmutableList<? extends EffectiveStatement<?, ?>> substatements) {
-        super(declared, argument, flags, substatements);
+        super(declared, flags, substatements);
     }
 
-    public EmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement original, final QName argument,
-            final int flags) {
-        super(original, argument, flags);
+    public EmptyLeafListEffectiveStatement(final EmptyLeafListEffectiveStatement original, final int flags) {
+        super(original, flags);
+    }
+
+    @Override
+    public QName argument() {
+        return getDeclared().argument();
     }
 
     @Override