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=e9b91e5a792ae831c152c8683a739f7780142720;hp=dca2eff70558c03de97c36aa46436caf21244a92;hb=978152c5de3bf78ab6da5da4c2db391eec063429;hpb=080d0047c6c66f4be727a1dec32cad54585bc471 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..e9b91e5a79 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,9 @@ */ 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; @@ -19,10 +17,9 @@ import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; - import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.dom.spi.RegistrationTreeNode; 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.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates; @@ -47,17 +44,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,34 +63,48 @@ final class ResolveDataChangeState { /* * Collect the nodes which need to be propagated from us to the child. */ - for (Node n : nodes) { - for (DataChangeListenerRegistration l : n.getListeners()) { + final Map, Builder> sub = new HashMap<>(); + final Map, Builder> one = new HashMap<>(); + final Map, Builder> base = new HashMap<>(); + for (RegistrationTreeNode> n : nodes) { + for (DataChangeListenerRegistration l : n.getRegistrations()) { 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; } /** * Create an initial state handle at a particular root node. * * @param rootId root instance identifier - * @param root root node + * @param registrationTreeNode root node * @return */ - public static ResolveDataChangeState initial(final YangInstanceIdentifier rootId, final Node root) { + public static ResolveDataChangeState initial(final YangInstanceIdentifier rootId, final RegistrationTreeNode> registrationTreeNode) { return new ResolveDataChangeState(rootId, Collections.emptyList(), - Collections.emptyList(), Collections.singletonList(root)); + Collections.emptyList(), Collections.singletonList(registrationTreeNode)); } /** @@ -103,8 +114,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 +168,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 +254,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,11 +269,11 @@ 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); - if (child.isPresent()) { - result.add(child.get()); + private static void addChildNodes(final List>> result, final Collection>> parentNodes, final PathArgument childIdentifier) { + for (RegistrationTreeNode> node : parentNodes) { + RegistrationTreeNode> child = node.getExactChild(childIdentifier); + if (child != null) { + result.add(child); } } }