X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-inmemory-datastore%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fstore%2Fimpl%2FResolveDataChangeState.java;h=6bbed57f392db63c647f704ef71a5d223384d60a;hp=dca2eff70558c03de97c36aa46436caf21244a92;hb=ab3be1c3e568b4daa9a98e026dc3fc7649a5b25c;hpb=f0f107f9b889b728be457cf84289b53386d7d301 diff --git a/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeState.java b/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeState.java index dca2eff705..6bbed57f39 100644 --- a/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeState.java +++ b/opendaylight/md-sal/sal-inmemory-datastore/src/main/java/org/opendaylight/controller/md/sal/dom/store/impl/ResolveDataChangeState.java @@ -7,11 +7,6 @@ */ package org.opendaylight.controller.md.sal.dom.store.impl; -import com.google.common.base.Optional; -import com.google.common.base.Preconditions; -import com.google.common.collect.Iterables; -import com.google.common.collect.Multimap; - import java.util.ArrayList; import java.util.Collection; import java.util.Collections; @@ -22,7 +17,7 @@ import java.util.Map.Entry; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; import org.opendaylight.controller.md.sal.dom.store.impl.DOMImmutableDataChangeEvent.Builder; -import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerTree.Node; +import org.opendaylight.controller.md.sal.dom.store.impl.tree.ListenerNode; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; @@ -32,6 +27,11 @@ import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.base.Optional; +import com.google.common.base.Preconditions; +import com.google.common.collect.Iterables; +import com.google.common.collect.Multimap; + /** * Recursion state used in {@link ResolveDataChangeEventsTask}. Instances of this * method track which listeners are affected by a particular change node. It takes @@ -47,17 +47,17 @@ final class ResolveDataChangeState { /** * Inherited from immediate parent */ - private final Iterable inheritedOne; + private final Collection inheritedOne; private final YangInstanceIdentifier nodeId; - private final Collection nodes; + private final Collection nodes; - private final Map, Builder> subBuilders = new HashMap<>(); - private final Map, Builder> oneBuilders = new HashMap<>(); - private final Map, Builder> baseBuilders = new HashMap<>(); + private final Map, Builder> subBuilders; + private final Map, Builder> oneBuilders; + private final Map, Builder> baseBuilders; private ResolveDataChangeState(final YangInstanceIdentifier nodeId, - final Iterable inheritedSub, final Iterable inheritedOne, - final Collection nodes) { + final Iterable inheritedSub, final Collection inheritedOne, + final Collection nodes) { this.nodeId = Preconditions.checkNotNull(nodeId); this.nodes = Preconditions.checkNotNull(nodes); this.inheritedSub = Preconditions.checkNotNull(inheritedSub); @@ -66,22 +66,36 @@ final class ResolveDataChangeState { /* * Collect the nodes which need to be propagated from us to the child. */ - for (Node n : nodes) { + final Map, Builder> sub = new HashMap<>(); + final Map, Builder> one = new HashMap<>(); + final Map, Builder> base = new HashMap<>(); + for (ListenerNode n : nodes) { for (DataChangeListenerRegistration l : n.getListeners()) { final Builder b = DOMImmutableDataChangeEvent.builder(DataChangeScope.BASE); switch (l.getScope()) { case BASE: - baseBuilders.put(l, b); + base.put(l, b); break; case ONE: - oneBuilders.put(l, b); + one.put(l, b); break; case SUBTREE: - subBuilders.put(l, b); + sub.put(l, b); break; } } } + + baseBuilders = maybeEmpty(base); + oneBuilders = maybeEmpty(one); + subBuilders = maybeEmpty(sub); + } + + private static Map maybeEmpty(final Map map) { + if (map.isEmpty()) { + return Collections.emptyMap(); + } + return map; } /** @@ -91,7 +105,7 @@ final class ResolveDataChangeState { * @param root root node * @return */ - public static ResolveDataChangeState initial(final YangInstanceIdentifier rootId, final Node root) { + public static ResolveDataChangeState initial(final YangInstanceIdentifier rootId, final ListenerNode root) { return new ResolveDataChangeState(rootId, Collections.emptyList(), Collections.emptyList(), Collections.singletonList(root)); } @@ -103,8 +117,38 @@ final class ResolveDataChangeState { * @return State handle */ public ResolveDataChangeState child(final PathArgument childId) { - return new ResolveDataChangeState(nodeId.node(childId), - Iterables.concat(inheritedSub, subBuilders.values()), + /* + * We instantiate a concatenation only when needed: + * + * 1) If our collection is empty, we reuse the parent's. This is typically the case + * for intermediate node, which should be the vast majority. + * 2) If the parent's iterable is a Collection and it is empty, reuse our collection. + * This is the case for the first node which defines a subtree listener in a + * particular subtree. + * 3) Concatenate the two collections. This happens when we already have some + * subtree listeners and we encounter a node which adds a few more. + * + * This allows us to lower number of objects allocated and also + * speeds up Iterables.isEmpty() in needsProcessing(). + * + * Note that the check for Collection in 2) relies on precisely this logic, which + * ensures that we simply cannot see an empty concatenation, but rather start off with + * an empty collection, then switch to a non-empty collection and finally switch to + * a concatenation. This saves us from instantiating iterators, which a trivial + * Iterables.isEmpty() would do as soon as we cross case 3). + */ + final Iterable sb; + if (!subBuilders.isEmpty()) { + if (inheritedSub instanceof Collection && ((Collection) inheritedSub).isEmpty()) { + sb = subBuilders.values(); + } else { + sb = Iterables.concat(inheritedSub, subBuilders.values()); + } + } else { + sb = inheritedSub; + } + + return new ResolveDataChangeState(nodeId.node(childId), sb, oneBuilders.values(), getListenerChildrenWildcarded(nodes, childId)); } @@ -127,16 +171,28 @@ final class ResolveDataChangeState { if (!nodes.isEmpty()) { return true; } - // Have SUBTREE listeners - if (!Iterables.isEmpty(inheritedSub)) { - return true; - } // Have ONE listeners - if (!Iterables.isEmpty(inheritedOne)) { + if (!inheritedOne.isEmpty()) { return true; } - // FIXME: do we need anything else? If not, flip this to 'false' + /* + * Have SUBTREE listeners + * + * This is slightly magical replacement for !Iterables.isEmpty(inheritedSub). + * It relies on the logic in child(), which gives us the guarantee that when + * inheritedSub is not a Collection, it is guaranteed to be non-empty (which + * means we need to process). If it is a collection, we still need to check + * it for emptiness. + * + * Unlike Iterables.isEmpty() this code does not instantiate any temporary + * objects and is thus more efficient. + */ + if (inheritedSub instanceof Collection) { + return !((Collection) inheritedSub).isEmpty(); + } + + // Non-Collection => non-empty => have to process return true; } @@ -201,13 +257,13 @@ final class ResolveDataChangeState { LOG.trace("Collected events {}", map); } - private static Collection getListenerChildrenWildcarded(final Collection parentNodes, + private static Collection getListenerChildrenWildcarded(final Collection parentNodes, final PathArgument child) { if (parentNodes.isEmpty()) { return Collections.emptyList(); } - final List result = new ArrayList<>(); + final List result = new ArrayList<>(); if (child instanceof NodeWithValue || child instanceof NodeIdentifierWithPredicates) { NodeIdentifier wildcardedIdentifier = new NodeIdentifier(child.getNodeType()); addChildNodes(result, parentNodes, wildcardedIdentifier); @@ -216,9 +272,9 @@ final class ResolveDataChangeState { return result; } - private static void addChildNodes(final List result, final Collection parentNodes, final PathArgument childIdentifier) { - for (Node node : parentNodes) { - Optional child = node.getChild(childIdentifier); + private static void addChildNodes(final List result, final Collection parentNodes, final PathArgument childIdentifier) { + for (ListenerNode node : parentNodes) { + Optional child = node.getChild(childIdentifier); if (child.isPresent()) { result.add(child.get()); }